From d31233a79a10f5ba032134d84631303d0dbd8b2f Mon Sep 17 00:00:00 2001 From: Black Sheep <1922634136@qq.com> Date: Thu, 7 May 2026 11:29:21 +0600 Subject: [PATCH] feat: change waveform --- .gitignore | 17 + .python-version | 1 + .vscode/launch.json | 16 + README.md | 0 pyproject.toml | 33 + src/dataset.py | 431 +++++ src/handle/audio_agement.ipynb | 160 ++ src/handle/audio_analyze.py | 70 + src/handle/export_model_state_dict.py | 13 + src/handle/export_new_tsv.py | 37 + src/handle/export_vocab.py | 92 ++ src/handle/test.ipynb | 490 ++++++ src/handle/test.py | 220 +++ src/handle/text_handle.py | 195 +++ src/handle/text_normalizer.py | 126 ++ src/inference.ipynb | 580 +++++++ src/inference.py | 123 ++ src/model.py | 84 + src/tokenizer.py | 107 ++ src/train.py | 367 +++++ uv.lock | 2168 +++++++++++++++++++++++++ 21 files changed, 5330 insertions(+) create mode 100644 .gitignore create mode 100644 .python-version create mode 100644 .vscode/launch.json create mode 100644 README.md create mode 100644 pyproject.toml create mode 100644 src/dataset.py create mode 100644 src/handle/audio_agement.ipynb create mode 100644 src/handle/audio_analyze.py create mode 100644 src/handle/export_model_state_dict.py create mode 100644 src/handle/export_new_tsv.py create mode 100644 src/handle/export_vocab.py create mode 100644 src/handle/test.ipynb create mode 100644 src/handle/test.py create mode 100644 src/handle/text_handle.py create mode 100644 src/handle/text_normalizer.py create mode 100644 src/inference.ipynb create mode 100644 src/inference.py create mode 100644 src/model.py create mode 100644 src/tokenizer.py create mode 100644 src/train.py create mode 100644 uv.lock diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..fcfe8a5 --- /dev/null +++ b/.gitignore @@ -0,0 +1,17 @@ +# Python-generated files +__pycache__/ +*.py[oc] +build/ +dist/ +wheels/ +*.egg-info + +# Virtual environments +.venv + +# data +.checkpoints +.data +data +runs +config diff --git a/.python-version b/.python-version new file mode 100644 index 0000000..2c07333 --- /dev/null +++ b/.python-version @@ -0,0 +1 @@ +3.11 diff --git a/.vscode/launch.json b/.vscode/launch.json new file mode 100644 index 0000000..cf422b0 --- /dev/null +++ b/.vscode/launch.json @@ -0,0 +1,16 @@ +{ + // Use IntelliSense to learn about possible attributes. + // Hover to view descriptions of existing attributes. + // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387 + "version": "0.2.0", + "configurations": [ + + { + "name": "Python Debugger: Current File", + "type": "debugpy", + "request": "launch", + "program": "src/train.py", + "console": "integratedTerminal" + } + ] +} \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..e69de29 diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..de6887c --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,33 @@ +[project] +name = "study-asr" +version = "0.1.0" +description = "Add your description here" +readme = "README.md" +requires-python = ">=3.11" +dependencies = [ + "ipython>=9.10.1", + "librosa>=0.11.0", + "matplotlib>=3.10.8", + "mutagen>=1.47.0", + "numpy>=2.4.4", + "pandas>=3.0.2", + "pillow>=12.2.0", + "pydub>=0.25.1", + "pyrubberband>=0.4.0", + "setuptools<82", + "silero-vad>=6.2.1", + "tensorboard>=2.20.0", + "tensorboardx>=2.6.5", + "torch==2.8.0", + "torch-audiomentations>=0.12.0", + "torchaudio==2.8.0", + "torchcodec==0.7.0", + "tqdm>=4.67.3", + "webrtcvad>=2.0.10", +] + +[[index]] +url = "https://mirrors.aliyun.com/pypi/simple/" +default = true +# url = "https://pypi.tuna.tsinghua.edu.cn/simple/" + diff --git a/src/dataset.py b/src/dataset.py new file mode 100644 index 0000000..68c9f81 --- /dev/null +++ b/src/dataset.py @@ -0,0 +1,431 @@ +import random + +import torch +from torch import Tensor +from torch.utils.data import Dataset, DataLoader +import torchaudio +from torch_audiomentations import ApplyImpulseResponse, Gain, PitchShift, LowPassFilter, HighPassFilter +from torchaudio.transforms import Resample, TimeStretch +from pathlib import Path +import pandas as pd +from typing import List, TypedDict +from handle.text_normalizer import collapse_spaces, normalize_extended_uyghur_characters +from tokenizer import ASRTokenizer + + +# 单个样本的数据结构（Dataset.__getitem__ 返回） +class BatchItem(TypedDict): + waveform: Tensor # [time] + target_ids: Tensor # [seq_len] 目标文本的token IDs + target_text: str # 原始文本 + audio_path: str # 音频文件路径 + + +# 批量数据的数据结构（collate_fn 返回，DataLoader 输出） +class Batch(TypedDict): + waveforms: Tensor # [batch, time] + targets: Tensor # [batch, max_len] padding后的目标IDs + waveform_lengths: Tensor # [batch] 每个样本的实际Waveform长度 + target_lengths: Tensor # [batch] 每个样本的实际目标长度 + target_texts: List[str] # [batch] 原始文本列表 + audio_paths: List[str] # [batch] 音频路径列表 + +class TsvFormat(TypedDict): + client_id: str + path: str + sentence: str + up_votes: int + down_votes: int + age: str + gender: str + locale: str + +class NoiseAugmentor: + def __init__(self, noise_root: Path, sample_rate: int=16000): + self.sample_rate = sample_rate + self.noise_files = list(Path(noise_root).rglob("*.wav")) + + def apply_real_noise(self, waveform: Tensor): + # 1. 随机选一个噪音文件 + noise_path = random.choice(self.noise_files) + noise_waveform, sr = torchaudio.load_with_torchcodec(noise_path) + + # Resample to target sample rate. + if sr != self.sample_rate: + noise_waveform = Resample(sr, self.sample_rate)(noise_waveform) + + # Convert to mono if it is setro. + if waveform.shape[0] > 1: + waveform = waveform.mean(dim=0, keepdim=True) + + # 3. 截取或填充，使其长度与语音一致 + sig_len = waveform.shape[1] + noise_len = noise_waveform.shape[1] + + if noise_len >= sig_len: + # 随机截取一段 + start = random.randint(0, noise_len - sig_len) + noise_waveform = noise_waveform[:, start:start + sig_len] + else: + full_noise = torch.zeros_like(waveform) + start = random.randint(0, sig_len - noise_len) + full_noise[:, start : start + noise_len] = noise_waveform + noise_waveform = full_noise + + # 4. 设定随机信噪比 SNR (5dB 到 20dB) + snr_db = random.uniform(5, 20) + + # 5. 混合 + return self._mix_at_snr(waveform, noise_waveform, snr_db) + + def _mix_at_snr(self, signal: Tensor, noise: Tensor, snr_db: float): + s_p = signal.pow(2).mean() + n_p = noise.pow(2).mean() + snr_linear = 10**(snr_db / 10) + scale = torch.sqrt(s_p / (n_p * snr_linear + 1e-8)) + + noisy = signal + scale * noise + # 归一化，防止溢出 + return noisy / (noisy.abs().max() + 1e-8) + +class CommonVoiceDataset(Dataset[BatchItem]): + def __init__( + self, + tsv_path: Path, + audio_dir: Path, + noise_dir: Path, + tokenizer: ASRTokenizer, + sample_rate: int = 16000, + max_audio_len: int = 480000, # 30秒 @ 16kHz + augment: bool = True, + augment_prob: float = 0.5, + ) -> None: + super().__init__() + self.noise_augmentor = NoiseAugmentor(noise_root=noise_dir, sample_rate=sample_rate) + self.audio_dir = Path(audio_dir) + self.tokenizer = tokenizer + self.sample_rate = sample_rate + self.max_audio_len = max_audio_len + self.augment = augment + self.augment_prob = augment_prob + + self.data: pd.DataFrame = pd.read_csv(tsv_path, sep='\t') + + valid_indices = [] + for index, row in self.data.iterrows(): + audio_path: Path = self.audio_dir / row['path'] + if audio_path.exists(): + valid_indices.append(index) + + self.data = self.data.loc[valid_indices].reset_index(drop=True) + + self.gain_up = Gain(min_gain_in_db=4, max_gain_in_db=8, p=1.0, output_type='tensor') + self.gain_down = Gain(min_gain_in_db=-15, max_gain_in_db=-8, p=1.0, output_type='tensor') + self.pitch_up = PitchShift(min_transpose_semitones=1, max_transpose_semitones=4, p=1.0, sample_rate=self.sample_rate, output_type='tensor') + self.pitch_down = PitchShift(min_transpose_semitones=-4, max_transpose_semitones=-1, p=1.0, sample_rate=self.sample_rate, output_type='tensor') + self.lowpass = LowPassFilter(min_cutoff_freq=600, max_cutoff_freq=2000, p=1.0, output_type='tensor') + self.highpass = HighPassFilter(min_cutoff_freq=800, max_cutoff_freq=2000, p=1.0, output_type='tensor') + self.apply_ir = ApplyImpulseResponse(ir_paths=noise_dir,convolve_mode='same', p=1, output_type="tensor") + + def __len__(self): + return len(self.data) + + def _load_audio(self, audio_path: Path) -> Tensor: + waveform, sample_rate = torchaudio.load_with_torchcodec(audio_path) + + # Resample to target sample rate. + if sample_rate != self.sample_rate: + waveform = Resample(sample_rate, self.sample_rate)(waveform) + + # Convert to mono if it is setro. + if waveform.shape[0] > 1: + waveform = waveform.mean(dim=0, keepdim=True) + + # Normalization + waveform = waveform / waveform.abs().max() + + # Clip waveform exceeds from max length. + if waveform.shape[1] > self.max_audio_len: + waveform = waveform[:, :self.max_audio_len] + return waveform + + def _augment_waveform(self, waveform: Tensor) -> Tensor: + if not self.augment or random.random() > self.augment_prob: + return waveform + + # 1. voice Stretch/Compress + if random.random() < 0.6: + waveform = self._stretch_or_compress(waveform=waveform) + + if random.random() < 0.4: + waveform = self.noise_augmentor.apply_real_noise(waveform) + + if random.random() < 0.3: + waveform = self._time_mask_waveform(waveform=waveform) + + # torch_audiomentations: [1, time] -> [1, 1, time] + if waveform.dim() == 2: + waveform_3d = waveform.unsqueeze(0) + # 随机选择一种频谱增强 + choice = random.random() + if choice < 0.15: + # 增益变化（上或下） + if random.random() < 0.5: + waveform_3d = self.gain_up(waveform_3d, sample_rate=self.sample_rate) + else: + waveform_3d = self.gain_down(waveform_3d, sample_rate=self.sample_rate) + elif choice < 0.25: + # 音高变化（上或下） + if random.random() < 0.5: + waveform_3d = self.pitch_up(waveform_3d, sample_rate=self.sample_rate) + else: + waveform_3d = self.pitch_down(waveform_3d, sample_rate=self.sample_rate) + elif choice < 0.30: + # 低通滤波（声音发闷） + waveform_3d = self.lowpass(waveform_3d, sample_rate=self.sample_rate) + # elif choice < 0.32: + # # 低通滤波（声音发闷） + # waveform_3d = self.apply_ir(waveform_3d, sample_rate=self.sample_rate) + elif choice < 0.35: + # 高通滤波（电话效果） + waveform_3d = self.highpass(waveform_3d, sample_rate=self.sample_rate) + + # [1, 1, time] -> [1, time] + waveform = waveform_3d.squeeze(0) + + # 防止多次 augment 后振幅溢出，最后归一化 + max_amp = waveform.abs().max() + if max_amp > 1.0: + waveform = waveform / max_amp + + return waveform + + def _stretch_or_compress(self, waveform: Tensor) -> Tensor: + speed_factor = random.uniform(0.85, 1.4) # (Speed Change: 0.85x - 1.4x) + spec = torch.stft( + waveform.squeeze(0), + n_fft=400, + hop_length=160, + window=torch.hann_window(400).to(waveform.device), + return_complex=True + ) + + # 时间拉伸（不改变音高） + stretched_spec = TimeStretch(hop_length=160, n_freq=spec.shape[-2], fixed_rate=speed_factor)(spec) + + # 转回波形 + waveform_stretched = torch.istft(stretched_spec, n_fft=400, hop_length=160, window=torch.hann_window(400).to(waveform.device)).unsqueeze(0) + + return waveform_stretched + + def _time_mask_waveform(self, waveform: Tensor) -> Tensor: + audio_len = waveform.shape[1] + sr = self.sample_rate # 16000 + + # 设置参数：单次遮盖最长 0.4 秒 (6400个点) + max_mask_time = 0.4 + max_mask_samples = int(sr * max_mask_time) + + # 根据音频长度决定遮盖次数： + # 比如每 3 秒钟允许遮盖 1 次 + num_masks = max(1, audio_len // (sr * 3)) + + for _ in range(num_masks): + # 每次随机遮盖 0.1s 到 0.4s + current_mask_len = random.randint(int(sr * 0.1), max_mask_samples) + + if audio_len > current_mask_len: + start_pos = random.randint(0, audio_len - current_mask_len) + + # 填充微小噪音（模拟环境底噪） + noise = torch.randn(1, current_mask_len).to(waveform.device) * 0.002 + waveform[:, start_pos : start_pos + current_mask_len] = noise + + return waveform + + def __getitem__(self, index) -> BatchItem: + row: TsvFormat = self.data.iloc[index] + audio_path: Path = self.audio_dir / row['path'] + # text: str = unicodedata.normalize('NFC', row['sentence'].strip()) + text: str = normalize_extended_uyghur_characters(collapse_spaces(row['sentence'].strip())) + + waveform = self._load_audio(audio_path=audio_path) + waveform = self._augment_waveform(waveform) + waveform = waveform.squeeze(0) + + return BatchItem( + waveform=waveform, + target_ids=torch.tensor(self.tokenizer.encode(text), dtype=torch.long), + target_text=text, + audio_path=str(audio_path) + ) + +def collate_fn(items: List[BatchItem]) -> Batch: + max_waveform_len = max(item['waveform'].shape[0] for item in items) + max_target_len = max(len(item['target_ids']) for item in items) + + batch_size = len(items) + + waveforms = torch.zeros(batch_size, max_waveform_len) + targets = torch.zeros(batch_size, max_target_len, dtype=torch.long) + waveform_lengths = torch.zeros(batch_size, dtype=torch.long) + target_lengths = torch.zeros(batch_size, dtype=torch.long) + + target_texts = [] + audio_paths = [] + + + for i, item in enumerate(items): + waveform_len = item['waveform'].shape[0] + target_len = len(item['target_ids']) + + waveforms[i, :waveform_len] = item['waveform'] + targets[i, :target_len] = item['target_ids'] + waveform_lengths[i] = waveform_len + target_lengths[i] = target_len + + target_texts.append(item['target_text']) + audio_paths.append(item['audio_path']) + + return Batch( + waveforms=waveforms, + targets=targets, + waveform_lengths=waveform_lengths, + target_lengths=target_lengths, + target_texts=target_texts, + audio_paths=audio_paths + ) + + +def create_dataloader(tsv_path: Path, audio_dir: Path, noise_dir: Path, tokenizer: ASRTokenizer, batch_size: int = 8, shuffle: bool = True, augment: bool = True, augment_prob: int = 0.5) -> DataLoader: + dataset = CommonVoiceDataset(tsv_path=tsv_path, audio_dir=audio_dir, noise_dir=noise_dir, tokenizer=tokenizer, augment=augment, augment_prob=augment_prob) + + return DataLoader(dataset=dataset, batch_size=batch_size, shuffle=shuffle, collate_fn=collate_fn, pin_memory=True, num_workers=8, prefetch_factor=8, persistent_workers=True) + + +# ============ 测试代码 ============ +if __name__ == "__main__": + from pathlib import Path + + workspace_dir = Path(__file__).parent.parent + + # 初始化tokenizer + tokenizer = ASRTokenizer(workspace_dir / 'config' / 'asr_vocab.json') + + # 创建数据加载器 + dataloader = create_dataloader( + tsv_path=workspace_dir / 'data' / 'ug' / 'train.tsv', + audio_dir=workspace_dir / 'data' / 'ug' / 'clips', + tokenizer=tokenizer, + batch_size=2, + shuffle=True, + ) + + # 测试加载一个batch + print("测试数据加载:") + for batch in dataloader: + batch: Batch + print(f"Mel specs shape: {batch['mel_specs'].shape}") + print(f"Targets shape: {batch['targets'].shape}") + print(f"Mel lengths: {batch['mel_lengths']}") + print(f"Target lengths: {batch['target_lengths']}") + print(f"Target texts: {batch['target_texts']}") + print(f"Audio paths: {batch['audio_paths']}") + break + + + + + +import torch +import torchaudio +from silero_vad import load_silero_vad, read_audio, get_speech_timestamps + +# --- 1. 加载 VAD 模型 --- +# 推荐使用 GPU (cuda) 如果可用，否则使用 CPU (cpu) +vad_model = load_silero_vad(source="local", force_onnx=False) + +def process_audio_with_vad_and_asr(audio_path, inference_module): + """ + 使用 Silero VAD 分割音频，然后对每个语音片段进行 ASR 转录。 + + Args: + audio_path (str): 输入音频文件的路径。 + inference_module: 您封装了 transcribe 方法的模块或对象。 + 需要确保其 _load_audio 和 transcribe 方法可用。 + """ + print(f"正在加载音频: {audio_path}") + + # --- 2. 加载音频用于 VAD 检测 --- + # Silero VAD 推荐使用 16kHz 采样率 + waveform_vad, sample_rate_vad = torchaudio.load(audio_path) + if sample_rate_vad != 16000: + # 如果采样率不是16kHz，需要重采样以供VAD使用 + resampler = torchaudio.transforms.Resample(orig_freq=sample_rate_vad, new_freq=16000) + waveform_vad = resampler(waveform_vad) + sample_rate_vad = 16000 + + # --- 3. 获取语音时间段 --- + # get_speech_timestamps 返回一个列表，每个元素是 {'start': start_sample, 'end': end_sample} 的字典 + # 采样率是16000，所以时间戳单位是 1/16000 秒 + speech_timestamps = get_speech_timestamps( + waveform_vad, + vad_model, + sampling_rate=sample_rate_vad, + threshold=0.5, # 可以根据需要调整阈值 + min_speech_duration_ms=250, # 最小语音持续时间，防止短噪音被误判 + max_speech_duration_s=float('inf'), # 最大语音持续时间，float('inf') 表示不限制 + min_silence_duration_ms=100, # 最小静音间隔，用于分割语音块 + window_size_samples=1536, # VAD窗口大小 + speech_pad_ms=30 # 在语音块前后添加的填充时间 + ) + + print(f"检测到 {len(speech_timestamps)} 个语音片段。") + + full_text = "" + for i, ts in enumerate(speech_timestamps): + start_sample = int(ts['start']) + end_sample = int(ts['end']) + + # 计算时间戳（秒） + start_time = start_sample / sample_rate_vad + end_time = end_sample / sample_rate_vad + + print(f"\n处理第 {i+1} 个片段: 时间范围 [{start_time:.2f}s - {end_time:.2f}s]") + + # --- 4. 从原始音频中提取此片段 --- + # 注意：这里假设您的 transcribe 函数可以接受 waveform 张量。 + # 我们需要从原始可能不同采样率的音频中提取片段，或者用VAD处理过的waveform。 + # 为了匹配您原来的 _load_audio 方式，我们用 torchaudio 再次精确加载片段。 + + # 计算原始音频中的样本索引（如果原始音频采样率与VAD不同） + original_waveform, original_sr = torchaudio.load(audio_path) + if sample_rate_vad != original_sr: + # 如果VAD和原始音频采样率不同，需要重新映射索引 + start_idx_orig = int(start_sample * (original_sr / sample_rate_vad)) + end_idx_orig = int(end_sample * (original_sr / sample_rate_vad)) + else: + start_idx_orig = start_sample + end_idx_orig = end_sample + + segment_waveform = original_waveform[:, start_idx_orig:end_idx_orig] + + # --- 5. 对该片段进行 ASR 转录 --- + # 这里调用您原有的 transcribe 方法 + try: + # 假设 transcribe 方法接受一个 waveform tensor + segment_text = inference_module.transcribe(waveform=segment_waveform) + + print(f" -> 转录结果: {segment_text}") + full_text += f"[{start_time:.2f}-{end_time:.2f}s] {segment_text}\n" + except Exception as e: + print(f" -> 转录第 {i+1} 个片段时出错: {e}") + + print("\n--- 完整转录结果 ---") + print(full_text) + + +# --- 使用示例 --- +# 假设您有一个名为 'inference' 的模块对象，它有 _load_audio 和 transcribe 方法 +# audio_path = "your_audio_file.wav" +# process_audio_with_vad_and_asr(audio_path, inference) \ No newline at end of file diff --git a/src/handle/audio_agement.ipynb b/src/handle/audio_agement.ipynb new file mode 100644 index 0000000..51aa62a --- /dev/null +++ b/src/handle/audio_agement.ipynb @@ -0,0 +1,160 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 3, + "id": "f6132018", + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import torchaudio\n", + "from torch import Tensor\n", + "from pathlib import Path\n", + "from IPython.display import Audio\n", + "from torch_audiomentations import Gain, PitchShift, LowPassFilter, HighPassFilter, ApplyImpulseResponse\n", + "workspace_dir = Path.cwd().parent.parent\n", + "sample_rate = 16000" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "a238e4ab", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([1, 132800])\n", + "原始音频: shape=torch.Size([1, 1, 132800]), sample_rate=16000\n", + "orginal\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "transforms = {\n", + " \"gain_up\": Gain(min_gain_in_db=4, max_gain_in_db=8, p=1.0, output_type='tensor'),\n", + " \"gain_down\": Gain(min_gain_in_db=-15, max_gain_in_db=-8, p=1.0),\n", + " \"pitch_up\": PitchShift(min_transpose_semitones=1, max_transpose_semitones=4, p=1.0, sample_rate=sample_rate, output_type='tensor'),\n", + " \"pitch_down\": PitchShift(min_transpose_semitones=-4, max_transpose_semitones=-1, p=1.0, sample_rate=sample_rate, output_type='tensor'),\n", + " \"lowpass\": LowPassFilter(min_cutoff_freq=600, max_cutoff_freq=2000, p=1.0, output_type='tensor'),\n", + " \"highpass\": HighPassFilter(min_cutoff_freq=800, max_cutoff_freq=2000, p=1.0, output_type='tensor')\n", + "}\n", + "\n", + "audio_path = workspace_dir / 'data/test/F001_001.wav'\n", + "\n", + "waveform, sample_rate = torchaudio.load_with_torchcodec(audio_path)\n", + "print(waveform.shape)\n", + "if waveform.dim() == 2:\n", + " waveform = waveform.unsqueeze(0)\n", + "\n", + "print(f\"原始音频: shape={waveform.shape}, sample_rate={sample_rate}\")\n", + "print('orginal')\n", + "display(Audio(waveform.squeeze(0), rate=sample_rate))\n", + "\n", + "test_audio = workspace_dir / 'data/test/637ae13bc4a7e3.wav'\n", + "# test_transform = ApplyImpulseResponse(ir_paths=test_audio,convolve_mode='same', p=1, output_type=\"tensor\")\n", + "test_transform = PitchShift(min_transpose_semitones=1, max_transpose_semitones=4, p=1.0, sample_rate=sample_rate, output_type='tensor')\n", + "out: Tensor = test_transform(samples=waveform, sample_rate=sample_rate)\n", + "max_amp = out.abs().max()\n", + "if max_amp > 1.0:\n", + " print(max_amp)\n", + " out = out / max_amp\n", + "display(Audio(out.squeeze(0), rate=sample_rate))\n", + "# for name, transform in transforms.items():\n", + "# out: Tensor = transform(waveform, sample_rate=sample_rate)\n", + "# out.squeeze(0)\n", + "# max_val = out.abs().max()\n", + "# if max_val > 1.0:\n", + "# print(f\"max_val: {max_val}\")\n", + "# waveform_3d = waveform / max_val\n", + "# print(f\"name: {name}, shepe: {out.shape}\")\n", + "# display(Audio(out.squeeze(0), rate=sample_rate))" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "6f47127f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.019030116872178315\n" + ] + } + ], + "source": [ + "import math\n", + "epoch = 1\n", + "final_prob = 0.5\n", + "warmup_epochs = 8\n", + "# current_prob = min(final_prob, final_prob * epoch / warmup_epochs)\n", + "\n", + "current_prob = final_prob * (1 - math.cos(math.pi * epoch / warmup_epochs)) / 2\n", + "if epoch >= warmup_epochs:\n", + " current_prob = final_prob\n", + "print(current_prob)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "study-asr (3.11.12)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/handle/audio_analyze.py b/src/handle/audio_analyze.py new file mode 100644 index 0000000..a4c1117 --- /dev/null +++ b/src/handle/audio_analyze.py @@ -0,0 +1,70 @@ +from pathlib import Path +from tqdm import tqdm +from mutagen.mp3 import MP3 +from mutagen import MutagenError +import pandas as pd + +workspace_dir = Path(__file__).parent.parent.parent + +def format_duration(seconds): + """将秒数格式化为 时:分:秒 的格式""" + hours = int(seconds // 3600) + minutes = int((seconds % 3600) // 60) + secs = int(seconds % 60) + + if hours > 0: + return f"{hours}小时{minutes}分{secs}秒" + elif minutes > 0: + return f"{minutes}分{secs}秒" + else: + return f"{secs}秒" + +def get_mp3_duration(file_path: Path): + """获取单个MP3文件的时长（秒）""" + try: + audio = MP3(file_path) + return audio.info.length + except MutagenError as e: + print(f"错误：无法读取文件 {file_path} - {e}") + return None + except Exception as e: + print(f"错误：处理文件 {file_path} 时出错 - {e}") + return None + +def analyze_mp3_files(directory: Path, ): + """分析目录中的所有MP3文件""" + results = [] + total_duration = 0 + df = pd.read_csv(workspace_dir / '.data/ug/train_new.tsv', sep='\t') + + for _, row in tqdm(df.iterrows(), total=len(df), desc="anlayze audio"): + mp3_file: Path = workspace_dir / '.data/ug/clips' / row['path'] + duration = get_mp3_duration(mp3_file) + + if duration is not None: + total_duration += duration + duration_str = format_duration(duration) + file_size = mp3_file.stat().st_size / (1024 * 1024) # 转换为MB + + result_line = f"{mp3_file.name:<50} {duration_str:>20} ({file_size:.2f} MB)" + results.append(result_line) + else: + error_line = f"{mp3_file.name:<50} {'读取失败':>20}" + print(error_line) + results.append(error_line) + + mp3_files: list[Path] = [] + for ext in ['*.mp3', '*.MP3']: + mp3_files.extend(directory.rglob(ext)) + + print(f"tsv 找到 {len(results)} 个MP3文件\n") + print(f"找到 {len(mp3_files)} 个MP3文件\n") + print(f"\n总时长: {format_duration(total_duration)}") + print(f"总时长(秒): {total_duration:.2f} 秒") + print(f"总时长(分钟): {total_duration/60:.2f} 分钟") + print(f"总时长(小时): {total_duration/3600:.2f} 小时") + print(f"文件总数: {len(mp3_files)}") + + +audio_directory = Path(workspace_dir / '.data/ug/clips') +analyze_mp3_files(directory=audio_directory) diff --git a/src/handle/export_model_state_dict.py b/src/handle/export_model_state_dict.py new file mode 100644 index 0000000..7792230 --- /dev/null +++ b/src/handle/export_model_state_dict.py @@ -0,0 +1,13 @@ + +from pathlib import Path + +import torch + +device = "cuda:0" +workspace_dir = Path(__file__).parent.parent.parent + +input_checkpoint = workspace_dir.joinpath('.checkpoints/best_wer_model.pt') +output_checkpoint = workspace_dir.joinpath('.checkpoints/prodect_best_wer_model.pt') + +checkpoint = torch.load(input_checkpoint, map_location=device) +torch.save(checkpoint['model_state_dict'], output_checkpoint) \ No newline at end of file diff --git a/src/handle/export_new_tsv.py b/src/handle/export_new_tsv.py new file mode 100644 index 0000000..2f0476d --- /dev/null +++ b/src/handle/export_new_tsv.py @@ -0,0 +1,37 @@ +from pathlib import Path + +import pandas as pd +workspace_dir = Path(__file__).parent.parent.parent + +# 读取你合并后的总表 (253,430条) +df = pd.read_csv(workspace_dir / ".data/ug/validated.tsv", sep='\t') + +# 1. 获取所有唯一的说话人 +all_speakers = df['client_id'].unique() + +# 2. 随机打乱说话人顺序 +import random +random.seed(42) # 固定随机种子，保证实验可重复 +random.shuffle(all_speakers) + +# 3. 挑选验证集说话人，直到录音总数达到 ~8000 条 +val_indices = [] +val_count = 0 +target_val_size = 8000 + +for speaker in all_speakers: + speaker_data = df[df['client_id'] == speaker] + val_indices.extend(speaker_data.index.tolist()) + val_count += len(speaker_data) + if val_count >= target_val_size: + break + +# 4. 划分文件 +df_val = df.loc[val_indices] +df_train = df.drop(val_indices) + +print(f"训练集条数: {len(df_train)}") +print(f"验证集条数: {len(df_val)}") + +df_train.to_csv(workspace_dir / ".data/ug/train_new.tsv", sep='\t', index=False) +df_val.to_csv(workspace_dir / ".data/ug/val_new.tsv", sep='\t', index=False) diff --git a/src/handle/export_vocab.py b/src/handle/export_vocab.py new file mode 100644 index 0000000..51be7ad --- /dev/null +++ b/src/handle/export_vocab.py @@ -0,0 +1,92 @@ +import json +from pathlib import Path +from typing import Counter +import pandas as pd +from tqdm import tqdm +from text_handle import process_text + +workspace_dir = Path(__file__).parent.parent.parent + +data_dir = Path("/home/blacksheep/projekts/study") +input_files = [ + data_dir / "data/multilingual/hanziDB_translated-simplified.jsonl", + data_dir / "data/multilingual/hanziDB_translated_validationset-simplified.jsonl", + data_dir / "data/multilingual/tatoeba-tr-en-ug-uz-kz-zh-simplified.jsonl", + data_dir / "data/multilingual/export_csv_database.jsonl", + data_dir / "data/multilingual/tatoeba_sentences.jsonl", +] +output_file = workspace_dir / "config/asr_vocab_1.json" +syllabizes = [] + +# langs = ["uig_Arab"] +# for input_file in input_files: +# with open(input_file, 'r', encoding='utf-8') as f: +# total_lines = sum(1 for _ in f) +# f.seek(0) +# for line in tqdm(f, total=total_lines, desc=f"Processing lines {input_file}"): +# data: dict[str, str] = json.loads(line) +# for lang in langs: +# if lang in data: +# syllabizes.extend(export_syllabize(data[lang])) + +# print(f'data_dir syllabize len: {len(syllabizes):,}, set: {len(set(syllabizes)):,}') + + +tsv_files = [ + # workspace_dir / "data/ug/test.tsv", + # workspace_dir / "data/ug/invalidated.tsv", + # workspace_dir / "data/ug/train.tsv", + # workspace_dir / "data/ug/validated.tsv", + # workspace_dir / "data/ug/reported.tsv", + # workspace_dir / "data/ug/dev.tsv", + # workspace_dir / "data/ug/other.tsv", + # workspace_dir / ".data/ug/invalidated.tsv", + workspace_dir / ".data/ug/train.tsv", + # workspace_dir / ".data/ug/clip_durations.tsv", # not sentence + # workspace_dir / ".data/ug/test.tsv", + # workspace_dir / ".data/ug/validated_sentences.tsv", + # workspace_dir / ".data/ug/other.tsv", + # workspace_dir / ".data/ug/validated.tsv", + # workspace_dir / ".data/ug/dev.tsv", + # workspace_dir / ".data/ug/unvalidated_sentences.tsv", + # workspace_dir / ".data/ug/reported.tsv" # Lacking sentence +] + +for tsv_file in tsv_files: + data = pd.read_csv(tsv_file, sep='\t') + # 带进度条处理每行数据 + for index, row in tqdm(data.iterrows(), total=len(data), desc=f"Processing {tsv_file}"): + syllabizes.extend(process_text(row['sentence'].strip())) + + +# 统计所有音节出现次数 +syllable_counter = Counter(syllabizes) +# 过滤出出现100次以上的音节 +freq_100_plus = {k: v for k, v in syllable_counter.items() if v >= 150} +freq_100_minus = {k: v for k, v in syllable_counter.items() if v <= 100} + +# 保存100次以上的音节列表（只有音节，排序） +vocab = sorted(list(freq_100_plus.keys()), key=len) +with open(output_file, 'w', encoding='utf-8') as f: + json.dump(vocab, f, ensure_ascii=False, indent=2) + +# # # 保存100次以上的音节及次数 +sorted_freq_100_plus = dict(sorted(freq_100_plus.items(), key=lambda x: x[1], reverse=True)) +with open(workspace_dir / 'config/syllables_freq_100_plus.json', 'w', encoding='utf-8') as f: + json.dump(sorted_freq_100_plus, f, ensure_ascii=False, indent=2) + +# # 统计信息 +print(f"总音节数: {len(syllabizes):,}") +print(f"唯一音节数: {len(syllable_counter):,}") +print(f"出现100次以上的音节数: {len(freq_100_plus):,}") +print(f"出现100次以下的音节数: {len(freq_100_minus):,}") + +# 区间统计（不累积） +print("\n=== 音节使用次数统计（区间） ===") +for low in range(0, 100, 10): + high = low + 9 + count = sum(1 for freq in syllable_counter.values() if low <= freq <= high) + print(f"出现 {low}-{high} 次: {count:,} 个音节") +# 100次以上 +count_100plus = sum(1 for freq in syllable_counter.values() if freq >= 100) +print(f"出现 100+ 次: {count_100plus} 个音节") \ No newline at end of file diff --git a/src/handle/test.ipynb b/src/handle/test.ipynb new file mode 100644 index 0000000..bc960a9 --- /dev/null +++ b/src/handle/test.ipynb @@ -0,0 +1,490 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 21, + "id": "aa1d00f1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PyTorch version: 2.8.0+cu128\n", + "Torchaudio version: 2.8.0+cu128\n" + ] + } + ], + "source": [ + "import torch\n", + "import torchaudio\n", + "from torchaudio.transforms import MelSpectrogram, AmplitudeToDB\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from IPython.display import Audio\n", + "from pathlib import Path\n", + "\n", + "print(f\"PyTorch version: {torch.__version__}\")\n", + "print(f\"Torchaudio version: {torchaudio.__version__}\")\n", + "\n", + "workspace_dir = Path.cwd().parent.parent" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "a6d351e1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "16000\n", + "torch.Size([1, 132800])\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor(8.6255)\n", + "tensor(8.6255) tensor(-9.5740)\n", + "tensor(0.9009) tensor(-1.)\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "waveform, sample_rate = torchaudio.load_with_torchcodec(workspace_dir.joinpath(\"data/test/F001_001.wav\").as_posix(), channels_first=True, )\n", + "print(sample_rate)\n", + "print(waveform.shape)\n", + "if waveform.shape[0] > 1:\n", + " waveform = waveform.mean(dim=0, keepdim=True)\n", + "\n", + "display(Audio(waveform[:, sample_rate * 2:sample_rate * 2 + sample_rate * 3], rate=sample_rate))\n", + "display(Audio(waveform, rate=sample_rate))\n", + "waveform = waveform * 20.0\n", + "print(waveform.max())\n", + "# display(Audio(waveform, rate=sample_rate, normalize=False))\n", + "\n", + "print(waveform.max(), waveform.min())\n", + "waveform = waveform / waveform.abs().max()\n", + "print(waveform.max(), waveform.min())\n", + "display(Audio(waveform, rate=sample_rate, element_id=\"scaled\", normalize=False), display_id=\"scaled\")" + ] + }, + { + "cell_type": "markdown", + "id": "9cb24ba9", + "metadata": {}, + "source": [ + "## Mel spectrogram based approach" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "59557614", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MelSpectrogram 配置:\n", + " sample_rate: 16000\n", + " n_fft: 400\n", + " win_length: 400\n", + " hop_length: 160\n", + " n_mels: 320\n", + " f_min: 0\n", + " f_max: 8000\n", + " power: 3.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/blacksheep/projekts/study_asr/.venv/lib/python3.11/site-packages/torchaudio/functional/functional.py:585: UserWarning: At least one mel filterbank has all zero values. The value for `n_mels` (320) may be set too high. Or, the value for `n_freqs` (201) may be set too low.\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "# Cell 3: 配置 MelSpectrogram 参数\n", + "# 可交互式修改这些参数，实时查看效果\n", + "CONFIG = {\n", + " \"sample_rate\": 16000,\n", + " \"n_fft\": 400, # FFT 窗口大小\n", + " \"win_length\": 400, # 窗口长度\n", + " \"hop_length\": 160, # 帧移 (10ms @ 16kHz)\n", + " \"n_mels\": 80 * 4, # Mel 滤波器数量\n", + " \"f_min\": 0,\n", + " \"f_max\": 8000,\n", + " \"power\": 3.0, # 2=功率谱, 1=幅度谱\n", + "}\n", + "\n", + "# 创建变换\n", + "mel_transform = MelSpectrogram(**CONFIG)\n", + "print(\"MelSpectrogram 配置:\")\n", + "for k, v in CONFIG.items():\n", + " print(f\" {k}: {v}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "7b9f9e7f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABKUAAAMWCAYAAAAgRDUeAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3Xd8E/X/B/BX0l1oaYGWssseslfZs6yigD9FQARBREVRFCeoKKDgQMDBVxRQ3CBupIyypwXZe5fdFlpKF23TJr8/akPTrEtyl7tLXs/Hg4f2crl7X3K58b7P5/3RGAwGA4iIiIiIiIiIiNxIK3cARERERERERETkfZiUIiIiIiIiIiIit2NSioiIiIiIiIiI3I5JKSIiIiIiIiIicjsmpYiIiIiIiIiIyO2YlCIiIiIiIiIiIrdjUoqIiIiIiIiIiNyOSSkiIiIiIiIiInI7JqWIiIiIiIiIiMjtmJQiIiIir/L2229Do9E49d5ly5ZBo9EgKSlJ3KBKSUpKgkajwbJlyyRbh1z27t2Lzp07o1y5ctBoNDh48KDcIREREZGMmJQiIiIiVTh27BgeeeQRVK9eHQEBAahWrRpGjRqFY8eOyR0aCaDT6TBs2DCkp6dj/vz5+O6771C7dm25wyIiIiIZaQwGg0HuIIiIiIhs+e233zBy5EhUrFgR48ePR506dZCUlISlS5ciLS0Ny5cvx/333y9oWYWFhSgsLERgYKDDcRQVFUGn0yEgIMDp1lb2JCUloU6dOvj6668xduxYSdYhh5MnT6JJkyZYvHgxHn/8cbnDISIiIgXwlTsAIiIiIlvOnTuH0aNHo27duti2bRsiIiKMr02ePBndunXD6NGjcfjwYdStW9fqcnJyclCuXDn4+vrC19e5SyAfHx/4+Pg49V5vl5qaCgAICwsTbZkl3ykRERGpE7vvERERkaJ9+OGHyM3NxZdffmmSkAKAypUr44svvkBOTg4++OAD4/SSulHHjx/Hww8/jPDwcHTt2tXktdLu3LmD5557DpUrV0ZISAgGDx6Mq1evQqPR4O233zbOZ6mmVHR0NO69917s2LEDHTp0QGBgIOrWrYtvv/3WZB3p6el46aWX0Lx5c5QvXx6hoaEYOHAgDh065PBnkpGRAR8fH3zyySfGaTdv3oRWq0WlSpVQuiH8xIkTERUVZfx7+/btGDZsGGrVqoWAgADUrFkTL7zwAu7cuWOcZ+7cudBoNLh48aLZuqdOnQp/f3/cunXLOC0xMREDBgxAhQoVEBwcjB49emDnzp3G18eOHYsePXoAAIYNGwaNRoOePXsaX9+0aRO6deuGcuXKISwsDEOGDMGJEydM1mvrOy35DrZs2YJ27dohKCgIzZs3x5YtWwAUt7Rr3rw5AgMD0bZtWxw4cMCRj5uIiIgkwqQUERERKdqqVasQHR2Nbt26WXy9e/fuiI6OxurVq81eGzZsGHJzczF79mxMmDDB6jrGjh2LTz/9FHFxcXj//fcRFBSEQYMGCY7x7NmzePDBB9G3b1989NFHCA8Px9ixY03qXZ0/fx5//PEH7r33XsybNw8vv/wyjhw5gh49euDatWuC1wUUtzZq1qwZtm3bZpy2Y8cOaDQapKen4/jx48bp27dvN/nsVq5cidzcXEycOBGffvop+vfvj08//RRjxowxzvPQQw9Bo9Hg559/Nlv3zz//jH79+iE8PBxAcUKpe/fuyMzMxFtvvYXZs2cjIyMDvXv3xp49ewAATz75JKZNmwYAeO655/Ddd9/h9ddfBwBs2LAB/fv3R2pqKt5++21MmTIFu3btQpcuXSwWlLf2nZ49exYPP/ww7rvvPsyZMwe3bt3Cfffdhx9++AEvvPACHnnkEcyYMQPnzp3DQw89BL1e79BnTkRERBIwEBERESlURkaGAYBhyJAhNucbPHiwAYAhMzPTYDAYDG+99ZYBgGHkyJFm85a8VmLfvn0GAIbnn3/eZL6xY8caABjeeust47Svv/7aAMBw4cIF47TatWsbABi2bdtmnJaammoICAgwvPjii8ZpeXl5hqKiIpN1XLhwwRAQEGCYOXOmyTQAhq+//trmNj/zzDOGKlWqGP+eMmWKoXv37obIyEjD559/bjAYDIa0tDSDRqMxfPzxx8b5cnNzzZY1Z84cg0ajMVy8eNE4rVOnToa2bduazLdnzx4DAMO3335rMBgMBr1eb2jQoIGhf//+Br1eb7KOOnXqGPr27WuctnnzZgMAw8qVK02W2apVK0NkZKQhLS3NOO3QoUMGrVZrGDNmjHGare+05DvYtWuXcdq6desMAAxBQUEm2/XFF18YABg2b95sthwiIiJyL7aUIiIiIsXKysoCAISEhNicr+T1zMxMk+lPPfWU3XWsXbsWAPD000+bTH/22WcFx9m0aVOT1kgRERFo1KgRzp8/b5wWEBAArbb40quoqAhpaWkoX748GjVqhP379wteV4lu3bohJSUFp06dAlDcIqp79+7o1q0btm/fDqC49ZTBYDCJLSgoyPj/OTk5uHnzJjp37gyDwWDSrW348OHYt28fzp07Z5y2YsUKBAQEYMiQIQCAgwcP4syZM3j44YeRlpaGmzdv4ubNm8jJyUGfPn2wbds2my2Srl+/joMHD2Ls2LGoWLGicXqLFi3Qt29fxMfHm73H2nfatGlTdOrUyfh3TEwMAKB3796oVauW2fTS3w0RERHJg0kpIiIiUqySZFNJcsoaa8mrOnXq2F3HxYsXodVqzeatX7++4DhLJz1KhIeHm9Rd0uv1mD9/Pho0aICAgABUrlwZEREROHz4MG7fvi14XSVKEk3bt29HTk4ODhw4gG7duqF79+7GpNT27dsRGhqKli1bGt936dIlYxKofPnyiIiIMNZ7Kh3HsGHDoNVqsWLFCgCAwWDAypUrMXDgQISGhgIAzpw5AwB49NFHERERYfJvyZIlyM/Pt7ltJTWrGjVqZPZakyZNjAmu0qx9p2W/gwoVKgAAatasaXF66e+GiIiI5MHR94iIiEixKlSogKpVq+Lw4cM25zt8+DCqV69uTJaUKN0qSErWRuQzlCo4Pnv2bLz55pt47LHHMGvWLFSsWBFarRbPP/+8U/WNqlWrhjp16mDbtm2Ijo6GwWBAp06dEBERgcmTJ+PixYvYvn07OnfubNJCq2/fvkhPT8err76Kxo0bo1y5crh69SrGjh1rEke1atXQrVs3/Pzzz5g2bRr++ecfXLp0Ce+//75xnpL5P/zwQ7Rq1cpinOXLl3d422yx9p1a+w6EfDdEREQkDyaliIiISNHuvfdeLF68GDt27DCOtlba9u3bkZSUhCeffNKp5deuXRt6vR4XLlxAgwYNjNPPnj3rdMyW/PLLL+jVqxeWLl1qMj0jIwOVK1d2apndunXDtm3bUKdOHbRq1QohISFo2bIlKlSogLVr12L//v2YMWOGcf4jR47g9OnT+Oabb0wKmyckJFhc/vDhw/H000/j1KlTWLFiBYKDg3HfffcZX69Xrx4AIDQ0FLGxsQ7HX7t2bQAwdkEs7eTJk6hcuTLKlSvn8HKJiIhIHdh9j4iIiBTt5ZdfRlBQEJ588kmkpaWZvJaeno6nnnoKwcHBePnll51afv/+/QEA//vf/0ymf/rpp84FbIWPj49Z65yVK1fi6tWrTi+zW7duSEpKwooVK4zd+bRaLTp37ox58+ZBp9OZ1JMqaTVUOg6DwYCPP/7Y4vIfeOAB+Pj44KeffsLKlStx7733miSJ2rZti3r16mHu3LnIzs42e/+NGzdsxl+1alW0atUK33zzDTIyMozTjx49ivXr1yMuLs7+h0BERESqxZZSREREpGgNGjTAN998g1GjRqF58+YYP3486tSpg6SkJCxduhQ3b97ETz/9ZGy146i2bdvigQcewIIFC5CWloaOHTti69atOH36NABAo9GIsh333nsvZs6ciXHjxqFz5844cuQIfvjhB9StW9fpZZYknE6dOoXZs2cbp3fv3h1r1qxBQEAA2rdvb5zeuHFj1KtXDy+99BKuXr2K0NBQ/Prrr1brK0VGRqJXr16YN28esrKyMHz4cJPXtVotlixZgoEDB+Kee+7BuHHjUL16dVy9ehWbN29GaGgoVq1aZXMbPvzwQwwcOBCdOnXC+PHjcefOHXz66aeoUKEC3n77bSc/GSIiIlIDtpQiIiIixRs2bBj27duHnj17YunSpXjqqaewePFi9OjRA/v27cP//d//ubT8b7/9Fs888wxWr16NV199FQUFBcYC34GBgWJsAqZNm4YXX3wR69atw+TJk7F//36sXr3arBC3Ixo1aoTIyEgAMOnaWJKs6tChAwICAozT/fz8sGrVKrRq1Qpz5szBjBkz0KBBA3z77bdW1zF8+HBkZWUhJCTEYsulnj17Yvfu3WjXrh0+++wzPPvss1i2bBmioqLwwgsv2N2G2NhYrF27FpUqVcL06dMxd+5cdOzYETt37hRUqJ6IiIjUS2NglUciIiIiMwcPHkTr1q3x/fffY9SoUXKHQ0RERORx2FKKiIiIvN6dO3fMpi1YsABarRbdu3eXISIiIiIiz8eaUkREROT1PvjgA+zbtw+9evWCr68v1qxZgzVr1uCJJ55wqXsdEREREVnH7ntERETk9RISEjBjxgwcP34c2dnZqFWrFkaPHo3XX38dvr58hkdEREQkBSaliIiIiIiIiIjI7VhTioiIiIiIiIiI3I5JKSIiIiIiIiIicjsWSRCBXq/HtWvXEBISAo1GI3c4RERERERERESyMRgMyMrKQrVq1aDVWm8PxaSUCK5du8aReYiIiIiIiIiISrl8+TJq1Khh9XUmpUQQEhICoPjDDg0NlTka5+l0Oqxfvx79+vWDn5+f3OGQh+B+RVLgfkVS4b5FUuB+RVLgfkVS4b5FYsjMzETNmjWN+RJrmJQSQUmXvdDQUNUnpYKDgxEaGsqDD4mG+xVJgfsVSYX7FkmB+xVJgfsVSYX7FonJXokjFjonIiIiIiIiIiK3Y1KKiIiIiIiIiIjcjkkpIiIiIiIiIiJyOyaliIiIiIiIiIjI7ZiUIiIiIiIiIiIit2NSioiIiIiIiIiI3I5JKSIiIiIiIiIicjsmpYiIiIiIiIiIyO2YlCIiIiIiIiIiIrdjUoqIiIiIiIiIiNyOSSkiIiIiIjJafywZ207fkDsMIiLyAr5yB0BERERERMqQlp2PJ77bBwA4PzsOWq1G5oiIiMiTsaUUEREREREBADLu6Iz/b5AxDiIi8g5MShERERERERERkdsxKUVERERERERERG7HpBQREREREREREbkdk1JEREREREREROR2TEoREREREZFgRXoDDAaWQSciItcxKUVERERERILk5Bei83sb8exPB+QOhYiIPACTUkREREREJMi6Y8lIyczH34evyx0KERF5AF+5AyAiIiIiImVbsv08zt3IRrvaFeUOhYiIPAiTUkREREREZJHBYMA/59PxzuoT//0tc0BERORR2H2PiIiIiIgs+uvQNYxc/I/x74xcnYzRkFAGgwHzE07jz4NX5Q6FiMgmtpQiIiIiIiKL1h1LNvl7bZm/SZn+vXgLH288AwAY0qq6zNEQEVnHllJEREREMkvJzMOBS7fkDoOIPETi+TTj/xvY55KIFIxJKSIiIiKZxczeiPv/twsfbzgjdyhE5AGW7bpo/P91x1JkjISIyDYmpYiIiIgUYv6G03KHQEQe5mxqltwhEBFZxaQUEREREREB4Oh6nuJmdr7cIRARCcKkFBEREZGMMnIL5A6BiDzIrRweU4hIPZiUIiIiIpLR51vPmfzNFg6kFBqw5ZQacYREIlIT1SWlFi5ciOjoaAQGBiImJgZ79uyxOm/Pnj2h0WjM/g0aNMg4z9ixY81eHzBggDs2hYiIiAh5BUUmf2flFcoUCZEp5qOIiEhqvnIH4IgVK1ZgypQpWLRoEWJiYrBgwQL0798fp06dQmRkpNn8v/32GwoK7jZfTUtLQ8uWLTFs2DCT+QYMGICvv/7a+HdAQIB0G0FEREREpBKX0nPlDoFclFMm8U1EpCSqaik1b948TJgwAePGjUPTpk2xaNEiBAcH46uvvrI4f8WKFREVFWX8l5CQgODgYLOkVEBAgMl84eHh7tgcIiIiIiJFO3YtU+4QyEWfbzlnfyYiIpmopqVUQUEB9u3bh6lTpxqnabVaxMbGYvfu3YKWsXTpUowYMQLlypUzmb5lyxZERkYiPDwcvXv3xjvvvINKlSpZXU5+fj7y8+/We8jMLD5Z63Q66HQ6RzZLUUpiV/M2kPJwvyIpcL8iqcixb+n1epO/CwvVfT1B5tR0zCoqvNt99HzqbZvzqmF7PJm1/aqw0LxlFL8rcoSajlmkXEL3H43BoI7yhdeuXUP16tWxa9cudOrUyTj9lVdewdatW5GYmGjz/Xv27EFMTAwSExPRoUMH4/Tly5cjODgYderUwblz5zBt2jSUL18eu3fvho+Pj8Vlvf3225gxY4bZ9B9//BHBwcFObiERERF5o8UntTh6627j9ddbFSIySMaAyKul3AFmHyx+bu2nNUCn11id9+NOrH+mRPGXtVh3xbRDDL8rInK33NxcPPzww7h9+zZCQ0OtzqeallKuWrp0KZo3b26SkAKAESNGGP+/efPmaNGiBerVq4ctW7agT58+Fpc1depUTJkyxfh3ZmYmatasiX79+tn8sJVOp9MhISEBffv2hZ+fn9zhkIfgfkVS4H5FUpFj35q8e73J3z179kB0pXJW5iY1UtMx6/yNHMw+uBMAbCakACAuLs4dIZEV1varkxvOAFcumMzL74ocoaZjFilXSY8ye1STlKpcuTJ8fHyQkpJiMj0lJQVRUVE235uTk4Ply5dj5syZdtdTt25dVK5cGWfPnrWalAoICLBYDN3Pz88jfrSesh0kH4PBgG93X8Q91ULRsnoIAO5XJA3uVyQVOfctX1/u155KDccsXz/htwdK3xZvUXa/8tGa9/bgd0XOUMMxi5RL6L6jmkLn/v7+aNu2LTZu3GicptfrsXHjRpPufJasXLkS+fn5eOSRR+yu58qVK0hLS0PVqlVdjpnIW208kYq3/jqGBxcJq/dGRERERERE3kc1SSkAmDJlChYvXoxvvvkGJ06cwMSJE5GTk4Nx48YBAMaMGWNSCL3E0qVLMXToULPi5dnZ2Xj55Zfxzz//ICkpCRs3bsSQIUNQv3599O/f3y3bROSJLtzMkTsEIiJVOJuaZTbtl32XZYiEiDxZ8u08uUMgIrJINd33AGD48OG4ceMGpk+fjuTkZLRq1Qpr165FlSpVAACXLl2CVmuaZzt16hR27NiB9evXmy3Px8cHhw8fxjfffIOMjAxUq1YN/fr1w6xZsyx2zyMiIiIS083sArNpCzefw8v9G8sQDRF5gp/2XDKbduFmDqIqBMoQDRGRbapKSgHApEmTMGnSJIuvbdmyxWxao0aNYG2AwaCgIKxbt07M8IiIiIiIiGSTlmOe7CYiUipVdd8jIs+TmpmH7/65iOx8DlVMRERERETkTVTXUoqI1OVMarbN14d/+Q8u3MzBgYu3MG94K/cERURERBZZ6WBAKpdbwId/RKRMbClFRJL6df9Vm6+XFEXfeDLVHeEQESmKXs8MABFJ79mfDsgdAhGRRUxKEZFszpZqRXX7jk7GSIiI5PFu/Am5QyAiL5BbUCR3CKqm1xvw5h9HMYfHbCLRsfseEYnuZLL5EOeWvLDioLSBEBEp3LFrmXKHQEREFpxNzcakH/ejQZUQrDp0zTj9hb4NEejnI2NkRJ6FSSkiEt2v+68Imu/I1dsSR0JERERE5Lgnvv0X52/mCH7YSkTOYfc9IiIiIg9VWKTHcz8dwGx2OSEicsj5/+qeEpG02FKKiIiIyEMt33sZf/3X7aRnwwh0rl9Z5oiISEqX0nLlDoGIyCFsKUVEktJoNHKHQETktZJKPek/dIVdpklcW0/fkDsEKiM1K0/uEIiIHMKkFBEREZGHysorlDsE8mCPfrUHBoNB7jCIRLfv4i25QyDyGkxKEZGoXLk43XX2poiREBHRin8vyx0CebjVR67LHQKR6B74fJfcIRB5DSaliEhUN7LynX7vdialiIiIVCXxfLrcIRCJqkjP1n9E7sSkFBGJSuh5PIkjmhARuVV2vk7uEIhIYkynuG7Agm1yh0DkVZiUIiJJWevOt+lkqpsjISLyLroivcnfCzefkykSUhOOT0Le7kxqts3X919ivSkiMTEpRUSSSnWgOx9rpZJQp5KzsO+mhgV2iWxgoV4iIvE9siRR7hCIPAqTUkQkqVWHk+UOgTzQvQt349szPthxLk3uUIiIiMiLsOQUkbiYlCIiWfB8TmI4mZwldwhERESKkXmHteOISF185Q6AiLyLrQLnBqaqiIiIZOVor+jrt+9IEwg5ZcK3/8odAhGRQ5iUIiK3KSjUo+fcLQCASuX85Q2GiIiIXLbhBAcuURJ2LSMitWH3PSIS1de7Llh9Lbeg0Pj/aTkF7gjHTJHegMIyI1IREXmLqxls1UJEZM25G7ZH3iMi8TEpRUSi+mLreblDsEqvN6D3R1vQ48MtKOKjRNXS87sjEuTnfy+bTePvh4jIuj4fbZU7BCKvw6QUEblN4oV02zNIfK90+44OF9NycTXjDtKy86VdGUlm93mOuEeeL09X5PIyftt/VYRIiIi8g44t6YlkwaQUEblFWk4Bnvxun9xhkAfIyS+0PxORCty0kRz/dNMZN0ZCRER6B6r8n07h6L9EYmFSiogkV1AEdHxvi9xhEBEpyodrT1l9bd/FW26MhIiI8guFt5R6ig9aiUTDpBQRSS5DnprmZjaf4ghBaldYpMfLvxw2/u3o0OVESnIr1/0Hxz32ulGT1zt69bbcIRDJ4o3fjwqeN+OOTsJIiLwLk1JEJDml5A2m/Hzo7h8a+eIg560+ch23S10IfrieXZyIHPHiykP2ZyKvpdcb8PyKg3KHQSSLvw5dkzsEIq+kuqTUwoULER0djcDAQMTExGDPnj1W5122bBk0Go3Jv8DAQJN5DAYDpk+fjqpVqyIoKAixsbE4c4Y3OURiysgXlgFypC+/q9jCRp1u88kkEZFkinhyJCIiN1NVUmrFihWYMmUK3nrrLezfvx8tW7ZE//79kZpqvUtOaGgorl+/bvx38eJFk9c/+OADfPLJJ1i0aBESExNRrlw59O/fH3l5eVJvDpHX+N8JH0HzLd5+QeJI7lqwgclnIiIiMRTpmcwi75Keo5DaFEQeQFVJqXnz5mHChAkYN24cmjZtikWLFiE4OBhfffWV1fdoNBpERUUZ/1WpUsX4msFgwIIFC/DGG29gyJAhaNGiBb799ltcu3YNf/zxhxu2iMiz3MiyPpKU0vy055LcIRAReRWDwQADW+J4pPgj1+UOgYiIVMpX7gCEKigowL59+zB16lTjNK1Wi9jYWOzevdvq+7Kzs1G7dm3o9Xq0adMGs2fPxj333AMAuHDhApKTkxEbG2ucv0KFCoiJicHu3bsxYsQIi8vMz89Hfv7dm+/MzEwAgE6ng06n3q4lJbGreRtIXiv2XLQ/kx3u3P+4r6tPUVGR2bQjl9PROCpEhmjIE7nzXKizsD+XMBgMksUgx7HPYDBg9Nf/wmAAvn+sHTQa7yrsp5ZrLEdGHyvtZtYdxW+bJyq7X2XnFwqan8ThyZ+nWo5ZpGxC9x/VJKVu3ryJoqIik5ZOAFClShWcPHnS4nsaNWqEr776Ci1atMDt27cxd+5cdO7cGceOHUONGjWQnJxsXEbZZZa8ZsmcOXMwY8YMs+nr169HcHCwo5umOAkJCXKHQCp16qoGgLCuetbEx8eLE4xFpoc8addFUjiWbL6PjV68CzPaWr+5J3KGO86Fm09ZvwxLS0sX4RhleflyHPuydUDiheJ4Vvy5BqH+bg9BEZR8jZV6B/jgsA+cGQnk2LFjiE8TPnIZiatkv8rRAbZu73jdY49jt8be8Hkq+ZhFypebmytoPtUkpZzRqVMndOrUyfh3586d0aRJE3zxxReYNWuW08udOnUqpkyZYvw7MzMTNWvWRL9+/RAaGupSzHLS6XRISEhA37594efnJ3c4pEInE84Al1yrCxUXFydSNOYm717vtnWRNNITL+GXC6YPIvINPoiL6y9TRORp3HkuLHtMKq1ixYqIi2svyfLlOPal5RTg9X+3AABiY/ugcvkAt8cgJzVcYz27/BB0+hSn3luhWl3EDWgkckRkT9n96lZuAab99zuzhNc91l24mQPs3unQezz581TDMYuUr6RHmT2qSUpVrlwZPj4+SEkxPVmmpKQgKipK0DL8/PzQunVrnD17FgCM70tJSUHVqlVNltmqVSurywkICEBAgPnFlJ+fn0f8aD1lO8j9Pt/meqFyd+573M/Vx8fHUks8Db9LEp3U50J7tZU0Gun2azl+L36+d7uF+fp673WGkq+xtFrnu1Rm3ClS7HZ5g5L9ys/X9nFF6u+oSG9A5h0dwsuprynkfQutl4OxxtfX1+O7Iiv5mEXKJ3TfUU2hc39/f7Rt2xYbN240TtPr9di4caNJayhbioqKcOTIEWMCqk6dOoiKijJZZmZmJhITEwUvk4iI3MezL/3Imxy4nCHp8tOy1TPwBBF5hpGL/0HrWQk4mSysdYSSOFNP7ac9lyWIhMj7qCYpBQBTpkzB4sWL8c033+DEiROYOHEicnJyMG7cOADAmDFjTAqhz5w5E+vXr8f58+exf/9+PPLII7h48SIef/xxAMVPIZ9//nm88847+Ouvv3DkyBGMGTMG1apVw9ChQ+XYRCKSgMFgwMLNZ+UOg4jIKCvPdkFiV7296rikyxfL8WuZePuvYxxencgD7LmQDgBY+e8VmSNxj2m/H5E7BCKPoJruewAwfPhw3LhxA9OnT0dycjJatWqFtWvXGguVX7p0CVrt3TzbrVu3MGHCBCQnJyM8PBxt27bFrl270LRpU+M8r7zyCnJycvDEE08gIyMDXbt2xdq1axEYGOj27SMiaaw7lowP150ym15YpIevj6py80TkAW7f0eGTjWckXceFm9mSLl8scZ9sBwDsOHsTG6b0kDkaInWz3XmvuAVlJS+r50ZEyqeqpBQATJo0CZMmTbL42pYtW0z+nj9/PubPn29zeRqNBjNnzsTMmTPFCpGIFOZy+h2L07/75yLGdanj5mhIbHd0HHmP1GX6n0ex7+ItSdehUVhn12W7kmy+fjZVHUk0IjV77bcjWDymndxhEBGZYBMB8lisp0El3o0/YXH6jjM33RwJERGw978uLrYkCpjHFqXV3v10E7tQE0ntVHKWzddPXFdfrSci8nxMSpFH+m53Etq+s0Hy7hFE5F7WuibcZBKaSPU2nUyxPxNJRmmt69Ky87Hy38vILZC2/ponGbn4H7lDAMBBSYjIMUxKkUd6889jAIB5CadljsS9ft13Bb/u847ikuSdrtyy3BWz3Tsb3BwJkfPs1X3xVo8t+1fuEMhJBgn26keW7sHLvxzGW/9d0xERkWdiUoo8nsHgHZf/WXk6vLjyEF5ceQhZeTq3r/9Miu0m40q0+3ya3CGQg77cdl7uEIjIRQVFjg+9Tsp27kaOS++3dK1W0tUs/sh1l5ZNRETKxqQUkYe4lJ5r/P+CQvdf8A//Upwm4+5MIuYWsEA2EZG7PfrVHrlDIJEdupzh9HtPJWchZvZG/Jh4yTgtJ/9ul71CvXc8XPQkSqtpR0TKxqQUeZwLN02f1uXLkKCRw6QfD8i6/vScAlGWcyOLtYGIyLN5SQNeo4xc0/PD2dRsvPHHEew8y8EmCHjll0NIzcrHtN+PGKfdKrXPsGUdEZFnY1KKPE6vuVtM/n5/7Ul5AnGz0sk4DR9RASh++popQ1dGIiJbkjPz5A7BrRZsMB905Pt/LmHUkkSz6aeSs3ApLddsOnkuXdHdLO3ldPPv3tuSuOR+lvY7InIfJqXI460/5n2j+aTnqLe10eTlB5Gnc71b3b6L6ei/YBt6frjF9aBIFb7ZlSR3CESKcf22chJfaQ60pO2/YBu6f7gZY7/egyu3cjnymhconXM6dq24jhQTUeq286y6anayNR6RvJiUIvJAU34+JHcITtt9Pg3vrTmJVYeumXX5cMT7a08BEK9bIcnPXr2xt/7iCE1EJZTSFXrn2ZtYdeiaw+/bcuoGur6/Gd3e3yxBVGSRi42sHakJef32HXy57Rxu5+oEvS/6tdV4eaV6r22kVqQ34JON5i0Sy7I2gq3Yjl/PRCIHkyEigZiUIo/nSmJDrQ5fuS13CC5ZtisJz/50AKOXOlcMV1ekx54L6SJHRXLbeCLV7jznbmSzGT6RgljqoucIR1pZkbzuONDKefgX/2B2/En0mbfVZLqt6gMr913BsWvqvr6RyveJlzAv4bTcYZjYd+mW3CG4xfYzN+QOgUj1mJQij1IyfHBpORxhTbWOXL2Nhxf/4/Boggs3n5UoIpJTmoBuqX0+2opuH2x26yiORGTZ7VzW9PMmGgeaWpWMGHwzOx8nk7MEv+/2He5TlsQf9b5SFUrx5bbzcodApHpMSpFHeW+NdxQ19ya7zqVhzdHrDr3HUlFdaxxNeBERkTAnks0fFJHncssYK3zeYNH+Sxlyh2BGV6iOL0uvN2DW38flDoPIqzEpRR5l62nLTWgPXc5wbyBuVqSX98QvdWInX8Ll/37gimTLJvnIUUtsb1I6Eo7ffVptMBjwxdZz2GbluEQkpyK9AeuOJSPFy0YCJGXj2MGeY/6G06po2bbmaDK2nOJ5mkhOTEqRV1i83XOb1q47lox60+JljeH1349Iuvyl2y/giMA6WYUOjqCSlefdIzvlFhRiz4V05BcW4eDlDJxNFd6NQsnkSNMOW7QbE779F1czigvJbj19A3PWnMSYr5yrjUbkLCHHyxV7L+PJ7/ah19wtksXBXrRkSU6+d593vcnGE8rvVniUdcqIZOcrdwBE7vD34et4Z2gBwoL95Q5FdE9+t0/uELByn7StjU6lZOG+z3Yg6b1BZq8VFumxfO9ldKxbEfUjQzisr4MeXpyIg2VaEp6cNQCBfj7yBOQBUjPzUD0syJicAorroFy4mQNfrQb1I8vz8yVJ/X3E9mh3r/9+xDg6X25BEQwGAzQS9L0ysK+VVxG6C+XaqPVZsh9aG7CFexSJ7UyKaw/jtp+5KVIkRN6LSSnyGv+cT8OAZlXlDoNE9tOeS3jzz2MAgL2vx3LUPQeVTUgBxTcMTJo4r+SmqXQrkZYz1pvMYynBSt5BCXXsfki8hF6NIox/H7icgTa1wkVfz3yFjQZGtrmalhRa6FxIsvKZH/dbfi+zUiSyDQJG9iUiabH7HnmNZ386IHcIHmPTyRR8vOEMPt5wBuduZMsay4FSxT3bv7vB6oUsiSc7vxBrjyYjz4Hhv8XgyMhOSr9x2e8lQ2WTudd+PSx3CGZy88X/LRsMBuxN4n7uTdxR3/LDdRzQxlV6N9YhdUvxey9xK6fA4RIVRGrBpBR5jCV26kbpihR+l6oSadn5eGzZv5i/4TTmbzjNEQ9VzNkbiInf78NT3+/D238dEzki8cjZbUjINfjtXOUXf/UWmXk6vPXnUYutBqWQkqWMwuKFpX7/768V/zieY6OLFimTq0dNwcl2GytKOJ5s862Hrtx2a1JFbHq9Act2XsDhKxmyxfDLfg7wojYX03LQelYC7vtsp9yhEEmCSSnyGO+sPiF3CG63bOcFt6/zVpmb6Qs3c9weQ2lqvTQ9du02/jpku+6LPa4WJj9g5Qbi+DXbw7iX1E9Yvvey0+t2VGpWHr6SYX8XwmAw4FipQqm5BUVIzcqznbTj02NZ3L6jw9x1p/D670ew6WRxAd7xy/bim90XMXThTqQqJGHkDqXroBy5ykK/5LofEi+6vIyf/7WfMHlg0S6X1yOXVYev4e1VxzH4s53QydTqRc6EGDln9ZHrAIAT121fn3mC/MIinJe5Fwa5H2tKEanU6ZQsvL3quNxhwODGflJJN3MQXbkcEo6noEKQH77Yeg4bT6qzFsCgT3YAABKOp+DTka0dfv+NrHwMXVj8xOzEzAEI8ne8BpS1h83jv9mLU+8MdHh5Uhq1OBFnUpVxkbI3KR1rjiTjxX4NsedCOsYt22vy+qgliXaXMe7rvawrJYMpKw4ajxk/JF5CSKCvyQics/4+gXkPNpM0BnccMh3p6koklvgjtls5iaV0t321OZl890HST3suYUynaLfHINXxIS07323r8iZLtp/HB2tPyR2G24z48h8cuJSBxWPaoW/TKnKHQ27CpBSRSt3MMj/5y8GdLZW+2HYOj3eriwnf/ivaMqUYccqe0l0cVh265lRSqvTIbk2mr8XvT3dGawcLFVtLKOYroBBzWUpJSAHAsEW7AcDlllvpOQWoWM7zRgRVsrJJ7NIJKQAmLd7INe58YEHqwj2j2PXb8rTMlOqyR+qRmL2Vt/UEKUk6r9h7mUkpL8Lue0QqpZiLOjcG8tOey9h/UdzCubvOun8o318kuHATM1HnCaR6OitmId9feQHvVskCbgDP38jBA4v+kTQOvRuSNc7UVMvJL7Q/k0yOsnuh5LLydFjzXxch8mxqbbuUladDkpMlI45evY2xX++xW57AWYnn0yRZLpG3YFKKSKWU8hDa3WG8/Iu4I1fJ0f3vx8RLJn9n5jle9LpsK4Sb2QVW5z2bmoU/D141e8/3ZeKw5vrtO+j54WYs2X4eF9PkrSEmlFStNDrO2Sjast6N966nn3J766+jguY7fDUTp25Ld9vmyK7pjtHMSnyy8Yzb1uWo+QmnRV/m51vO4bVfD7NF13+e+fGA1S7dSlTy29h0MgWz/j6uylHJ5EoOubOFuJiripm9ET3nbsGZFMdraT7w+S5sOXUDw7/cLV5ApayQoMZm0s0crD5sOVH87urjHImSPAqTUuRVvt2dZFbcWa2juBy/zifHnuKcxF3TYudtw+TlB7HxhGkCbpXAQuvvrzmJpLRcvLP6BHrO3WLymlJv6EoXcRbLz/9exg2FdJslx9wpKMK6YymC519zWRmXR7+6cZSsi2m5bluXowpESjgs33MJgz/bgdSsPLy/9iSW772MfSK3vlWrbadvuG1dP4twA//1f92nH1v2L5buuCCoQLoSlL7mlOvsuWxXEgok6KYvZaqrsEiP3P9G9HTm/F5SlqCky3ZBoR5z1pzArnPiXCv8duCqKMsprefcLXjmx/1m01Mz87B4+wUs3HwOuQXKbeFK5AhlXHURucn0P4/h/v/tMt5I701KR9O31ooyYoy7zY6X5wlJfqHpMN9KTUoo1SULN37u+gQPO9AFpvT3qisqdRFdJtipvx1xOS4ppEqQPJotQcumLCdayZFjzqZmocn0tQ69J0WC/Mzxa5nYm5Tu0HvOOTkCUYIDCbgSa4+JW6S6dEFnV4mVZH7ttyM4fOU2PixVNDinoMjGO0gKH4nQ8m3R1vMmLQnLjkrmzlaGjvhi23nj/3++5ZzDxwSx7BQpGeMuX26/+7mJ8c1+sysJX2w9j4cX2x+YRGlK1/1U6G5O5DAmpcgr5en0uJyei2GLdiNPp8frvwvr1qEmUtXgeL/MCCA8ITrmoEhDMbv6sdtLJgodRWm5BE3WleqOBDevS7a7Viyd7Iudt83h9+QWaXDl1h37Mzog7pPtGLZotyQJ07LOO1l3RUyPf6PcOne5Oiai1O5mdj7+KNU65bt/LiLvv+91fsJpNJ2+Fqed6OblbiUDZ3gCKXsFlh59ToyHoUkqKUVgSey8rXKHQCQ61SWlFi5ciOjoaAQGBiImJgZ79uyxOu/ixYvRrVs3hIeHIzw8HLGxsWbzjx07FhqNxuTfgAEDpN4MklmT6WvR7YPNJtM8rcWPFK06APMm/koujqtEYu1n+5Jc63JiL5loqcm4mry/9iQ+3iBejZwivUGSUQnzCnlzrFS95m2XZLlXHUl2qfi0dPuOOloBWjsmn7uRjdu56tgGb/XiykMmfw//8h8kHE/BxxvPIL9Qjzms22eVFPkjKQYYKSjU4701pj0D/jgoflc5NSl9LaLWovVEZakqKbVixQpMmTIFb731Fvbv34+WLVuif//+SE21XKh4y5YtGDlyJDZv3ozdu3ejZs2a6NevH65eNT2YDRgwANevXzf+++mnn9yxOaQwv+73rJOcu3JsaTnWC2yrhRrriq3414kWSh6WeLVn/gbxiiNn50mUfPWur8TtftojrJi/NbckOL45MzIeua508ulyuu3+mWdSstDno61oOXO91GE57WrGHRy6nCF3GIpy6HIGR6JVGFeLqn+7OwmLtp4zmXb0aiay+UCUyKOoKik1b948TJgwAePGjUPTpk2xaNEiBAcH46uvvrI4/w8//ICnn34arVq1QuPGjbFkyRLo9Xps3Gg6elJAQACioqKM/8LDw92xOaQw3/2jvrpSJI6zTtZtccbc9afMph1zYohioS2u/hThiSJvoqX7DMQq4EzmDAaDyzXPWs9KECmau6TOgSu1lo7cSg/0cPjK3e7tlj6tvvMd7/Lpbl3e24QhC3fivBvPX0Tu9s5qy63dfnfjIBBy2CxwZGg3DqRIJCnVJKUKCgqwb98+xMbGGqdptVrExsZi925h/bFzc3Oh0+lQsWJFk+lbtmxBZGQkGjVqhIkTJyItLU3U2EklvKwVCcnjcrp51503/3C8ppmlvdXSyHCTlx+0+P71Aooac1Qq6X29M0nuEDzW8euOJ3stEbtrtyPL0zuxbqnqCardplNWbvIMxfWJZv19HGdTs1TXZc+ZhxokDynqEiqJWMfcEraKwLt6VM6QoHvxWZFGUv5mVxLGLdsraF4lj5pK5AhfuQMQ6ubNmygqKkKVKlVMplepUgUnTwobhezVV19FtWrVTBJbAwYMwP/93/+hTp06OHfuHKZNm4aBAwdi9+7d8PHxsbic/Px85OffvfnLzCw+COt0Ouh06rqYKa0kdjVvgyvydUUete2X0nM8anukpITfrqX1bzyZio83nsNHDzZHgyrlTV4zWGgN0f7dDTgzq5/VdRTp9cb1TP/TfiLswo0stKhW3m73xqe//xcfD29pd3lyEOt71emk6ypw8loG6kWUk2z53kivN2DQJztEWdanG09jYo+6oiwLcKyl1O5zaQ7vwwUu7PNyHwdtcTW2HxMtd+U8m5qJZTsvYOuZm/h2dxJ6N4oweT0/vwBarevNEaS6xioqUta1ixixiLU9er1BUZ/NzjM3LE4vKChwupubTqdz6pmqXoL9xlLL7KLCQqfXs91aIhmu7fc6nQ4bjjs+Qqk9a49cw5Pd67i8nLf+OiZ43pFf/oO903q5vE5L5L4vNBj0ivr9knOEfoeqSUq56r333sPy5cuxZcsWBAYGGqePGDHC+P/NmzdHixYtUK9ePWzZsgV9+vSxuKw5c+ZgxowZZtPXr1+P4OBg8YN3s4QE8bsrSO34LQ0Ay0lEoW5kZCE+Pl6cgNzC9s/3akYeVq+Ol6Bpr+cdNj77YwcG1HRXSznLn5+lfW/y7uJ54z7bhfkdC1H6vig9yweWSlz+vToepvdPd9d39sxZxOcX11nKz7f8/tIOHTwIv6sHkHxdC1sNa+OPpqB/iNS/Hef2O7F+09k652OwZ+2mragTIsmivdY/qa6fE0rM23AWtXOEPfyyzfH9JzX9tsP7cFKWc+sCgN9XxSNAnI/N6Riscf23bDmed+PvdqnWFRmQcDwFpY+Njd5KwMedxEtKi3eNVbw9Bw4cgOayGOcvcb4vYd+T7XUVL8P1eFJvpCrquu6YlWvVH/5Yg4oBzi/3yC3HL/T27N2LrDMiX/cYzK8rDhw8CM3lA05di56+bP04nnjwGCqmFT9cu5ZbfIUSZeUW7FI2UHp/io+Ph77I/jWQo06dOon4bDGK6wvf9zPu6ATv4zk6wE8L+Dt4jHf/fWHx9qekpCjq90vOyc0V1ppPNXeXlStXho+PD1JSTDPbKSkpiIqKsvneuXPn4r333sOGDRvQokULm/PWrVsXlStXxtmzZ60mpaZOnYopU6YY/87MzDQWUQ8NDRW4Rcqj0+mQkJCAvn37ws/PT+5wHPLXDwcAWH4CJVRavgZxcXHiBOQGk3fbL8C6KbcmPhrW3O3rVZs1V3zwyZPWWxiJydrnZ2nfKz3v/85XQPyzXewup/+AAfDz0Vqcr179+oiLrQ8AeOfIFkBnu4hzy1atENeyKtZkHgLSbT9VlPq34+x+J1Zck346CEBYjQdHtWwbg671K0mybG/18cc7AYg35LcY+5Ez+3D58uUQF9fVofccunIb848mOrwuAKjfpguaV6/g1HvLEvtc4cp3cDolCxBY6kFv4Ua1aUwPRFdyrTWj2NdYJZ9v69atEdfc9nWwI8tzlZDvyd664uLiRIknMiIScXFtXF6OWIJP38CXJw+YTe/VqxeqhwU5tUydToeln220P2MZHTq0R7f6lZ1apzVTEhPMmoJ+e8YHR/IqYMWEDg63Bju36RzWXjln8bW1V3zw6ZP9cCo5C5MXFv+2T7wdC18f8wdoDd403Zfi4uLwyt4NgMgj6jZq1BhxIrSUcnTf/zO9Km5m5+Pbce1QLsD81n7N0WSsOpyMhBOpCAn0xf7Xewtarlz3hSXbX6VKFcTFtXbbekkaJT3K7FFNUsrf3x9t27bFxo0bMXToUAAwFi2fNGmS1fd98MEHePfdd7Fu3Tq0a9fO7nquXLmCtLQ0VK1a1eo8AQEBCAgwf6Th5+enumSOJWrcjo0nXUtIlVDLducIHHXkr8PX8cnDyrkgUzK5v/uy699/ybSe05nUHEEx+vn5mSSlSvPx0RqXIeTi0NfHB35+foK6roxcshfP9mmAHg0j7M7rTmJ9r+uOS5OQAoBx3+zD7093RutaHGRDDMt2XsD5m+IlpADX96OdZ2869T6NRuPwun19nb+08/MtPv8bDAZk5xciJFA550RXvoP31p1xad3zN57D/0a1dWkZJcS+xvL57zitFGLE4so+XJpG6/jvR0rWyoLIcd3t6+Mr+jqtDbJw4PJtpGQXomZFx3qTaK1cy5Tw8/PDvQvvJpuTswtRp7L95LFUn7W21DWWO206VXwP9NXuy3i+TwOza7bnVhw2/n9WXqHDMcp1X6jRyPN5kriEfoeqKXQOAFOmTMHixYvxzTff4MSJE5g4cSJycnIwbtw4AMCYMWMwdepU4/zvv/8+3nzzTXz11VeIjo5GcnIykpOTkZ1dXIguOzsbL7/8Mv755x8kJSVh48aNGDJkCOrXr4/+/fvLso1EQuSL/HSH3CO3QHgXkPfinesuJGZN5h8SLwpe5r8Xb+HRr/bgYloOBn+2A/FHrosXiAvydOooLHv//3bJHYLHeHvVcblDMHE6JQujljjXcsnV4dQdX1/xf2esOo7mb6/Hdis1cNRm+xnnkoIl4o/YHxiCxHPllvmAIM7YlyT/YB15uiIs2X4eZ1Oz8fuBa5KsQw3j9DhzKNM42L1OJ3A022sZdyS5jpb7e/hk4xnUnRaPc3ZG5LRXJ5RIDqpKSg0fPhxz587F9OnT0apVKxw8eBBr1641Fj+/dOkSrl+/eyP0+eefo6CgAA8++CCqVq1q/Dd37lwAxU8sDh8+jMGDB6Nhw4YYP3482rZti+3bt1tsCUVE5Io8nfCLoD0WRp05UmoYc2v+sFBotMTmUkVDUy2M1FfWXicu6F/99TAOX7mNp3/Y7/B7pfDeGjFqAZFapGblyR2CmVPJWU6/V+yR/+wpuXFctisJAPDhulPWZ/YyL6w46Pbvw1s5M+qkJVkCW5VL6fMt5/DO6hOInbcVqw5Jk5Ryxm0JRp+zRYoEu7O/x87vbRI5kmJKOV72+WirzcTU/A2n3RgNkTCqSkoBwKRJk3Dx4kXk5+cjMTERMTExxte2bNmCZcuWGf9OSkqCwWAw+/f2228DAIKCgrBu3TqkpqaioKAASUlJ+PLLL81G+CNlW7rjgmjLEnLTT54pSeTuPpa4ekNz32f2RxN75Ze7zbTLPjU8etW54ZrvONDaKCtP/puA0tYcVUaLLXKPTIlutNTS4s5VWpFuHK9miNPSRUl+P3DVqUS9t8lWQCJIScp2xbfEve0hiz37k3ltKymddiI5b6/b89bTntGSUwp9PtqKXVY+v083nUVWnjTnyjsFRXh++QHFtJYn9VBdUoqorFl/i9dV42aO/dYj5Jne+OOo5Ov4ZvdFyddR2pLtridsDQYDtpwSfuF3TWE3o442/5fTzWwef1z1637rLQVdMfbrPZIs1x65uu+VOOzkg5q3HRjSXE2kupHzJO+zdarDkm7mINOFfUsN7fee+O5fh99jqcV4ab8fkOZ47ynGfGX9vNX87fU4mezcg0pblu44jz8OXlNMa3lSDyaliErZ4WLdCVKvHU4WInbEJxtdK7brKEtPGR29qXK07sKtXN60OWvfRbbCcNXnWyyP1OSqf87bvjmSioAxBsw40yKhhFhJXCUlb8S88Zr+p2cm28R06EqG3CGozsNLEtHi7fUoFFgTSY10ReKnzv48qJzukEpUqDfYrAs4YMF20dc5dz27BpJzmJQiKkXMroBScqQbmCv1TEh5hHQFsOVmdoFD8x+6nOHS+jzBYd5kkUyuZTheI8te6wJb0nMK0HfeVqffX0KKOrqpmc7VCxPzxssTuyWK7U6Bd3R1FaJIb8D5G8JLA/Sdv83qCHbe5vptx39rJZfGl9NzkXxbnvqCStv/Ry91XyvfycvF7RK64UQKXvv1sP0ZySMwKUXk4a5m5ModgmqctzNiiRL8n4ujtJ1JycLldOH7xCQ3151QIrkubskxtz2wlZ4z9XlcKV332eYzOJPq+nFQioLgbznRJbCAI9W6ndJGB5Zz8IOxX+9xKJF54WYO6k2Lx6BPtgseSU5NHEm4OVsUPjUrD90+2IyOczYaawm7k706WJ5MipZry/deFn2ZpExMShF5ODFHWPH0kYd6f+R6CwExuFJbAgC+3FbchcnSyENPfLcP769lzQ9HuGuvv85WGC6Z9scRuUNQBIMLe6yuUJy9XYpThTM1134/cEX0OJTWEkJpLqXnYvuZG4q5Xnj8G8drGYllu5MlIY5dy0SD19fY7HqlRo50R3Z29xny2U7j/2s0GpxKcW9vgSKF7PdCidUa3tLvncXOyRFOJaUyMjKwZMkSTJ06Fenpxc3E9+/fj6tXWXCOSGleWHFItGWdFeEJutLpFdB03l43FXtJq9nxxUknaxcbjoyQdyNL3cW33Vwn2iVvrxJv0AZvk5KZh9WHeQEMwKUsqli/F71CbsykGA30s83urQ2oRqOX7sFqKzekQuqNnU4R71rD2WL9SiC065Uyfm32OTJwgzPbdEdXhOtlWja7u7Xkk9/tcykh6+7um0MW7sSxa67/RiyVhvj+H/cO7kPq5nBS6vDhw2jYsCHef/99zJ07FxkZGQCA3377DVOnThU7PiJSkH+9oBDzF9vOyx2CXWMEXKjaurBx1zDKSkjwiXGPrZD7a7JhphsSensuOFerSU27T6KT21iWFD99pYykeS5VeI0gbzbpxwPILTBPCn4koBDyCysOShCROkW/ttrugyhPPEc5k9geunCn2TQ5PhtXas/9b/NZESMRZtAnO1xexvhv9ppNE6sGX/RrqxH92mqLxxPyHA4npaZMmYKxY8fizJkzCAwMNE6Pi4vDtm3bRA2OSE6nU7Iw+LMd2HwyVe5QFGPdsWS5Q5CcGrq2HRTQ3Prvw/KPSqOE62RHnsySellrlSGmZbtUMhCGyMs7eDnD4Sf/ktTDceKnLMUNqSvdI6WgrGhMfbPLvKWEkMFX7ujYRbK0Fm+vV8RDHncS67ertk/towT1jV535Mptiy0SL6aJW9N2+R7Wl/JkDiel9u7diyeffNJsevXq1ZGc7Pk3rOQd9HoDnvxuHw5fuY1xy8yz/3KT6yS75ZRn1TdQErHrb0xeflDU5TlDzTcWBoMB+y6mIz3HsdEKyXM52w3E3WlRsY8lQxfuRJ2p8Ui6KbyF0LFrmaLGADjXUk1pCSRvY6llg5DvhI8SzNWdFi9qjVA5rD3q3vvEnh9uxhk315QCgDyd+orUn3bhc7rvM9dbWgmRIuOgBSQ9h5NSAQEByMw0v9g4ffo0IiIiRAmKSE56vQFDFu7EBQcuwN3N3Sd2byPHkMxqvIix58+D8tcZdLah1JbTN/DA57vR7f1N+OOA/NtB1uW5Kfm54YQ6Ws1KdfSa+bf6ap5J0lKKeS6SScfZG+UOwSWzHDiGiJFcT0rLxcu/HHZ5OY5666+jbl+nq0YtSZQ7BLu+2Hoe0a+tliXRSNJzOCk1ePBgzJw5EzpdcbZeo9Hg0qVLePXVV/HAAw+IHiCRu127fQdHriq7MOYbf6jvhKcmX+2Qt5vOtQzPeBokR3KvrCu3nKtpsOm/BEROQRHWekG3VTX7Yqvy68B5AiX8npVg/fEUuUNQNSG5BrF7XV9MU+5DRkfc0RUhzYlRKNVIzcnfnWfT5A7BYWoa1ObJ7/bJHQJJwOGk1EcffYTs7GxERkbizp076NGjB+rXr4+QkBC8++67UsRI5FZd398sdwgks5//Fb/fur2uP6W7NIz5StiIO0qnlBoYznS7SstRzwWat7tw032jgjqTmElV0cW+LUK3XOzug6U5ekxRxhFI2bLydPhmV5Ikyy608H0J+U7E3oXe+uuYuAuU0UNf7Dab5on7uSduk9Kdu+H4udTdoxsCwE0vScx6G4eTUhUqVEBCQgJWrVqFTz75BJMmTUJ8fDy2bt2KcuXKSREjEZFbnUkV/yb3OztD45ZchLtjFDF3UUhOCkBxcV0hBXZLbD99U8JoSEw7zrrvu/rrkONdOe+4ecQgd7Qw+OvQNTz+zV6Lo4JJObpn3WnxOGKhoG5ZRXoD3vn7ON5bI83AFWpqVWDP678flSxpc8nJQsdit5TacuqGpMlSdzp3I0cxD3wcle9AAsNDvi5VGbhgu8Pv+f3AFQkisS0zj6PweSKHk1IlunbtiqeffhqvvPIKYmNjxYyJSHHEGtaUvNd5gU+gvtqpjhG+hFDKNWV+YRH6L9iG/gu2Ca8/xEq7qnEz233F6F9Yccjh97h7BEh3/O6e++kANpxIxcJN5sOXO1OQ3BH3fbYDt3N1KNIbsPlkKkZ8uRuHLmfg/I1sHL16Gy3eXod60+KxRMJu2M60KFCqjSek645ocVRMId33JDgArzvm3m6XQs/5zvhhzyXJlq0Ux68ru4yGJypwYtTUy+n274/Scwrw16FrotZ/lGSEV5KVr5CZPvnkE8ELfO6555wOhkipPlx7EgtGtJY7DHKjXWdvonP9yqItz16XQKUkcMSklCfTGbl3W3Pk5Bci0M9Hxmhsy8gtQFiwv9xhkA0GgwHHrmWiXkR5BPlLvy9dv30HVSsECZ5fqt+dpeXuPGfeSs0dv/qxy/bgekYekjOL6+8NWbjTDWu9a9rvR7BxSg+3JxwtOXbtNga3rCZ3GFYt3XEBozvWhr9v8XNwIaPvOXNzbM+VW+IOT2+PlA+Y3vzjKEZ3rG38WyGnWlG5O4lIjjudkoXPNps/mChrxJe7cTolG+O71sGb9zYVZd2bTqai/z1RoiyLlEFQUmr+/Pkmf9+4cQO5ubkICwsDAGRkZCA4OBiRkZFMSpFbuavw6qaTqcgvLEKAr3JvZklcDy9JRNJ7g0Rbnq7I9r6qlASOmDadTMXj3erKHQa6faCeOnELNpzB24PvkTsMsuGzTWfxUcJp3FMtFKuf6yb5+m5k5TuWlJIojqv/DRpw/fbdJ+NHr5qPxuyOQ9mBSxnSr8SG8zdysPZoMgY2ryprHABwI9O1roT2zk2umvX3cRQU6jGxZz0AnplAKetmdj6+/0fa1kzPLz+AZ3rVR3TFQJy87XTHFzcT9uV7wgjTuiI9/HyEfy8GgwGZd+TvlmYwGAQn239MFLaPn04pbjW45sh10ZJST363T9RrdJKfoF/LhQsXjP/effddtGrVCidOnEB6ejrS09Nx4sQJtGnTBrNmzZI6XiIT7iqwl5lXiHbvbHDLuuxxpsmqWusPeBMDPC8xtetcGvILxWuu7Q22nZGuHo8nulPg/v3ro4TTAIBj18wTMpa42pjG4a5MEh1Gzt/MwZt/HEWnOZvsrN6zjmPWeMqonFK0Sipr2+kbWLj5LC6n58q2d7yz+gQ2n0qVfD3f7k5yy/XiHwevoe/8bZKvR0xCLnE2nUzBU9+rf3S1RVvOOTT/mK/2oOXM9RJFI9z2M8JrNCqgoSh5EIdT62+++SY+/fRTNGrUyDitUaNGmD9/Pt544w1RgyOyp1Dvvj7FWXmFKJS5D3NGbgEavL7G4fflitiP25ucTRVeGNtVBgOQluO+2jjuInV9GUcJfQIo17XW+RueMXS5uyzefl7uEOxytT6Ooxf+UiaF7A3YAMiTKJTDcYFJSQJ2n0/Dh+tO4f8+34VsGYsUj/t6r+T1wKb/6d6R/o5fV89+qBeQlXps2b9uiER6JQ8vhHIkGSSlvw5dEzyvo+c2JXR3JuVyOCl1/fp1FBaan1CKioqQksL+v+Re7uq+V2LVYeEHaym0mpng1PuSb7NQuzMu3HRfDQqDweD2/dkdRi/dI3cIqiN38lvpDAYDFmw4jY0nUjDPwQt/Obh6HV5Si0epyh63vt1tP3HlCaQYpdXT3cjKx6kU9z3ssaTPR1slW7YcrZ0vOjnCodiEDAh0K9d8tE5Sll/2XcHopYlIupmD7xMv4cYd4MJN5x+Wle7uzUGjyBaHr3T69OmDJ598Evv37zdO27dvHyZOnMhR+MjtCt18E+/MyEtiuZzu/IXH1N+OiBiJ93j118NOvW/jiRQ888N+3HbgAmzlv1ew+1yaU+vzdELrFghxyYXfkbskKqx1mdJsPJGKBRvOYPw36nii7uqz4ex8x1qWuPu++PcDV927QjKRUyB/HRq1kSp5JEei8rkVzl2niO2KCs6tJMz2MzfRc+4WzPj7JN456It+H+/EgAXbzMqHCHngsvkkSxKQMA4npb766itERUWhXbt2CAgIQEBAADp06IAqVapgyZIlUsRIZJUntiyxZtii3U6/t2SEInJMek6BUxev47/5F6uPXMeH608Kfs+78Sfw/IqDDq/LG0z7Xbyk6tCFOwUlCzNl7GLiTcc1Z3jb8Wyng9063J2UemnlISS58CSdXLPuWAqK9AaPq0kopTsSlTTw5q/AizfdqmGLdskdgmhOJmehwetrcPTqbeM0IQ9cLI3QKpZUL7sW8HQOJ6UiIiIQHx+PkydPYuXKlVi5ciVOnDiB+Ph4REZGShEjkVXubikll4zcApduxAolHl3Hkzm6i5Vu0fb9P5dwywPrRKndZTcPDe4oIXU3vJlWZXUpXA334OUMh+aXo9B4z7lb3L5OJUg8r4zWrb0/2oKHvnD+wZW3keoQq1XXoYkktjfplqDBiXJV1Nrx3k93GFvvCjm3SVlDTsyBC5jUl5/ThQoaNmyIwYMHY/DgwWjYsKGYMREJdlKGAo/OjH7nKmdrSZUQI3nnaBcST+FoUdSy9R2Gf8kbBaXZJeGTOzEs2urYqD3eRmU5KZeTaBtPCr/wNhgMXt1aw91GLv5H7hAAFJ939ibdkjsMr8dCzvZ5281/74+22N3mptPXuSkacTR7ax12nLkpaH8/cEm645JYD6j2XEhHm1kJ+PMgu6LLydfRNzz22GM2X//qq6+cDobIUc8vP+j2db75x1G890ALt61v51nXb6BvZOW7vIwVey+7vAw1eu6nA1j7fHfB85d9Uno6JdukuTPJb3b8SQxsVhU1KwbLHYpF/5xPx6nkLDSKCpE7FEXyxtYID36+Cyue7AQfGxuflp2Ptm4Yip7uUltjbYPBwMQJgFu5BSgX4PAtkF2JF5TRck5Kfx++hi+3ncenI1ujdqVyxulCc00Gg/oeLLjicvodfLntPJ7sUU/uUET1yNJEQfNJWQpBrKTU+GV7kZVfiMnLD2JIq+qiLJMc53BLqVu3bpn8S01NxaZNm/Dbb78hIyNDghCJrMuSofXOcjcnZ0YtEXbgl5q3jgh2MtmxkYIsXfDf++kOscJRpRwFtrJzZTQZd+i/YBvmq2BkOTmo7aZajHj/vXgLh65k2JxnyY4LLq+HHCdlSwBH2eounltQiD7ztuKNPzjwSdf3N0vStf7134+KvkylmfTjARy+cttsIBihLaC8sXv6nDUn8fzyA4j7eDsO2zmOk3Bi9VyR416SzDmclPr9999N/v399984f/48hg8fjo4dO0oRI5FFX8jYxeXYNfe0fMkvlKYYJ0nHG1tx2HPsWiYKCvXYm5QuS/dXS9RQTPzjjWccfs+fB69i7dFkCaJRDiX9xPQC9iOx4p28/IDNGkZp2a63iHXF7VwdUrO8r/Ds/f9TTjHjXh9tsfraqkPXcP5GDr7/R7zRTNVs6P92yh2CIsQfuY458ScEHctK++e86SixQt9d5IVJKQD44+A1HL+eicGf7TTpvXD8mvvLkMhpfsJpjFryD/4RoR7faxxZ3KM4XVPKZCFaLaZMmYL58+eLsTibFi5ciOjoaAQGBiImJgZ79uyxOf/KlSvRuHFjBAYGonnz5oiPjzd53WAwYPr06ahatSqCgoIQGxuLM2ccvxEg9zpw6RbmrBE+spnYBn2yA5tOpki+nl4fbpF8HUJ552WE49TWisMd/rflLN766yiGLdqNt/46Jnc4AIAvt52XOwTRXU7PxeTlB/HU9/tkT1BISUm/se8TL9qdR6xwL6ffwfAvrdcw+vnfK+KsyEnxR69zUA2ZZdgYWbR0K28OwGFe/9Eb/X34Gp7+YT++2HYeG07cvaaNfm01ol9bbTdRVbp1VLrAfSotm/te+3c3GD/j55YfkDsct/p44xnsPJuGETbOZXLKyLW/fw5YsM34/VlSWKTHd7uTkJadj7VHryMz7+5x2WAw4IfEi8YWcx9vOINf98l77lYKUZJSAHDu3DkUFkrb/G3FihWYMmUK3nrrLezfvx8tW7ZE//79kZpquQjorl27MHLkSIwfPx4HDhzA0KFDMXToUBw9erd57QcffIBPPvkEixYtQmJiIsqVK4f+/fsjL8/7nvapiRJOao8t+1fybknXbou3Hya7uKw7BWy1JYSC7pcVY8upG/hpT/EN0Y+JynhKv1sho2aJ6d+Ld59cD/PgkbiK9MpobQcA0/+0n2R1xyHh9h3ryQh3mfrbEZs1rzzZ+mPKb514Of2O8f/FaKXgCZTU9VIOk368mxApSSqVvtb7Zb/tm+XMO3evgaf9LqzVSuf3NiFPx+vJEmdTHRtMx5OsPnxd7hDMXLdzr5R8O89uWY/Gb67Fm38eQ9t3NuCp7/ejxdvrcSo5C9GvrUadqfF4/fejGPzZTkS/thrzN5zGiysPibkJquVwUmrKlCkm/1544QWMGDECw4cPx/Dhw6WI0WjevHmYMGECxo0bh6ZNm2LRokUIDg62Wlz9448/xoABA/Dyyy+jSZMmmDVrFtq0aYPPPvsMQHG2csGCBXjjjTcwZMgQtGjRAt9++y2uXbuGP/74Q9JtIdcopQvQPW9JN2JG6cy6GDrO2Yi3/jzq9Gd304NbXohJifWTlOZSWi7Scwpw+EqG3ToUUo7Us/GE9K0d3al0rub8DWXXzHLFieuO1XmTmr3WBAcuZ4i6vvrT4rF423njMOIGgwELNiij/pgYg2qo0RPf7XPr+hztalXs7ntu2WhR5U3u/98u/H7giijnGbWPKlfSFap02YhXfjlsbXYAwKJtd8toZDlQ0LrljPUORkee6Jkf97u8jOjXVmPDcfGu5QZ+vN34/7kFhfht/xVEv7YaP++9jNu5Oryw4qDZ+r/bnYR272zAd/9cRM8PN1sc8bz/gm021/tD4kXkFhQiM0/n5PFd/TQGB4+ivXr1Mvlbq9UiIiICvXv3xmOPPQZfX/FHswCAgoICBAcH45dffsHQoUON0x999FFkZGTgzz//NHtPrVq1MGXKFDz//PPGaW+99Rb++OMPHDp0COfPn0e9evVw4MABtGrVyjhPjx490KpVK3z88ceCYsvMzESFChVw+/ZthIaGOruJsrqVU4DU27nYum0revfsiSJokacrwvK9l9GmVhiaVa+AlMw8nEnJxtbTN9CzUQR8tBo0r14Bt3J1mJdwGsH+PggP9kNKZj6iK5dDm1phOJ2ShR4NIxAREojwYD/4+Wjx5p9HcStXhwXDW0FXpMfvB66iX9Mq8PPR4mrGHUSFBiI0yA9p2fkwAPD30UKr0SCvsAjhwf4AgF/3X8HnW5Q3bHo5fx/0uycKrWuFoVPdSigo0iNPV4Sb2QUoH+CLiuX8kacrQlZeIcKC/QAAwf6++Od8Gq7fvoMbWflIyczH1tM33BJv++hwtIuuiNTMfPRuHIlAPy0aVglBVl4hLqXnoH5kedy+U4ikmznM5AN4PrYB7m1RDf/bfBYd61WCr1aDhlWKR0irEOSHAF8tdp1Lw/NlTlokXM9GEdAV6aErMuDFvg1Rqbw/YufZPpm7YnTH2pjUuz4mfr8P5QJ8cSu3AEevKrfGw4j2NdGmdjg6RFeE3mCAAcU3QwYDMH/DacQfMW2xsfXlnjiVnIVK5f1xM7sA1cOCEOzvgzydHpfSc5Cn0yMiJAAVgvxQpDfg8q1cHLlyGxm5OhQZDCgs0uOPg9ccitHfV4uCwrsZsp6NIjCpV31cv52HZbuSEFE+ABO614G/jw/Cy/kh0M8HuflFuJGdh3IBvrhTUIRCvQHlA3xx8HIG2tUOhwHFBXINBtOLRiXq3TgSSTdz8GjnaFy7fQdfbPW8rqJkX5taYXhlQGNcv30HeTo9yvlpcPP0frTv3A1+fr64mVWA2fEnsHBUG9wpKEKFYD8UFRmw71Jxi8dgf19sPpmKp3vWx4HLt6A3GLDv4i0U6Q1oVr2CKEW1g/19kMtW0GYaVQnBxJ71MDv+BAa3rIYBzaLg66OFrkiPpJs5SM3KR9va4ahWIQhFBgOy8wpx32fePaCJq4a2qubwuYaotLGdo7FsV5LZ9C0v9UReYRF2nLmJ7/+5iGphQZh9f3MUGQy4U1BkNhhRh+iK2JOUbrYcuRyf2R/B/tLkV9xBaJ7E4aSUXK5du4bq1atj165d6NSpk3H6K6+8gq1btyIx0XyEMn9/f3zzzTcYOXKkcdr//vc/zJgxAykpKdi1axe6dOmCa9euoWrVqsZ5HnroIWg0GqxYscJiLPn5+cjPv/s0MDMzEzVr1sTNmzdVm5T6YtsFzE1gLS0iIiIiIiIiuf0xsSPuqabO/AJQnCepXLmy3aSUw2m33r1747fffkNYWJjZCocOHYpNmzY5HKzazJkzBzNmzDCbvn79egQHB8sQkevOXdcg2EeL3CLp6kEE+Rhwx8byK/gZcFtX/Lq/1oACvem8GhgQ5AsUGYB8CeMUi1ZjQHlfIFOn/FhJHBoYYFDU2GDkyYJ8ip8paTTFdYtyCu3vez4aA/y1MDsWl/M1wE8LZBS4d//10xigM9xdZ3lfA7ItbEc5X4NxO7N4TCWVC9AakK/nfqwmFQMM8NUAqXmm35u9a1siIlec2bcDFw/KHYXzcnOFDSrhcFJqy5YtKCgwLzKdl5eH7dula1JfuXJl+Pj4ICXFtN9oSkoKoqKiLL4nKirK5vwl/01JSTFpKZWSkmLSna+sqVOnYsqUKca/S1pK9evXT7UtpeIAvKvTYd36BDTr0BXREebbodf/d1Og0cBgMEBXZIC/r9ZsHq22+HVLIyQZDAZk5xehfIAPAOdHUfrun0uYuVq+0ffKWvdcF9SuFCy4yKulz6dkWmGRHj5aDWauPonvEy9bWYLzWtWsgP+NbIVK5fxxO0+H8GB/k3hKGk+Wja/lrI1e28z/+T71Mbxddfj7aOHno0WQf/H+W/Z7NBgMeGjxHhy8fFuuUFXt4Bu9kVeoR/LtPDSILG88vjR4U5r6E4seboWnfjwIANj1Sg9ULu8PjUaDOwVFaDFroyTrdMb6yV1Qp3I56PUG5BQUHz8tHTunrDyMVYfvdt/76fH2aFsrzO5x1tLxqEhvQE5+IQL9fGAwGODno4UBxQW1fbQaFOoNSMvOR7kAX+gNBmw+dRP3VA1B9fAgFOkNCA/2M3a9tnVOAIrPG4V68/OJNUM/341j15RVV2rBQy3QPjocFQJ9EfDfZ1akN8DXRyvJ/vtS3wZs3axQ6yd3gUYDhAb6oWI5f+N0nU6HhIQExMbGwt/f3+Q9Jb8Pa+ffIr3BeH1RpDfAYDCgydsbLK6/RlggJvaoi13n0zG8XXVsOXUTk/vUQ8tZpg+Nz8zqB0C646saDW5RFa8NaIhAPx+cu5GNplVDBR+XMnJ1aD9ns8QRyqtF9VActtC9/Y24Rngn/pRDy3r73sb4ae8VzBrcFCOX7sXI9jVwT7VQTP1dGSP0kvs0qxaKUylZ6Fy3EnRFeuw671jXuff/7x68+lvxfrPm2c4IDfJDZEgA9HoD8gv1OJmShZrhQahcPsDkfSXXHvfMsHwsjQwJQKrMdRJXTOiANrXCZI3BVZmZwkpiCE5KHT58t9jd8ePHkZx898K3qKgIa9euRfXq1R0I0TH+/v5o27YtNm7caKwppdfrsXHjRkyaNMniezp16oSNGzea1JRKSEgwdv+rU6cOoqKisHHjRmMSKjMzE4mJiZg4caLVWAICAhAQEGA23c/PD35+fs5toEJoNUB0RKig7fC3O4dlFZ19YymVQgJdX4hI9r/Z1+TC01UlH/3MIc1FT0o1qhKCP57pavw7MkB43KNiamHx9guixqMWD7WvhaphQYLmDQ0Sb1/wVP8b1QZ9m1ZBTn4hwoL9odcX10YquemKCivnljgGtKiOpBbm5y0lHceT3htk8reFU8/d1/xMT+md6kc6vV4/AIEWjg+lp5X+nupGVnB6XQBgY7PM3N+6Bo5dO+HS+sR0YU6c0w9YnPHu/c0wKqY2JvVpaJw26cf9+FsBIxlVCQ1ASqZ3Fjsv+1u1xt/f3+FjjJ+V/7dkx2t9AACjOtUBAHRvZP7g9o1BTRR1nJNL53qV8N34GGg15onAiiHCzvklIiqo8/P8+clOuHIrF3HNq+LlXw5DqwH+/K+209v3NcXYLnVM5o9+bbXJ3ydnDUCgn49DSam+TatgbNd6GNu1HgDg3Ow442tMSnkXS8fNsvuYLd0aVMbwDtEY3iHa4usBAUCHutbvGcteezzSsRamxTUx1nC6lJaLl1YewpwHmqNeRHnsPpeGkYv/MXnP56PaoGXNMFStEIjUrHzEzHb8oebL/RuhQ52KaB9d0eH3Kp3Qc43gpFSrVq2g0Wig0WjQu3dvs9eDgoLw6aefCo/QCVOmTMGjjz6Kdu3aoUOHDliwYAFycnIwbtw4AMCYMWNQvXp1zJkzBwAwefJk9OjRAx999BEGDRqE5cuX499//8WXX34JoPgE9Pzzz+Odd95BgwYNUKdOHbz55puoVq2aSTF1IkuWPtoOfZpUkWz5WpGH1v5ufAd0rV/Z6fdHKigR6G6VygtPNFUWMUHpqeKaF7dMDftv4AKx93VvVTfibpJow5TuMkbiPX5+spNbE1IAMCqmttm0+cNbKSIp9c/UPqgzNV7uMMiC0EBfZP43QlpUBe89n5f2w+Mxbv/9Kk2HOhXRoU7xjfCnI1sDuJuU6mznmrF0QmFQi6pYLfAY9N7/NXcmVPIwvRpFuLyML0e3EyGSu94Zarpv1qoUjJ+fulvLuuS3UqIkKVuiSmggzs+Ow75Lt3Dg0i3Mjj+JehHlsPHFnsjTFeFkchaGLtwJAFj/QnfUrhQMX61WcE8bTyY4KXXhwgUYDAbUrVsXe/bsQUTE3R3J398fkZGR8PHxsbEE1w0fPhw3btzA9OnTkZycjFatWmHt2rWoUqU4MXDp0iVotXeb2Xbu3Bk//vgj3njjDUybNg0NGjTAH3/8gWbNmhnneeWVV5CTk4MnnngCGRkZ6Nq1K9auXYvAQJ6wybr+91SRNCFV4vNRbTDxB9eHTAWAbg1cO/iXC1DvyA+uCvAVfmzr2TgSvx24KmE06jP93qZ4oE0NvPTLIbw6oLHc4XisMZ2i8cHa4qfVtSq6p7WZtyt7gWpJ9bAgXM24I8r6rD1Y8PMR1sVISm8MauK1N/hPdq8rdwh2je1SB59sLO7y2apmmLzBKED9yPKi768aDaCO4aNsmxbXGCmZ+cbRhYXQOvBZVirvSNtY8lRLHm3v8jJKymm4i49Wg00v9kDvj7Zi6aPtTBJSJbRaDdpHF7d6GtKqOiJDivf3QD8ftKoZhtXPdUVUaCB/B2UIvsusXbv4yZxer7czp7QmTZpktbveli1bzKYNGzYMw4YNs7o8jUaDmTNnYubMmWKFSF6gZyPnu8U4YmDzqvZnchO9J1xpuUGAwPoT3qRX40hUCPbD4jHiPtFyRViwOrta2FI+wBd7X4+Fj1YjuA4KSU+sJ6DFXY06WH190SNt8dT3+0RZlzPqRZaXbd1ye0UhyfahrapZfa1eqZaUNcLVOSiPmH4p1fpBLI/E1MZ3/1wUfblSmTXkHovTn+hez+FlCT3Mdazred2TnPVwTC3cyMpHwvEU+zN7iCVj2uHxb/8FIN650d3qRpQX3F27Sqh5I5d7qrlW7sBTCUpK/fXXXxg4cCD8/Pzw119/2Zx38ODBogRGpGR9m0rfSqrE6I7KuMgxMCklCJNS5upUVl6rnWkDm8gdgiQiQvjkTWnEuu6219VoQDPLg764S9Oq6hzoxVUHp/eV/eZqyZh2qBDsh3a1w63Oc2+Laki8kG5zHm9SXoLW30Uqu04a3Sna4fd8NbYdXvv1CP5+tqvJ9G4NIozd/mz5bnyMw+v0RCdmDkCQvw9+SLzoVUmp2KZV8P34GIfKYlhzf2vpalmT+wk6Ig8dOhTJycmIjIy0WWtJo9GgqMg7R+ci71J2BAcpvXFvE5eTUq8NdP0prl5d11qieWVAI4fmL9u9plbFYPw1qQtazUyw+97FY9phwn9PkEg67/1fczzYtobcYdhV9qKf1MnVmmnhwX44ML2foHnHdo7Gsl1JLq3PWZaeCHuDktp4cooV8KDMR6vB7PtZy6eErwRdXr3h4V3vxlWw53Xz/e2+llXx0spDdt+vhK7Gcjs3O86YyB7WtiZe//2ozBE5rnpYELrUr4Sf/73i8Hu7NnC+vm1p4Qo49pJ4BB0Z9Ho9IiMjjf9v7R8TUuQNnu7peLNmVwT4+mDTiz1cWkZ1gSPH2eKt3fcealfTofnLXuhue6WX4JsWd7bA82YjOtRSfHH1+cNboll1NvG2p0qo8luG+bixztLbgy13xyFp7HrNfOAf8l7ufGCpNI7UlPJ2pVtWqrGrfYCvFjtf6w0frbyxj+5kPuiHM0pqnb7c37GH0CQu9f0SiFBc08lHq0FbGZqhPx/b0P5MIqsbUR4TXUiGiZFO8taWUu66yBzZoZZb1kPq0LsRE5RCJE6LlTsEu1zt2qW2Q6833ZtWE+GBD7nf4JbWa2+54ske7n1oCQCv9nf/NaklXvSzd1jdUiUMZg1tZmNOefloNUh6bxC+HN0WGg1QqZw/2lbWY+6DzY2Jm6d61MOxGf3/e4f9s1Oz6tJ16xarNMTEnvWQOK0PnulVX5TlkXMEdd/75JNPBC/wueeeczoYIqEqBPnh2Iz+8PfRou409w4/LddTjVcHNMbnW87Jsm4A0HthVsqdXR1a/zca0qG3+qHljPVuW68a7H+zL9rMst/90VOUHWKY1M3VEb7U0Eg1vNTAAb5aDXRFKgia3G5Iq2qC6g5Jbfb/SXNul6JOlT3ju9TG++tOu329ZXnryJtCfP5IW+y/dAv7L97Cwwp+ALlgeCsAQL97onBhziDodDrEx8cjrmVV+Pn5OfVwvEKQOgaV8dbu50oi6Og5f/58QQvTaDRMSpHbeONNW2igLzLzCmVZtzd23xve3rGue2JQywncnSqW8666Ad54bHPFd+M7YPTSPXKHYZWfj6tJKceOvdGVgpGUluvSOh2ROK0PQgPvHreKu/F43/mCbBvXJRrP9W4ge1KqQ3RFWZJHUtgzrY9ikkHKiEJ5Fj3SFo2iQtAoKsRqi3il1BO9t4X4I36P7hiNnWfTAADVKjDxQ9YJOipfuHBB6jiIVCGmjrxD2e55PRaN31wry7pb/deSx5u4c0QlA2/i3CKKT8M8TrcGEXKHYJOvm7vvTexZD6/+esSldTqi7BNmKWvLvNy/ET5cd8rmPOue746zqdl45sf9ksUBiDeqoreoEhqIcAU8YPhwWAu5QxBF06qhiAwNhE6nkzsUAN7VbVcorUZYrdCYuvLeW5SQIsHZ/5672y/m8t+9X7ndIMk5LvVDMhgMXjHSBFGJDx9sKev6A/18MLlPA4ffJ8bvNKZuJZeXoSalT6Tu4IW9I2VRNYxJKXIvVy/EH+9aV6RI3EPKLu6Wan70bhyJQ2/1Q9J7g5D03iA0igrBoBZVkfTeIMniAIC/JiljdMx6EeLUVZFavYjygudtUlW6OjS1K6nj87Lni9Ft5Q7BhFJabCnJ+TmD3Ppw0/3ubltdK/WdNBqNcYCot+5rKtqaR8WIU+SclMOpK4elS5eiWbNmCAwMRGBgIJo1a4YlS5aIHRuR4tSqFCx3CKgRzsKq7rDoEfde8LEFj3s80KaG3CGQlwlwMUnTpnaYQ/NL+azwj2e62H0w4mrLMHtK34yvmtQVX41tb7Xb87ePdZAsDqWMjilWsV+p1aks/PppXOdo6QKR2Ol3BuKTka3RuZ60D/JqVpT/epSs69FQeAveQF/5u+wPcrHr3rJx1o+1rwxojCNv90O/e6JcWgd5NoevlKZPn47Jkyfjvvvuw8qVK7Fy5Urcd999eOGFFzB9+nQpYiQicjt3P/Xr2UjZXZDUbvsrvTB/eEvBoxzKNRriokfayLJeNQnyN7+AP/x2P7es+/GudfBkj+KWS5XLC+uK5ClPymObRKJVzTA829v2CEVSHzr73xOFA2/2xYU5cWhew3ZiyNfFel7qoOxtfKhdDYzsUBP1I0MAAN0aVLb7ngA/9Q4O7u+rxeCW1fDjhI6SrWPLSz0lWza5n7+vFoseaYN+Arr6SeWjYa71BKlVKdjmbzskkPVSyTaHK/19/vnnWLx4MUaOHGmcNnjwYLRo0QLPPvssZs6cKWqAREqw8OE2aFBFeNNzKTnT9LxdtDL6q6vFBw+6v+YEm75Lq2bFYIeeLNeWqVXkPdWU0fpCyR5oUwPxR66b1JIKddMFb0zdSujWoDLqRZR36Em4O0l1KClpgeXrYzthULVCEG5mF0gTxH8E1yaSqNWYnDePZSn91PFBmbIHlQR8d1KcD4e1rYGKAhPJShddpnVcowp6nLqt/ETeG4OayB2C2zj6LGJAs6oY0Kwqol9bLU1AbrDk0XboO28bLqUXD7TBHgDkCIePYDqdDu3atTOb3rZtWxQWyjMqGJGYPh/VxuyGdFCLqmhYJUSmiEx1cKLYevUwdvlzxLC24nfx+lCGRJcSuLsbpCVta4c7/B65yiUq/QZTCQL9fPDD4x3xVA/T4andUVund+NIBPr54KF2Nb1uCOmwYGE39AtGtJI2EAdIUatv5VOd8OUY8+tgMvdYlzpm0+QaXfTDYS0xdaD6kyIfPGB+LRGtjMtTu+pHivtwN1oBJTWsiVVQ4loIfzsPGyzpWKZAe4CvD8Z0ulvrSUirSKISDu+Bo0ePxueff242/csvv8SoUaNECYpITgObV8XWl3uhnIUuIkoh9yiAns7Vp7R/P9sVg5pXxe6pvY3THpQg0aV0c4e1xIBm6qwhINdoiGwx57yfn+wk+TrU0BVPI1F3rqlxjc2mWaqbUy+ivCytTS2R4nfcXmEtj5W8R1pqGSMk4S/2Ni182HO6RT/UvqbZNI0Hjd677eVeeD1OWPKwUvkAiaNx3oj28pQAcMZPEzpC68S5bXDLalj0SBvseLWXcdqQVtWN/z9dxMLm5Pkc7r4HFBc6X79+PTp2LO4vnZiYiEuXLmHMmDGYMmWKcb558+aJEyWRDOYOa4mJP+zHlL4N5Q7FjCOXH9UqeNfTfFcdeLOvy8toVr0CFo4yvQh2JNmw+rmuGPTJDpfjoGLOjD4pV0spoXWKyJySb1BcUSNcGa0BKlv4fJtaGSVNKSMzB8nUKsedlJrHrlYh0OKNrl7AviH2NrlaxNlZe6b1QYfZG0Vb3tl3B1qcrtBdwIyQ66BalYIxoXtdtI0Ox//9b5fNeWuGB2HfxVtihScqNTzAKNHJyaL8Go0GA5qZ/rYiQgJwctYABPhqJXvItu3lXvZnItVxuKXU0aNH0aZNG0RERODcuXM4d+4cKleujDZt2uDo0aM4cOAADhw4gIMHD0oQLpG0ala8281tYPOqODqjP56zM9KQLBy43u+rsibEchNcq0RC9uoKrXhCugKqnsiZ2+O45sUXWg3dXEsuQAGj8JBlv07sLMt6HR1dTa5WfqVJ0W3OGc503bXlr0ldRF2eEkSESJPMtbYPjOhg3tLHU0WK2MX39DsDrdZzc+bePzTQqXYJbhMuoLvw9PvucUMk5KhAPx/JElJ/TeqiiJHQSXwOH5E2b94sRRxEitCnsWkCp3yAMk/a/i4OMU6WrX6uq9whCBJTV9qhpj2NM4026lQuh31vxCI0yA8NXl8jflAWtBP5BtobvXt/M7z++1FJli12gkNNRsWYdkXRaIp/V12t1AwR0hrGHcS6MVoyph16N450qouL1LQubuNPE2Lw0frTWHM0WaSIillLjrat7d7uj74K/M4clTitj83rPme2cHzXus4H5CSxv4mKAh4iVqsQiGu380Reszr8+0Ys2r2zQe4wRNWiRpjcIZBEeGdLVMpkJbaKsmDW0GZyh+CRpB75bFBz17sQBMtQ68zZi3p3tzKyxpFR90qrVD4Afk4U/3RW22jvTXqI5eEO0tTxcGaACU9SdhSlxGl98NOEjlZHINQrpamUCOpWLofYplUUmZACnD++lagfGYLPJRiQwpW8ZCcRH7zI3TJrYs969mf6T6Cf1iwB/HL/RnYHVXAmLylHt09HdgkfkQKU40ikhHuJSb3qo3L5ADzQxnY906GtqrkpItcNUVGs5DiHm4Hk5eXh008/xebNm5Gamgq9Xm/y+v79+0ULjsjdlNB1SwhHunOwVY0wa5/vJvk6BjSLwuoj111aRp8m4nTHrB9ZHmdTswXN+0jH2li2K8nhdSjlida796sjiStVgWpvotFo8OvETnjg892iLve78R2cfm//e6Kw/cxNEaOxTYr9qGzCNDIkEJEh1m+UrXUzkkPNikG4nH7H6fd/pvAi2UorvF7Clbykp9aHs2VQ86rGWpTv3t8cAHCnoAhBAh5EOfOLl+Ns48g6S5fTcIUcrTaf7iU8ESmVx7sVj3xp71CslsFVfprQEa1rhckdBknI4auG8ePH44MPPkDt2rVx7733YsiQISb/iNxN7CFmPc1AlY5+5m6NoywX7BXTvSIUW33TwmhGZf00oSNWTepqs7m/0KGUn+heF1FOFMufMVg5tR78tK7dIL/lphFklFALyBO0rV0RSe8NwiIRW3+4UuurcZR7x2t3ZT96sod5l55vH+uAzvUcG9r7/tbV7c/kJmsmd3fp/dXCOFiIM5RS7H5iz/pyh2DX6XcGmg2OAkBQQgpQT6Hzlg48qBKaLPl+fIzJ3493rWPy98wh7n8o5e9CUr5CkJ8oMZT7r/zICIlaD7tbp3qVEOgFA1d4M4dbSv3999+Ij49Hly6eV+yR1GnJmHboOXeL3GEollqegshJaILGVWJ8F0IKp5aMpNK1fmVsOpnq0vr631MF+y9mCJ6/Ujl/zBveymq3Hjm4muzp1kA520LCDWgWhbPvDkR9N9UEs8bdt+ZFevvzWPNITG18sfW8ybTuTvyWA/18ENc8CvFHxK1T5Axna0NO7FkPg1tWQ5iAgstyUkrypyylRFU9TJwWN84KsVNQvHpYkMt1QoOd2MXluDSsECxOwgW4+7lWCb3bqs7fR4vXBjbGs70bwMdHg4JCvaC6U2JqWjXUpWu9x7vWwUcJp516b+OoEHz7X6vektIDbWrZLgswor33DDxAyubwUbB69eoICXHvUz8iW6IdHJnIm3SzUoSWTD3SsbbcIQjSq5FjN4e2blYcuY9xpCbHv2/EKiohBbhW24TUzddHi671ves4WOTCDu9qfaLSfFxsoVhWAze1in6oXQ3seb0PXh3QGE2qSt+C1lVKPbwpNVnmbmM7R9t8XYykWfsIz/ysu9S3Xn6iYRXze9G/n+sKXx8tKgT7oXyAr8WE1EfDWooaY1mWWrw54vFuzhWg3/dGLNY+391u1+qyWOKDlMLhK4aPPvoIr776Ki5evChFPEQkIjG7r3gye08yxWSpAKalLjOWfCjixVQ9B27wQgKFPd18oE0NRbbM88zLdRLqk5Gt5Q7BrVxNBohVy8VH5EOBq6PMCRFTpyI+eLClQzd1clPeEbfYqBh1POyRWrC/7euLecNdP6976oDMc+5vIfoyS1qSS8WRmq+WCO2yWZan1mEb3bE2TswcIHcY5AYOH8batWuHvLw81K1bFyEhIahYsaLJPyI5TOrles0ApYwUJqZyTnZbsCYyxDNPeve3tj06iZiGW2gqXd7CRaulugKVHbzosHVrKnR0mObVwwSvT+qLPWd0qV8J5WQYsZCUo2I5fyxUULFqqWtMuTry3beP3a3REuLCOWSgCKONluZKF6dAP8+7a384phaaV6+Ano0i5Q7FoglOtvgo0chCSxhPVCPcPeUD1KiWjdIKE7rVMZum1AQtOW/W0GZOJ+pIXRy+2hg5ciSuXr2K2bNno0qVKop8Kk7ep0a46092vxzdToRIPNvfz3VFh3c3yh2G6Fyt5+AIe0M7u8O9LaoKTlg68tkoMfnz9dgOIpyn3NPWql1tPtiRipwJ07J7X6/GkTiZnCXZ+lzMScFXWypiF346/ZqKM1JoiY8ecr5Fyf43+6Lp9HV251PTJe3s/0ZoU5p9b8Qir1Dvcv2gAA9KJE4d2Bhz1pyUOwxZLX1U3GvsAc2cS3qr6Tcu1LS4xnKHQOQyh5NSu3btwu7du9GypbR9cokc4aN1/SzD2lT2qalLg1JZ2lctXSS9e38zTPrxgEvrstaLp3n1CgCAhQ+3wTM/7rf6/nFdoh1aX797ONKjK2KbKLPFgyeQY1hwa6SOJTJUvBatrpxZNRoNhreriRX/XhYlFks1ZISy14WKxOOp3Yhc8WSPel6blKpTuRzGdKqN3o2VcX7TeGB7qqgKzj2Y/3hEK3EDIXKBw48hGjdujDt37kgRC5HT7m1RTe4QiEQ1qEzXl74itjqoXak4Adurse2C5D4OPlIUIzksNjGeila1csFXRcSbf4AjZUpJSUkpqRve+br4Oyw9Wp2rRXDF7kJO5IgwEUd7I+d0a1AZ47rUkez85utz91ZWyDoiJCxDIdfgQhF2EsFBfuat2Fc/1xVDWlWXKiQihzmclHrvvffw4osvYsuWLUhLS0NmZqbJPyI5uNrfWO4hg8m7vDO0md15yl5czXWiyPmomFpm017s2xD97xG3W42nKxfgi8RpfRBc5jiz6JG2WPFERx4/VCAsyLFhwQfU0EsUCRAgcXdhZ/NvJbms8HL+mNK3IRpVCcHcB9kqntTLV+QRIF3x/fgYs2mvDGgkQyTu1cXF0U872UmMly4sXi/Cfo8HH60Gb93X1KWYrIkTuY6eUB3r2u76/8a9TUz+blQlxGtqtpF6OHy0HjBgAHbv3o0+ffogMjIS4eHhCA8PR1hYGMLDw6WIEQCQnp6OUaNGITQ0FGFhYRg/fjyys7Ntzv/ss8+iUaNGCAoKQq1atfDcc8/h9u3bJvNpNBqzf8uXL5dsO0gZWtUMQ3ipJ2gPtnVfoWuSxqJHnCtkbKmguNTKPrUS8nSvbJzWhkefNeQe4/9b6k73VM96xvUp6YJdKmI9m60SGoiNL/Yw/j1/eEu0rhWOmLqVsPO13nhbootcEocjtdFWPtEBIX7iNWeqVippObhlNXSqJ8/TdHtKj273XJ8GWPdCd5frArWpHeZiVOSJXB2hTIjIkAAsHqOcEYi7WmhF072B7dbKnsDV2nLP9jEfyKhtbdP7zaT3BiHpvUGCW2ON62JeJF3NHG2FtmZyN5MWZkpVtscAeTaH21Vv3rzZ6mtHjhxxKRhbRo0ahevXryMhIQE6nQ7jxo3DE088gR9//NHi/NeuXcO1a9cwd+5cNG3aFBcvXsRTTz2Fa9eu4ZdffjGZ9+uvv8aAAXeHmwwLC5NsO0g6XepXws6zaXbnCwv2wy9PdUJOQRHeW3MS5fx9MLFnPTdESGJY/VxXzE84jQ0nUo3Tgv19MKBZVTwf2wALNpxxaHntakuXTLem7O2uM4X6p8Y1xmPL/jWbPrpTtNX3rHyqE/xKXYjYu1F/tLP1ZZVl6Smwp6laIQjLxrVHoJ8POpZ5eju2Sx28veq408tmzz3p/fB4DEYtSbQ5z6cjW6NVzTAkiNjDo1pYEL4fH4PQIF+0qBGG3efsn6fkEGihi4erBjWvinUtU7Dq0DXRly2FxlGhcodAIkmc1oddom1wV9daV7+DkADzxHh0JdeTms2rV8CRq7ftz+gBmlWrYPK3VoGlFixSSZgkDofTpD169DD516ZNG5w6dQovv/wyJk+eLEWMOHHiBNauXYslS5YgJiYGXbt2xaefforly5fj2jXLFzrNmjXDr7/+ivvuuw/16tVD79698e6772LVqlUoLCw0mTcsLAxRUVHGf4GBLOasRpb6TFvSProifH20qBDkhzn/1xxv3NtUkotxqdW2MVSup+rZKAL3VKuAJY+2x7Jx7Y3Tl43rIGNUjqtU3rQr0X1WaqINaVU8/d4W5k+LKjjYHQko3vfLWv1cV4vz1o8sj5oVhe9jlp4CK4HYNyU9G0WaJaRKTL/X+dZS/74e6/R7SRh73UhOzByA+1oW/+aahhnwQp/6qFTOH5N6mT+pd1TXBpXRokYYAMCgpPpWpbzUr6Hoy9RoNLjPwvFLDiXfrS0v9ff87lRKIOQ34OqRW4kJKSUVlh7Zwbx7v9jE6J7YrHooKpYzvd55s0x3NGfUrCh+t/uuLnZVlErLmmHG/69agfe4pExOp8m3bduGpUuX4tdff0W1atXwf//3f1i4cKGYsRnt3r0bYWFhaNfu7nCisbGx0Gq1SExMxP333y9oObdv30ZoaCh8fU03+5lnnsHjjz+OunXr4qmnnsK4ceNsnszy8/ORn59v/LuklpZOp4NOp3Nk0xSlJHa1boNe4DjYBr1etdtYWttaYbiYlmtzHndtZ4PIcjiTmiP5egx6g3GbutQNx6YpXZGUlovWNUKg0+mgL3K8Doze4P79oUudMJO/i4oKUVRkPt87g5sgrlkVdKpT0SzGe6IsPym0tS2WXmsYEYwzs/qhwZvrTaZ/8lALk/nnPtgcL/1iuTXsPdVCFPub0ul00LvpqeDIdtUw82/HW0uNaF8DoQFaxX6GnmTbS93Rfe42s+nhwX7w1eih0xUfDzQaYEKXmni6Z10A4h5LdWUejNmd38F1F1o6mAjwcPvqkuyDTa0cqxzlamwfPXAPXoyth54fbbf4etOqIQjQGiT7Har9GksoIdtnb+ABnU7ncvJWiZ9zg8qmD3oKCwtdjtPZ9/ug+HgnpQldaovyPax7rgvazynuqdO0agjK+WkcWu7I9jXw094rGNG+hvF9BoH3DI6ICvGTZb9zZJ0BvsKvNeQ+ZumLPON+zdsJ/Q4dSkolJydj2bJlWLp0KTIzM/HQQw8hPz8ff/zxB5o2la6eRnJyMiIjTYcS9fX1RcWKFZGcnCxoGTdv3sSsWbPwxBNPmEyfOXMmevfujeDgYKxfvx5PP/00srOz8dxzz1ld1pw5czBjxgyz6evXr0dwsPpbryQkJMgdglNSU7UQ0vgvOSUF8fHx0gcksStX7G+vNNtpfthoHpyJMxC3tVlczSLEXzZdZmFmqsVtij9d/N/ryRrAwThSUy0vU3p3P0d76998zvL0cQ01+Pq06faaL0voeky/1zP7tqF0R0g/AM83AxYcNZ2vSZgeI6vdcsNn6NwzlDVr1sC9LdUdjzMiNwnx8Unih0JmcguBku9oZL0i/HSu+Pczus4ds31YqnPh5ey7MdgTE6F3+Ld1MM3x4yBQ/FuRjutdhcQ7xliOpW25DLecC5R7jSVOdy4hn2Fujg9stYWKj49HRobteaxpXUmPPtUc/924w/VcoPTnfHjPDlx0vNGzy8r7GtxyfSjmOj7oAPhoAB+N49cb7bVA5D1Abe3dc+31ZGH3DI6Q+hhlyaSmRQLXW7zMnJwch+N0/zGrONbrydcRH3/VzesmseXm2m5AUULwXn/fffdh27ZtGDRoEBYsWIABAwbAx8cHixYtcjrI1157De+//77NeU6cOOH08ktkZmZi0KBBaNq0Kd5++22T1958803j/7du3Ro5OTn48MMPbSalpk6diilTppgsv2bNmujXrx9CQ9Vbj0Cn0yEhIQF9+/aFn5/6htH969YBHL11w+58NatVRVyc+kcU2vLbUeCG7TodcXFxoq938u71ZtOaNm2K35JOibqeEbEdEP/1PpNpn4zvg1AbhcljC/VYOWODQ+upJdP+sB8n8c3uS6hVMQhxcd2cWkaFc2n4+rTpZ1T2O199+yDWH0+1+Fpppb/XFjVCERfX0TzmSxlYcHSPybTn722L3o2kL9Zqab8TIm7gQLfWT3AmzudGiP87JcvydEWYuncjAODlEX3R/+ptJKXlYlSHmsZ5pD4XFhbpMfeIsONUbPsmiOtU26Hla4+l4OvThxx6T2RIAOLi+jn0Hkc4+/stTazzmaVYNr7QFbUc6K7sDKVfY4nxHQHCvqe5J7cD+XdsLmPppX9wKcexUb0fbFMds4c2VWTXPQA4k5KN9w7tMv49cqjr+3TJfuWI8JBgp687bCm7D0lxDSqWtZmHcDAtRdRlSnmMsjrvyIEOLbN8uXKIi7NctqEsuY5ZJbFWjfKM+zVvV9KjzB7BSak1a9bgueeew8SJE9GgQQOnAyvtxRdfxNixY23OU7duXURFRSE1NdVkemFhIdLT0xEVZT66VGlZWVkYMGAAQkJC8Pvvv9v9UcXExGDWrFnIz89HQIDlSqcBAQEWX/Pz81PkhYaj1LodGo2wJx5v3HePKrevLK2A7XXXdmq14tfk8vW5e3hqHx2OlU91tvseZzb3TZn2hxlDmuOZXg1QsZy/06OgtKplXiOq7La8c39zXLiZiBEdatnczs71KmHXuTSM7RyNZ3vXtzhvvSrmSXcfrY+if09+fn6KL+qp5M/P0/j5+WHxmHYo0htQMSQIPRtbrysi1blQoxXeZcaZ35evj3PHY6Xvh1LGV69KBfsziUSt11hCCdm2NrXDcfmW9aSUn5+foMRSncrlcOHm3dIBcx9qJShGudSKCDH5W679QKvVSLLumUPuwfQ/jxn/VvJ+rpVg9GF3b++PE2IEr7NDnYrYcyEdD8fUdjhOuY5ZWq1W0fsQCSP0OxSclNqxYweWLl2Ktm3bokmTJhg9ejRGjBjhdIAAEBERgYgI+0/YO3XqhIyMDOzbtw9t2xYP77pp0ybo9XrExFgf8SkzMxP9+/dHQEAA/vrrL0EFzA8ePIjw8HCrCSlSrid71MWGE/afelQPE7+4oRyU9CBQisKJbaPDMWtoM3y94wLmD28l+vJLVJNxf4gMde1zK1ty44VY80LFkSGBSJjSw+6yvh8fg6z8QlSw0RKtcvkA/P50Z1xKz8Xk5QcdDVcWSvqdkDL0dXGIck+kzNLr0hjSqhr+PKiO0QA91czBzex/BwIO3ptf6ono11aLFJX0ypca8S4ixPPuM8Z0ijZJSpFzYptEmowwbU3TqsJ753wzrgOOX7+N1jXdP+I0kRCC08QdO3bE4sWLcf36dTz55JNYvnw5qlWrBr1ej4SEBGRlZUkWZJMmTTBgwABMmDABe/bswc6dOzFp0iSMGDEC1aoVj6Zy9epVNG7cGHv2FHctyczMRL9+/ZCTk2OsgZWcnIzk5GQU/VcEdNWqVViyZAmOHj2Ks2fP4vPPP8fs2bPx7LPPSrYtJB1LI4uRe/S/x3aLRWcE+PpgdMfa2PRST9QIF96tooMX7weTY51vxarVamwmpEq0rhWOIa2qO70eIhLOXUnVB9rUcM+KnNQ4KsT+TAIxTy2/CsH2zzWBvo61ZJG6+6VY/P9rGd2q1Iho7sbfgLJVrWD/YemgFlURFiy8IFmQvw/a1q6o+Jbj5L0cbrtYrlw5PPbYY9ixYweOHDmCF198Ee+99x4iIyMxePBgKWIEAPzwww9o3Lgx+vTpg7i4OHTt2hVffvml8XWdTodTp04Zi2nt378fiYmJOHLkCOrXr4+qVasa/12+fBlAcXOyhQsXolOnTmjVqhW++OILzJs3D2+99ZZk20HS6n+P9zwBH9s5Wpb1dqhjnvRR0knO4FXP/MkepdYWIVKSCd3qyB0CeYDRHR2rf2bLnP9r7tD8FcvJUDHcCfGTu+GpHvXw/gMtZIuB50X1+2xka7lDkByv572LS0NtNGrUCB988AHmzJmDVatW4auvvhIrLjMVK1bEjz/+aPX16Ohok+Fje/bsaXc42QEDBmDAgAGixUjye3VAY6w7Jm7hQqWSosucEG8MaoLBn+00/t2ncaSNucnT8ZLBNV3qV5I7BFIwO5cxovFR0IMFUq9IEbuk1Y0ob/P1KqGm61JLnqV+ZHm8NrCx3GGQyMTc94VgYpE8jShV3nx8fDB06FD89ddfYiyOyGm+EhQuVKpK5eWpRxDsb1pE94G24nf7mH2/Y09IS3OkRpS/kwXGlUJIdzsi8i5NHKgzQiSmhiJ2s7Tni9Ht3LYuT8N0hvgejqnltnX5O9i1lUgNuFeTR6lZ0TOKmCubxsZfrvt4RCuXTu7T720qeF61Nw1WUrdJco6GtwcksujK5Rx+jyO1SdROzlo+nk7M2l/WaDTFhaBb1jAdMbGSSrrvKQJPO6rGr488EZNS5FHYnNX9StI67aOVMaKHXC3ISFoLH24jdwiCfDXWsaf3UTJ1wyX5KC0VnvTeILlDcKtHOtbGrKHN4OdTfL3w2cOeX5vFXaTubqrRAOdnx2HJo+2N13tLH22Hbg0qY9bQZtKu3IO4I3moeCLfLog5mmL9SNtdVyvzOpc8kEs1pYjU5vvxMXKH4LG0KkwIPh/bUO4QVOuhdjVw5GomejSMcMv6BrWoih8SK2HXuTS3rM9ZvRs7NtjCtLgmEkVCRJb4+mgxumNtUYtyk/S6NaiMucNamj187NOkCvo08Z5BbsTAB7jie6hdTdGW9XBMLbz11zGrry918OEXkRqwpRR5nDWTu2FMJ8sXm10bVHZzNJ6n7LVMyZPRd12oA1Va8+oV7M9kR+XywprxPyrTCIZi2vVabwDAvS2qunW9HzzYEmsmd3NrbQNHn8Kroe6CWkaMInlIfe/4z9Q+0q6ASCQLR7VBlVC2LLWmepjwz+aRGCZkxeYnYo1Se8tqHOXZdQMD/Yq3310PPUkZlH/FTuSgJlVDMXMIm3G7m73mxkLZG3FHiO/Gx6BT3UoY06k22tVWRrdCqVQLC8KFOXH4TCXd21zh6+PYHbpcLSPHdYmWZb3keaTuDuWu7qPsLkRlbZjSA6smdRU8P9v2iKdTPY76qlbT4jx/5MatL/fC4jHtMKyteK3PSPmYlCIij9Okaih+eqIjZg5phl8mdpY7HMl5S1P8tg4mGDvUqShRJLbVqhgsy3pJHXzdMEDB4JbVJF+HI9p4+MMBT9BUhFEbHTkV1Y8sj+Y1KmCYwBF8QwI52qwtUiewhYqupI7zX41wdQ6M9ET3enKHILkqoYHo27QKB/PxMkxKEZFDyp4i1D6CHamHGuuWEZWl0WgQJXE3JB6VyVE/PC5Py1If3nh6lK/Gtke/plXw16Qucodi07O9G2BE+5r4bnwHuUMhIjApReSxyvn7yB2CYlirtxSogppDROR52JqOlCa8nD86RMvTurS0vk1ZtNwZg5pHyR0CgOISDF+OaYcWNcLkDsWm8gG+eO+BFujWgHWLiJSAd2REKvb+A9aLiz/Tu74k64yuVA7Nqt9t5q+UJuO2PBxTy+J0XxELUxKVUMNvgsid+Jsgax4s032vH5NSTrm3hTKSUkREzuAdGXmsOf9nmrD5aUJHmSKRzvD2tXD47X5m078e2x4Te0jT71yr1ThUnJSILGOvFe/lfd2evW17Sah2ZVpneUuNRLGxezsRqZmv3AEQSWVkh1oY2CwKgX4+CPTz3K5soRaKf/ZqHCnpOtV20ejPFlGkQF+NbS93CKRw7hodT2qd61XGT3suyx0G2aOAU7ufg6OsUrGGIo2ATEQkByalyKOFBfvLHYLHU8Pz7za1OPITKU/Taq6PdkWebcA9ntElJ0amkTBJfQY2s1wDkmzjSGVEpGZsPkDkAcZ2jpY7BABA8+oV5A7BIksXa1MHNpYhEnJFoJ/wU9aT3etKGIltA5oJSyREhnhGKxiSDm80i7EmlZvI/Dk/H9sA/hyAhAhfjm4rdwhEbsUjP5EHePPeprKt279UU/ulY9vJFoej6kawqbvajIqpLXheXxm7gFQLC5Jt3UREcqlcPkDuEIgcNqmXawMD1QgX/5zfz0NayRIJxaQUkQfw0WrwTK/iwuZLxrgnMfRs7/roWr8y+jS5O1IOW36QlMoFeE6P824NKssdAnmwhztYHnG0tAnd6rghkmKhQea1D8nzuHqMDi9TcqFhleKHR6wzJZ4PH2whdwiK06CKaw8pO9atJFIkRN7Lc67wibzcy/0b4+X+7uuS9mK/RqIvs0t96U7s3RtGYNvpG5Itn5SlZniw3CHYNKRVdblDIA/WqZ79Y+nDDrQ8dJUnDzZCrps/vCW2nrqBER1qmkxfMqY95iWcwpMSjSbsjdgCR53WPt8NEWyJSB6MSSkiUgyNhEP/tKkVZpKUMrBIiUd7sG0NuUMgUjQeA0kp7m9dA/e3Nj9m16oUjAUjWssQkecKDeStnxo1juLAKOTZ2H2PiETVsoYyi53X53DJXsXXh6c3Uq4X+jaUOwQic+wl5/E0Gn7JajMtjgPzkOfjVTsRieqh9jXtzySDQc1Nh5nmhRnJqVejCLlDIBl1rseaYo5oUjVE7hCIiNzqj2e6YErfhhjb2X31/4jkwqQUEYlqRHv7BXatkTJPxCQUKcGI9jVxfGZ/VGJtCCLB3h58j9whEJGH8tUq83a4Vc0wPNenAfx9lRkfkZi4lxORqHy06kj+sJ4KyeG1gY0R7M+aHiQ9fztdWNWUqA8rMyobEZFY+jatYn8mG1ootGwFkZowKUVERCSR0herUaGBvLkmIiJSEFdbIj3cwfkeAkRUjEkpIiIiN+jVmHWkyH0MYGtQIiKpcWAVItfxV0REXqNd7XDj/wf6+cgYCXmTNZO74eme9TAtroncoRARWfVop2i5QyAiIi/EpBQReY3Siaiu9Tn6FUmnVc0wAMBD7WqiSdVQvDKgMUIC/eQNikhhIkJY8F9JBrWoih8nxMgdBhEReRnVJKXS09MxatQohIaGIiwsDOPHj0d2drbN9/Ts2RMajcbk31NPPWUyz6VLlzBo0CAEBwcjMjISL7/8MgoLC6XcFCJSAK1KCrKTOv00oSN+e7ozRsWw1gQRAIztHG027a9JXdwfCNlUt3J5uUMgIiIvo5qk1KhRo3Ds2DEkJCTg77//xrZt2/DEE0/Yfd+ECRNw/fp1478PPvjA+FpRUREGDRqEgoIC7Nq1C9988w2WLVuG6dOnS7kpRGSFmkaDInl0rFtR7hAECfL3QZta4dynSTblAmyP8lgjPMhNkRTrYqF1atUK9mMI4HDoRCSxxlEhcodA5NVUcaY/ceIE1q5diyVLliAmJgZdu3bFp59+iuXLl+PatWs23xscHIyoqCjjv9DQUONr69evx/Hjx/H999+jVatWGDhwIGbNmoWFCxeioKBA6s0iIjcb360OAKBP40iZIyFntS1VF4yIrPt8VFubr/vJXJy3cnlhXfdqVgyWOBIi8nbPxzaUOwQir2b7MZpC7N69G2FhYWjXrp1xWmxsLLRaLRITE3H//fdbfe8PP/yA77//HlFRUbjvvvvw5ptvIjg42Ljc5s2bo0qVKsb5+/fvj4kTJ+LYsWNo3bq1xWXm5+cjPz/f+HdmZiYAQKfTQafTubStciqJXc3bQOpm0Osl3f+61g3Htpe6IzIkgPu5SumL9ILm4/dLzlLSudCVGBpE2G6F5O7tKypTGqFnw8rCYjAYFPFduEpJ+5UtukLn41P6tnkiR/crfkeWBbgw9o2nfqZqOWaRsgndf1SRlEpOTkZkpGnLBl9fX1SsWBHJyclW3/fwww+jdu3aqFatGg4fPoxXX30Vp06dwm+//WZcbumEFADj37aWO2fOHMyYMcNs+vr1640JLzVLSEiQOwRSPecOLTdu3EB8fLzIsZAnOXtJCyGNfLkfkaukPxfaP066sh/nFtpeh7t/I0fSNQDu3vldvnwZ8fEXYe9zyM7O9qjfs9KvsTLyAWfO4aPrF3nU96Q2xfuVtMcUT3Yyw/T45AhP/0yVfswiZcvNzRU0n6xJqddeew3vv/++zXlOnDjh9PJL15xq3rw5qlatij59+uDcuXOoV6+e08udOnUqpkyZYvw7MzMTNWvWRL9+/Uy6B6qNTqdDQkIC+vbtCz8/jhJFzpu8e71T74uMjEBcnO0uJ+TdTiacQcLVC3bni4uLc0M05IncdS4Ucpx0ZT++fUeHqXs3S7JsZwScSMWSUweNfzeuH424uMZ2P4fy5csjLk79BdHVco2VnJmHt/Zvc/h9Hdu3Qb+mVezPSKIqvV9ht/XfewmeGy0LPZuGz0/sc+q9nvqZquWYRcpW0qPMHlmTUi+++CLGjh1rc566desiKioKqampJtMLCwuRnp6OqKgoweuLiSke5vbs2bOoV68eoqKisGfPHpN5UlJSAMDmcgMCAhAQYF4Lwc/PzyN+tJ6yHaQ+Go2W+x7ZpBVYB4f7EblK6nPh7PubY9rvR6y+Xj+yvEvr97PTYt7dvxEfX9NLzvKBwj5fjUbjUb9npV9j+fkWOfU+Hx9fRW+XpxP62fM7sszX17lWUr0aRXj8Z6r0YxYpm9B9R9akVEREBCIiIuzO16lTJ2RkZGDfvn1o27a4FcWmTZug1+uNiSYhDh48CACoWrWqcbnvvvsuUlNTjd0DExISEBoaiqZNmzq4NURERETC+Gptj8zI0aCIiIjIG6hi9L0mTZpgwIABmDBhAvbs2YOdO3di0qRJGDFiBKpVqwYAuHr1Kho3bmxs+XTu3DnMmjUL+/btQ1JSEv766y+MGTMG3bt3R4sWLQAA/fr1Q9OmTTF69GgcOnQI69atwxtvvIFnnnnGYksoIpJW94b2k9RERGRfkL8LlXsVRGM7d0dE5DJfrSpuiYk8lmp+gT/88AMaN26MPn36IC4uDl27dsWXX35pfF2n0+HUqVPGYlr+/v7YsGED+vXrh8aNG+PFF1/EAw88gFWrVhnf4+Pjg7///hs+Pj7o1KkTHnnkEYwZMwYzZ850+/YREfBop9pyh0BEpAgGF9/v76uaSzwiIll1qFNR7hCIvJoqRt8DgIoVK+LHH3+0+np0dDQMhruXcDVr1sTWrVvtLrd27doeP2oCkVr4CqwXRESkel7WAqj0NRoA9GnCothEpAw+drpTE5G0eAdIRERE5Gb3tagm+TpeGdBI8nU4q02tcABAhSAW0FWS0CDVPK8mkl2z6hXkDoHIIzApRUREqqHxtuYl5LHcUfOpWoUgydchlMZKcSjWjFKWYH8mpYiEeqZXfblDIPIITEoREREReZH+96in6xwT0UTCtKjBVjvuFujnGQNKEMmNSSkiIlINg8vln4moUVSo3CEQkcjmPdRS7hCIiJzCpBQRERERSapsoXMiElf9yBC5Q/AqjaP4eROJhUkpIiIiIhm0rR0udwhEorinGlvfERGRc5iUIiIiIvJAkSEBFqfXiyjn5kjI09WsGCx3CATgnaHNrL42fzi799nio2X9OiK5MClFREREJIPJfRpIuvxO9SpZnH5fi2qSrldM7z/YQu4QvE6X+pb3G1K+Ee1rWn0tiEW5bfrusQ5yh0DktZiUIiIiIpJB94YRVl97qJ31m0uhNBoN7mtpnoDSytAiQKNxbp2taoaJGwjZNayt6/seyYOV25wXFuwvdwhEXotJKSIiIiKF6WEjYaVGpQudf/CAsNZP7GZIRO7SiIXLiWTDpBQRERGRh2qmwALUD9noYkREJAfWlCKSD5NSRERERB5qXJc6codg09jO0VZf639PlPsCISIiIlkwKUVERETkofx9lX2p92xv68XeJ8dKWwieLDM4WJkotkmkRJEQKdcDbWrIHQKRx1D2lQoREREReSxbXWYCfDlamBq0rhUudwgkCLuniemxrspuhUqkJkxKEREREZGk/Hx4yUkkNV/WRXLJ4jHtBM/LGlRE4uEVAhEREZGXiAwJkGW93RpURse6FfGYwmtcEamZRqPBoen95A5DtRpWKS93CEReyVfuAIiIiIjIs/n6aLH8iU5yh0EChAb6OTR/x7qVJIqEnFEh2LHvj4hIbmwpRUREqlEvgk8xyfOFBIr7zPCjYS1FXR55Nq3GsW5JbWuzphR5lzAm/ohExaQUERGpxtBW1VE9LEjuMIhUpU2ppEGvRhwpjYjIFUF+HISBSExMShERkWpotRo82aOu3GEQqda0uCZyh0Ae5O9nu8odAgnUgPWS7OKADETy4C+PiIiISCbvP9DcbJrYYzqV87/7VD84gE/4STzNqleQOwQSiN3f7avGlthEsmBSioiIPEKLGrw5IvUJ9pd+zJnI0EBMv7cpZt/fnC0ByD6OdE9e7LOHW8sdApHX4ZUJEYlu4cNt5A6BvNDUgeyWRGTNY13r4OGYWnKHQUSkaO1qV5Q7BCKvw6QUEYmOo5KQHAL9eEojz2CQOwDyamwoRURE7sQreCIiIiJShM0v9UTFcv7oWr+y3KEQkRcSMrLe073quyESIu/BpBQRiY5PWUlKkSEBFqdrNNzziNSuTuVy2DOtD74b30HuUIjIC1UI9sMHD7SwOc/ojrXdFA2Rd1BNUio9PR2jRo1CaGgowsLCMH78eGRnZ1udPykpCRqNxuK/lStXGuez9Pry5cvdsUlEROSEfk2j5A6BSDRNqobKHYLi+PpomWQmItk81L4mjs7oL3cYRF5DNUmpUaNG4dixY0hISMDff/+Nbdu24YknnrA6f82aNXH9+nWTfzNmzED58uUxcOBAk3m//vprk/mGDh0q8dYQEZGztFrerJLnqB9pPkz7M+waQkQkq/IBvvjfKA7cQ+QO0o9DLIITJ05g7dq12Lt3L9q1awcA+PTTTxEXF4e5c+eiWrVqZu/x8fFBVJTp0/Tff/8dDz30EMqXN70ADAsLM5uXiIiISA7sGkJEJL/uDSPkDoHIK6iipdTu3bsRFhZmTEgBQGxsLLRaLRITEwUtY9++fTh48CDGjx9v9tozzzyDypUro0OHDvjqq69gMHDcGyJ3qxtRTu4QSEWqWKkrReQJ2HONiFxRJZTnSDGUD1BF+w0i1VPFLy05ORmRkZEm03x9fVGxYkUkJycLWsbSpUvRpEkTdO7c2WT6zJkz0bt3bwQHB2P9+vV4+umnkZ2djeeee87qsvLz85Gfn2/8OzMzEwCg0+mg0+mEbpbilMSu5m0gZSgsKnT4PS/G1ue+R4JFhPgjJSvfZFph4d39jvsSOUsJ50KdTgedxnsekI3vUhtLd17EiPY1PPa3q4T9Sih9UZHgedWwPZ7M2n71RlxjPLv8kMV5yXXe8Fmq6ZhFyiV0/5E1KfXaa6/h/ffftznPiRMnXF7PnTt38OOPP+LNN980e630tNatWyMnJwcffvihzaTUnDlzMGPGDLPp69evR3BwsMvxyi0hIUHuEEjlbhcAjh5e9u/fj8Ik77kJI9c09NfgKO4O29ynmh67du5EyX4XHx8vU2TkKdx7LjQ9Xq5btx4B9kcl9xjNDMBLzYHqPkmIj0+SOxxJqeEa60SGBoCwHZDHWmUou18dSjP/DvldOSfIxwd3ikybr3rTZ6mGYxYpV25urqD5ZE1Kvfjiixg7dqzNeerWrYuoqCikpqaaTC8sLER6erqgWlC//PILcnNzMWbMGLvzxsTEYNasWcjPz0dAgOWmr1OnTsWUKVOMf2dmZqJmzZro168fQkPVO4qOTqdDQkIC+vbtCz8/P7nDIZWbvm+9Q/MP6tUZzatXkCga8jR9Cgrw26wtxr9jWjZBm1phmHe0uEt3XFycPIGR6slxLpy82/R42b9/PwT7q6IxOwmkpmuskDM3sejEfkHz8lgrL2v7lc+xFHx1+m5LqQ/+rxniWpvX4CX7mnfKRe95O0ymecN+r6ZjFilXSY8ye2S94omIiEBEhP0Ccp06dUJGRgb27duHtm3bAgA2bdoEvV6PmJgYu+9funQpBg8eLGhdBw8eRHh4uNWEFAAEBARYfN3Pz88jfrSesh2kLm2iK8sdAqmYVquFr+/dUxqPYeQqOc+FxetmUsoTqeEay8dX+L6n9G3xFmX3K19f01ZSD3Xg4AnOqhtZAXtfj8Wl9Bw88PluAN6136vhmEXKJXTfUcUVT5MmTTBgwABMmDABixYtgk6nw6RJkzBixAjjyHtXr15Fnz598O2336JDhw7G9549exbbtm2z2Mxy1apVSElJQceOHREYGIiEhATMnj0bL730ktu2jYiAyX0ayB0CEZFsdr7WG13e2yR3GETkMThagpgiQgIQERKAd+9vhsrlWUSeSGyqSEoBwA8//IBJkyahT58+0Gq1eOCBB/DJJ58YX9fpdDh16pRZv8WvvvoKNWrUQL9+/cyW6efnh4ULF+KFF16AwWBA/fr1MW/ePEyYMEHy7SGiu17o21DuEEiFOkfqsStVFYPIEtlUPSxI7hCIiMiOUTFscUYkBdUkpSpWrIgff/zR6uvR0dEwGMyLJM+ePRuzZ8+2+J4BAwZgwIABosVIRI57tBNP8OSch+reTUp1rFsJhXoWyicichXb2BARkTupJilFRJ7pwbY15Q6BVEqjAXa/2gM3cgrRrHoFHLycIXdIRKII8PWiofdIcTTMShERkRsxKUVEsqpVMVjuEEjFKpcPQNXw8gD4dJ/UzVerMbb289FybyYiIiLvwGIcRCSbbS/3QoVgjuhBRBTkz9ZRRERE5H2YlCIiSSx6pK3N15/oXhe1KrGVFBERAHzzWAdEVwrG0kfbyR0KERERkduw+x4RSWJAsyibr49oz1pSREQl2tQKx5aXe8kdBhEREZFbsaUUERERERERERG5HZNSREREREQEANBw2AgiInIjJqWIiIiIiIiIiMjtmJQiIiIiIiLyEM2qh8odAhGRYExKEREREREReYga4cF4OKaW3GEQEQnC0feIyK1a1qiAzLxC1KoYLHcoRERERB5p+r1NkZ1XiF6NI+QOhYjIJialiMitfn+6CwwAfLQspEpERKRk/ZpWwfrjKXKHQU4I9PPBJyNbyx0GEZFdTEoRkVtpmYwiIiJSLE2p03SAn498gRARkVdgTSkiIvIINcKD5A6BiIiIiIgcwJZSRETkESqVD8Cayd0Q7M8n+0REREREasCWUkQkmWFta5j8Pa5LtDyBkNdoUjUUtSuVkzsMIiIiIiISgEkpIpLMrKHN8MUjd4ts1uaIe0RERIrGyo9EROROTEoRkWQC/XzQuxGHIiYiIiIiIiJzTEoRkeS6VdGjRngQHmxXU+5QiIiISKD/a13dbFqPhnzYRERE4mFSiogk92BdPTa90BXlAzi2AhERkaKV6r/Xq3Ek/H1NbxcaVinv5oCIiMiTMSlFRG6h0bBKBRERkdqUTkJ9Pa49woL9ZYyGiIg8DZstEBERERGRRT6lHir1ahSJAB8+0yYiIvEwKUVERERERBa9/2ALjF66B5P7NAAAdK5fGUvGtEO9SHbjIyIi1zEpRUREREREFjWOCsWeaX1MuuHHNq0iY0RERORJ2P6WiIiIiIisYl1IIiKSCpNSREREREQEANCACSgiInIfJqWIiIiIiIiIiMjtVJOUevfdd9G5c2cEBwcjLCxM0HsMBgOmT5+OqlWrIigoCLGxsThz5ozJPOnp6Rg1ahRCQ0MRFhaG8ePHIzs7W4ItICIiIiIiIiKiEqpJShUUFGDYsGGYOHGi4Pd88MEH+OSTT7Bo0SIkJiaiXLly6N+/P/Ly8ozzjBo1CseOHUNCQgL+/vtvbNu2DU888YQUm0BERERERERERP9Rzeh7M2bMAAAsW7ZM0PwGgwELFizAG2+8gSFDhgAAvv32W1SpUgV//PEHRowYgRMnTmDt2rXYu3cv2rVrBwD49NNPERcXh7lz56JatWqSbAsRERERERERkbdTTVLKURcuXEBycjJiY2ON0ypUqICYmBjs3r0bI0aMwO7duxEWFmZMSAFAbGwstFotEhMTcf/991tcdn5+PvLz841/Z2ZmAgB0Oh10Op1EWyS9ktjVvA2kPNyvSArcr0gq3LdICmrar4qK/p+99w6TtKzS/+/qit1dqbs6zTCBIAICigLiLCq6IqxidldXDKCuEcyisrriioq6rmHNu2YFA666uwYUFVzlSzAwiiIYQBiY6Vixc4X390f/Pk+f6gEWZZhhhnNf11wzU11d9b7Pc54T7hPeVvj33nC992bsTXLl2LvgsuXYFbiz8rPPklLj4+OSpNHR0a7XR0dHw8/Gx8c1MjLS9fNEIqHBwcHwntvCeeedFyq3LL73ve+pr6/vrl76HsfFF1+8py/BsQ/C5cpxd8DlynF3wWXLcXdgb5CrZkfKJeMaykjf/va39/TlOO4E9ga5cuydcNly3BXMz8/fqfftUVLqDW94g971rnfd4Xt++9vf6tBDD91NV3TncPbZZ+vVr351+H+9XtfGjRt10kknKZ/P78Eru2toNpu6+OKL9ehHP1rJZHJPX45jH4HLlePugMuV4+6Cy5bj7sDeJlenPKajeE9MsVhsT1+K4w6wt8mVY++By5ZjV4COsv8Le5SUes1rXqPTTz/9Dt9z4IEH/kWfPTY2JkmamJjQunXrwusTExM66qijwnsmJye7fq/VaqlcLoffvy2k02ml0+mdXk8mk/vEod1X7sNxz4LLlePugMuV4+6Cy5bj7sDeIld7wSU6DPYWuXLsfXDZctwV3FnZ2aOk1PDwsIaHh++Wzz7ggAM0NjamH/zgB4GEqtfruvLKK8MT/LZs2aJqtaqf//znOvrooyVJP/zhD9XpdHTcccfdLdflcDgcDofD4XA4HA6Hw+GQevb0BdxZ3Hzzzdq6datuvvlmtdttbd26VVu3btXs7Gx4z6GHHqqvf/3rkqRYLKZXvvKVetvb3qb//u//1jXXXKPnPOc5Wr9+vZ70pCdJkg477DD9zd/8jV7wghfoqquu0mWXXaYzzzxTf//3f+9P3nM4HA6Hw+FwOBwOh8PhuBux1ww6f/Ob36zPfvaz4f8PfOADJUmXXHKJHvGIR0iSrr/+etVqtfCe173udZqbm9MLX/hCVatVPfShD9VFF12kTCYT3nP++efrzDPP1KMe9Sj19PToqU99qv7t3/5t99yUw+FwOBwOh8PhcDgcDse9FHsNKfWZz3xGn/nMZ+7wPVEUdf0/FovprW99q9761rfe7u8MDg7qggsu2BWX6HA4HA6Hw+FwOBwOh8PhuJPYa9r3HA6Hw+FwOBwOh8PhcDgc+w6clHI4HA6Hw+FwOBwOh8PhcOx2OCnlcDgcDofD4XA4HA6Hw+HY7XBSyuFwOBwOh8PhcDgcDofDsdvhpJTD4XA4HA6Hw+FwOBwOh2O3w0kph8PhcDgcDofD4XA4HA7HbkdiT1/AvoAoiiRJ9Xp9D1/JXUOz2dT8/Lzq9bqSyeSevhzHPgKXK8fdAZcrx90Fly3H3QGXK8fdAZcrx90Fly3HrgD8CHzJ7cFJqV2ARqMhSdq4ceMevhKHw+FwOBwOh8PhcDgcjnsGGo2GCoXC7f48Fv1ftJXj/0Sn09H27duVy+UUi8X29OX8xajX69q4caO2bdumfD6/py/HsY/A5cpxd8DlynF3wWXLcXfA5cpxd8DlynF3wWXLsSsQRZEajYbWr1+vnp7bnxzllVK7AD09PdqwYcOevoxdhnw+78rHscvhcuW4O+By5bi74LLluDvgcuW4O+By5bi74LLluKu4owop4IPOHQ6Hw+FwOBwOh8PhcDgcux1OSjkcDofD4XA4HA6Hw+FwOHY7nJRyBKTTaZ1zzjlKp9N7+lIc+xBcrhx3B1yuHHcXXLYcdwdcrhx3B1yuHHcXXLYcuxM+6NzhcDgcDofD4XA4HA6Hw7Hb4ZVSDofD4XA4HA6Hw+FwOByO3Q4npRwOh8PhcDgcDofD4XA4HLsdTko5HA6Hw+FwOBwOh8PhcDh2O5yUcjgcDofD4XA4HA6Hw+Fw7HY4KeWQJH34wx/W/vvvr0wmo+OOO05XXXXVnr4kxx7Ceeedp2OPPVa5XE4jIyN60pOepOuvv77rPYuLizrjjDNUKpWUzWb11Kc+VRMTE13vufnmm3XKKaeor69PIyMjOuuss9Rqtbrec+mll+pBD3qQ0um07nOf++gzn/nMTtfjsrlv4p3vfKdisZhe+cpXhtdcrhx/KW699VY961nPUqlUUm9vr4488kj97Gc/Cz+PokhvfvObtW7dOvX29urEE0/U73//+67PKJfLeuYzn6l8Pq9isajnP//5mp2d7XrPr371Kz3sYQ9TJpPRxo0b9e53v3una7nwwgt16KGHKpPJ6Mgjj9S3v/3tu+emHXcr2u22/umf/kkHHHCAent7ddBBB+ncc8+VfT6Qy5XjzuB///d/9fjHP17r169XLBbTN77xja6f35Pk6M5ci+OegTuSq2azqde//vU68sgj1d/fr/Xr1+s5z3mOtm/f3vUZLleOewwix70eX/rSl6JUKhV96lOfin7zm99EL3jBC6JisRhNTEzs6Utz7AGcfPLJ0ac//eno17/+dbR169bosY99bLRp06ZodnY2vOfFL35xtHHjxugHP/hB9LOf/Sx6yEMeEv3VX/1V+Hmr1YqOOOKI6MQTT4yuvvrq6Nvf/nY0NDQUnX322eE9N9xwQ9TX1xe9+tWvjq699trogx/8YBSPx6OLLroovMdlc9/EVVddFe2///7R/e9//+gVr3hFeN3lyvGXoFwuR5s3b45OP/306Morr4xuuOGG6Lvf/W70hz/8Ibznne98Z1QoFKJvfOMb0S9/+cvoCU94QnTAAQdECwsL4T1/8zd/Ez3gAQ+IrrjiiujHP/5xdJ/73Cd6xjOeEX5eq9Wi0dHR6JnPfGb061//OvriF78Y9fb2Rh//+MfDey677LIoHo9H7373u6Nrr702etOb3hQlk8nommuu2T2L4dhlePvb3x6VSqXom9/8ZnTjjTdGF154YZTNZqMPfOAD4T0uV447g29/+9vRG9/4xuhrX/taJCn6+te/3vXze5Ic3ZlrcdwzcEdyVa1WoxNPPDH68pe/HF133XXR5ZdfHj34wQ+Ojj766K7PcLly3FPgpJQjevCDHxydccYZ4f/tdjtav359dN555+3Bq3LcUzA5ORlJin70ox9FUbRi6JLJZHThhReG9/z2t7+NJEWXX355FEUrhrKnpycaHx8P7/noRz8a5fP5aGlpKYqiKHrd614XHX744V3f9fSnPz06+eSTw/9dNvc9NBqN6OCDD44uvvji6IQTTgiklMuV4y/F61//+uihD33o7f680+lEY2Nj0b/8y7+E16rVapROp6MvfvGLURRF0bXXXhtJin7605+G93znO9+JYrFYdOutt0ZRFEUf+chHooGBgSBrfPchhxwS/v+0pz0tOuWUU7q+/7jjjote9KIX3bWbdOx2nHLKKdHznve8rtee8pSnRM985jOjKHK5cvxlWEse3JPk6M5ci+OeidsiO9fiqquuiiRFN910UxRFLleOexa8fe9ejuXlZf385z/XiSeeGF7r6enRiSeeqMsvv3wPXpnjnoJarSZJGhwclCT9/Oc/V7PZ7JKZQw89VJs2bQoyc/nll+vII4/U6OhoeM/JJ5+ser2u3/zmN+E99jN4D5/hsrlv4owzztApp5yy0967XDn+Uvz3f/+3jjnmGP3d3/2dRkZG9MAHPlD/8R//EX5+4403anx8vGvPC4WCjjvuuC7ZKhaLOuaYY8J7TjzxRPX09OjKK68M73n4wx+uVCoV3nPyySfr+uuvV6VSCe+5I/lz7D34q7/6K/3gBz/Q7373O0nSL3/5S/3kJz/RYx7zGEkuV45dg3uSHN2Za3HsvajVaorFYioWi5Jcrhz3LDgpdS/H9PS02u12V5AnSaOjoxofH99DV+W4p6DT6eiVr3yljj/+eB1xxBGSpPHxcaVSqWDUgJWZ8fHx25QpfnZH76nX61pYWHDZ3AfxpS99Sb/4xS903nnn7fQzlyvHX4obbrhBH/3oR3XwwQfru9/9rl7ykpfo5S9/uT772c9KWpWNO9rz8fFxjYyMdP08kUhocHBwl8ify9behze84Q36+7//ex166KFKJpN64AMfqFe+8pV65jOfKcnlyrFrcE+SoztzLY69E4uLi3r961+vZzzjGcrn85Jcrhz3LCT29AU4HI57Ls444wz9+te/1k9+8pM9fSmOvRzbtm3TK17xCl188cXKZDJ7+nIc+xA6nY6OOeYYveMd75AkPfCBD9Svf/1rfexjH9Npp522h6/OsbfiK1/5is4//3xdcMEFOvzww7V161a98pWv1Pr1612uHA7HXoNms6mnPe1piqJIH/3oR/f05TgctwmvlLqXY2hoSPF4fKcnXE1MTGhsbGwPXZXjnoAzzzxT3/zmN3XJJZdow4YN4fWxsTEtLy+rWq12vd/KzNjY2G3KFD+7o/fk83n19va6bO5j+PnPf67JyUk96EEPUiKRUCKR0I9+9CP927/9mxKJhEZHR12uHH8R1q1bp/vd735drx122GG6+eabJa3Kxh3t+djYmCYnJ7t+3mq1VC6Xd4n8uWztfTjrrLNCtdSRRx6pZz/72XrVq14VKj1drhy7AvckOboz1+LYuwAhddNNN+niiy8OVVKSy5XjngUnpe7lSKVSOvroo/WDH/wgvNbpdPSDH/xAW7Zs2YNX5thTiKJIZ555pr7+9a/rhz/8oQ444ICunx999NFKJpNdMnP99dfr5ptvDjKzZcsWXXPNNV3GDmNI8Lhly5auz+A9fIbL5r6FRz3qUbrmmmu0devW8OeYY47RM5/5zPBvlyvHX4Ljjz9e119/fddrv/vd77R582ZJ0gEHHKCxsbGuPa/X67ryyiu7ZKtarernP/95eM8Pf/hDdTodHXfcceE9//u//6tmsxnec/HFF+uQQw7RwMBAeM8dyZ9j78H8/Lx6errd5Hg8rk6nI8nlyrFrcE+SoztzLY69BxBSv//97/X9739fpVKp6+cuV457FPb0pHXHnseXvvSlKJ1OR5/5zGeia6+9NnrhC18YFYvFridcOe49eMlLXhIVCoXo0ksvjXbs2BH+zM/Ph/e8+MUvjjZt2hT98Ic/jH72s59FW7ZsibZs2RJ+3mq1oiOOOCI66aSToq1bt0YXXXRRNDw8HJ199tnhPTfccEPU19cXnXXWWdFvf/vb6MMf/nAUj8ejiy66KLzHZXPfhn36XhS5XDn+Mlx11VVRIpGI3v72t0e///3vo/PPPz/q6+uLvvCFL4T3vPOd74yKxWL0X//1X9GvfvWr6IlPfOJtPnL9gQ98YHTllVdGP/nJT6KDDz6469HY1Wo1Gh0djZ797GdHv/71r6MvfelLUV9f306Pxk4kEtF73vOe6Le//W10zjnn7PRobMfegdNOOy3ab7/9om9+85vRjTfeGH3ta1+LhoaGote97nXhPS5XjjuDRqMRXX311dHVV18dSYre+973RldffXV4Cto9SY7uzLU47hm4I7laXl6OnvCEJ0QbNmyItm7d2uXP2yfpuVw57ilwUsoRRVEUffCDH4w2bdoUpVKp6MEPfnB0xRVX7OlLcuwhSLrNP5/+9KfDexYWFqKXvvSl0cDAQNTX1xc9+clPjnbs2NH1OX/605+ixzzmMVFvb280NDQUveY1r4mazWbXey655JLoqKOOilKpVHTggQd2fQdw2dx3sZaUcrly/KX4n//5n+iII46I0ul0dOihh0b//u//3vXzTqcT/dM//VM0OjoapdPp6FGPelR0/fXXd71nZmYmesYznhFls9kon89Hz33uc6NGo9H1nl/+8pfRQx/60CidTkf77bdf9M53vnOna/nKV74S3fe+941SqVR0+OGHR9/61rd2/Q077nbU6/XoFa94RbRp06Yok8lEBx54YPTGN76xK6BzuXLcGVxyySW36VeddtppURTds+TozlyL456BO5KrG2+88Xb9+UsuuSR8hsuV456CWBRF0e6ry3I4HA6Hw+FwOBwOh8PhcDh8ppTD4XA4HA6Hw+FwOBwOh2MPwEkph8PhcDgcDofD4XA4HA7HboeTUg6Hw+FwOBwOh8PhcDgcjt0OJ6UcDofD4XA4HA6Hw+FwOBy7HU5KORwOh8PhcDgcDofD4XA4djuclHI4HA6Hw+FwOBwOh8PhcOx2OCnlcDgcDofD4XA4HA6Hw+HY7XBSyuFwOBwOh8PhcDgcDofDsdvhpJTD4XA4HA7HvRynn366nvSkJ+3py3A4HA6Hw3Evg5NSDofD4XA4HA6Hw+FwOByO3Q4npRwOh8PhcDgcDofD4XA4HLsdTko5HA6Hw+Fw7EZ89atf1ZFHHqne3l6VSiWdeOKJmpub009/+lM9+tGP1tDQkAqFgk444QT94he/6PrdWCymj3/843rc4x6nvr4+HXbYYbr88sv1hz/8QY94xCPU39+vv/qrv9If//jH8DtvectbdNRRR+njH/+4Nm7cqL6+Pj3taU9TrVa73WvsdDo677zzdMABB6i3t1cPeMAD9NWvfvVuWxOHw+FwOBz3Tjgp5XA4HA6Hw7GbsGPHDj3jGc/Q8573PP32t7/VpZdeqqc85SmKokiNRkOnnXaafvKTn+iKK67QwQcfrMc+9rFqNBpdn3HuuefqOc95jrZu3apDDz1Up556ql70ohfp7LPP1s9+9jNFUaQzzzyz63f+8Ic/6Ctf+Yr+53/+RxdddJGuvvpqvfSlL73d6zzvvPP0uc99Th/72Mf0m9/8Rq961av0rGc9Sz/60Y/ulnVxOBwOh8Nx70QsiqJoT1+Ew+FwOBwOx70Bv/jFL3T00UfrT3/6kzZv3nyH7+10OioWi7rgggv0uMc9TtJKpdSb3vQmnXvuuZKkK664Qlu2bNEnP/lJPe95z5MkfelLX9Jzn/tcLSwsSFqplHrb296mm266Sfvtt58k6aKLLtIpp5yiW2+9VWNjYzr99NNVrVb1jW98Q0tLSxocHNT3v/99bdmyJVzPP/zDP2h+fl4XXHDBLl8Xh8PhcDgc9054pZTD4XA4HA7HbsIDHvAAPepRj9KRRx6pv/u7v9N//Md/qFKpSJImJib0ghe8QAcffLAKhYLy+bxmZ2d18803d33G/e9///Dv0dFRSdKRRx7Z9dri4qLq9Xp4bdOmTYGQkqQtW7ao0+no+uuv3+ka//CHP2h+fl6PfvSjlc1mw5/Pfe5zXW2BDofD4XA4HHcViT19AQ6Hw+FwOBz3FsTjcV188cX6f//v/+l73/uePvjBD+qNb3yjrrzySr3kJS/RzMyMPvCBD2jz5s1Kp9PasmWLlpeXuz4jmUyGf8disdt9rdPp/EXXODs7K0n61re+1UVkSVI6nf6LPtPhcDgcDofjtuCklMPhcDgcDsduRCwW0/HHH6/jjz9eb37zm7V582Z9/etf12WXXaaPfOQjeuxjHytJ2rZtm6anp3fJd958883avn271q9fL2ml7a+np0eHHHLITu+93/3up3Q6rZtvvlknnHDCLvl+h8PhcDgcjtuCk1IOh8PhcDgcuwlXXnmlfvCDH+ikk07SyMiIrrzySk1NTemwww7TwQcfrM9//vM65phjVK/XddZZZ6m3t3eXfG8mk9Fpp52m97znParX63r5y1+upz3taRobG9vpvblcTq997Wv1qle9Sp1ORw996ENVq9V02WWXKZ/P67TTTtsl1+RwOBwOh8PhpJTD4XA4HA7HbkI+n9f//u//6v3vf7/q9bo2b96sf/3Xf9VjHvMYjY2N6YUvfKEe9KAHaePGjXrHO96h1772tbvke+9zn/voKU95ih772MeqXC7rcY97nD7ykY/c7vvPPfdcDQ8P67zzztMNN9ygYrGoBz3oQfrHf/zHXXI9DofD4XA4HJI/fc/hcDgcDodjn8Zb3vIWfeMb39DWrVv39KU4HA6Hw+FwdMGfvudwOBwOh8PhcDgcDofD4djtcFLK4XA4HA6Hw+FwOBwOh8Ox2+Htew6Hw+FwOBwOh8PhcDgcjt0Or5RyOBwOh8PhcDgcDofD4XDsdjgp5XA4HA6Hw+FwOBwOh8Ph2O1wUsrhcDgcDofD4XA4HA6Hw7Hb4aSUw+FwOBwOh8PhcDgcDodjt8NJKYfD4XA4HA6Hw+FwOBwOx26Hk1IOh8PhcDgcDofD4XA4HI7dDielHA6Hw+FwOBwOh8PhcDgcux1OSjkcDofD4XA4HA6Hw+FwOHY7nJRyOBwOh8PhcDgcDofD4XDsdjgp5XA4HA6Hw+FwOBwOh8Ph2O1wUsrhcDgcDofD4XA4HA6Hw7Hb4aSUw+FwOBwOh8PhcDgcDodjt8NJKYfD4XA4HA6Hw+FwOBwOx26Hk1IOh8PhcOxF2H///XX66afv6ctwOBwOh8PhcDjuMpyUcjgcDsdejc985jOKxWL62c9+tqcvRW95y1sUi8XU09Ojbdu27fTzer2u3t5exWIxnXnmmXfrtczOzuqcc87REUccof7+fpVKJR111FF6xSteoe3bt9+t331ncMEFF+j973//nr4Mh8PhcDgcDscehJNSDofD4XDsYqTTaX3xi1/c6fWvfe1ru+X7m82mHv7wh+tf/uVf9LCHPUzvfe979Y//+I960IMepAsuuEC/+93vdst13BGclHI4HA6Hw+FwJPb0BTgcDofDsa/hsY99rL74xS/qda97XdfrF1xwgU455RT953/+5936/d/4xjd09dVX6/zzz9epp57a9bPFxUUtLy/frd+/q7G4uKhUKqWenrs/l9ZqtdTpdJRKpe7273I4HA6Hw+G4t8MrpRwOh8Nxr8DVV1+txzzmMcrn88pms3rUox6lK664Yqf3/epXv9IJJ5yg3t5ebdiwQW9729v06U9/WrFYTH/605/u1Hedeuqp2rp1q6677rrw2vj4uH74wx/uRBKBpaUlnXPOObrPfe6jdDqtjRs36nWve52Wlpb+7Hv94x//KEk6/vjjd/pZJpNRPp8P/z/99NOVzWZ1ww036OSTT1Z/f7/Wr1+vt771rYqiqOt3O52O3v/+9+vwww9XJpPR6OioXvSiF6lSqez0Pd/5znd0wgknKJfLKZ/P69hjj9UFF1wgSXrEIx6hb33rW7rpppsUi8UUi8W0//77S5IuvfRSxWIxfelLX9Kb3vQm7bfffurr61O9XpckXXjhhTr66KPV29uroaEhPetZz9Ktt9660/dfeOGFut/97qdMJqMjjjhCX//613X66aeH75GkP/3pT4rFYnrPe96j97///TrooIOUTqd17bXXanl5WW9+85t19NFHq1AoqL+/Xw972MN0ySWXdH2P/YwPf/jDOvDAA9XX16eTTjpJ27ZtUxRFOvfcc7Vhwwb19vbqiU98osrl8p3YRYfD4XA4HI59H14p5XA4HI59Hr/5zW/0sIc9TPl8Xq973euUTCb18Y9/XI94xCP0ox/9SMcdd5wk6dZbb9UjH/lIxWIxnX322erv79cnPvEJpdPpP+v7Hv7wh2vDhg264IIL9Na3vlWS9OUvf1nZbFannHLKTu/vdDp6whOeoJ/85Cd64QtfqMMOO0zXXHON3ve+9+l3v/udvvGNb/xZ379582ZJ0uc+9zm96U1vUiwWu8P3t9tt/c3f/I0e8pCH6N3vfrcuuuginXPOOWq1WuH6JelFL3qRPvOZz+i5z32uXv7yl+vGG2/Uhz70IV199dW67LLLlEwmJa3M+Xre856nww8/XGeffbaKxaKuvvpqXXTRRTr11FP1xje+UbVaTbfccove9773SZKy2WzXNZ177rlKpVJ67Wtfq6WlJaVSqfDdxx57rM477zxNTEzoAx/4gC677DJdffXVKhaLkqRvfetbevrTn64jjzxS5513niqVip7//Odrv/32u837//SnP63FxUW98IUvVDqd1uDgoOr1uj7xiU/oGc94hl7wgheo0Wjok5/8pE4++WRdddVVOuqoo7o+4/zzz9fy8rJe9rKXqVwu693vfree9rSn6a//+q916aWX6vWvf73+8Ic/6IMf/KBe+9rX6lOf+tSd3k+Hw+FwOByOfRaRw+FwOBx7MT796U9HkqKf/vSnt/ueJz3pSVEqlYr++Mc/hte2b98e5XK56OEPf3h47WUve1kUi8Wiq6++Orw2MzMTDQ4ORpKiG2+88Q6v5ZxzzokkRVNTU9FrX/va6D73uU/42bHHHhs997nPjaIoiiRFZ5xxRvjZ5z//+ainpyf68Y9/3PV5H/vYxyJJ0WWXXRZe27x5c3Taaafd4XXMz89HhxxySCQp2rx5c3T66adHn/zkJ6OJiYmd3nvaaadFkqKXvexl4bVOpxOdcsopUSqViqampqIoiqIf//jHkaTo/PPP7/r9iy66qOv1arUa5XK56LjjjosWFha63tvpdMK/TznllGjz5s07Xc8ll1wSSYoOPPDAaH5+Pry+vLwcjYyMREcccUTX537zm9+MJEVvfvObw2tHHnlktGHDhqjRaITXLr300rAe4MYbb4wkRfl8PpqcnOy6jlarFS0tLXW9VqlUotHR0eh5z3veTp8xPDwcVavV8PrZZ58dSYoe8IAHRM1mM7z+jGc8I0qlUtHi4uJO9+5wOBwOh8Nxb4O37zkcDodjn0a73db3vvc9PelJT9KBBx4YXl+3bp1OPfVU/eQnPwmtYRdddJG2bNnSVQUzODioZz7zmX/295566qn6wx/+oJ/+9Kfh79tr3bvwwgt12GGH6dBDD9X09HT489d//deStFPL2P+F3t5eXXnllTrrrLMkrVQuPf/5z9e6dev0spe97DZbAu3TAHk64PLysr7//e+HaywUCnr0ox/ddY1HH320stlsuMaLL75YjUZDb3jDG5TJZLq+4/+q2LI47bTT1NvbG/7/s5/9TJOTk3rpS1/a9bmnnHKKDj30UH3rW9+SJG3fvl3XXHONnvOc53RVX51wwgk68sgjb/O7nvrUp2p4eLjrtXg8HuZKdTodlctltVotHXPMMfrFL36x02f83d/9nQqFQvg/1XfPetazlEgkul5fXl6+zZZDh8PhcDgcjnsbnJRyOBwOxz6Nqakpzc/P65BDDtnpZ4cddpg6nY62bdsmSbrpppt0n/vcZ6f33dZr/xce+MAH6tBDD9UFF1yg888/X2NjY4FkWovf//73+s1vfqPh4eGuP/e9730lSZOTk3/29xcKBb373e/Wn/70J/3pT3/SJz/5SR1yyCH60Ic+pHPPPbfrvT09PV2EnaTw3czR+v3vf69araaRkZGdrnN2djZcI/OsjjjiiD/7mi0OOOCArv/fdNNNknSb+3jooYeGn/P3n7OPa78LfPazn9X9739/ZTIZlUolDQ8P61vf+pZqtdpO7920aVPX/yGoNm7ceJuv39YcLofD4XA4HI57G3ymlMPhcDgcdxNOPfVUffSjH1Uul9PTn/702316XKfT0ZFHHqn3vve9t/nztcTGn4vNmzfrec97np785CfrwAMP1Pnnn6+3ve1tf9ZndDodjYyM6Pzzz7/Nn6+tNLqrsFVSdzdu67u+8IUv6PTTT9eTnvQknXXWWRoZGVE8Htd5550XiDeLeDx+m599e69Ha4bIOxwOh8PhcNwb4aSUw+FwOPZpDA8Pq6+vT9dff/1OP7vuuuvU09MTSJ/NmzfrD3/4w07vu63X7gxOPfVUvfnNb9aOHTv0+c9//nbfd9BBB+mXv/ylHvWoR/1ZLW5/LgYGBnTQQQfp17/+ddfrnU5HN9xwQ6iOkqTf/e53khSeVnfQQQfp+9//vo4//vg7JIwOOuggSdKvf/3rO6ww+3Pvk+Ht119//U4VZ9dff334OX/f1X386le/qgMPPFBf+9rXuq71nHPO+bOu2+FwOBwOh8Nx+/D2PYfD4XDs04jH4zrppJP0X//1X6EVTZImJiZ0wQUX6KEPfajy+bwk6eSTT9bll1+urVu3hveVy+XbrQ76v3DQQQfp/e9/v8477zw9+MEPvt33Pe1pT9Ott96q//iP/9jpZwsLC5qbm/uzvveXv/ylpqend3r9pptu0rXXXnubLXAf+tCHwr+jKNKHPvQhJZNJPepRjwrX2G63d2r9k6RWq6VqtSpJOumkk5TL5XTeeedpcXGx6322Oqi/v/822+BuD8ccc4xGRkb0sY99rGsm1ne+8x399re/DU81XL9+vY444gh97nOf0+zsbHjfj370I11zzTV3+vuocLLXfOWVV+ryyy+/05/hcDgcDofD4bhjeKWUw+FwOPYJfOpTn9JFF1200+uveMUr9La3vU0XX3yxHvrQh+qlL32pEomEPv7xj2tpaUnvfve7w3tf97rX6Qtf+IIe/ehH62Uve5n6+/v1iU98Qps2bVK5XP6Lqphe8YpX/J/vefazn62vfOUrevGLX6xLLrlExx9/vNrttq677jp95Stf0Xe/+10dc8wxd/o7L774Yp1zzjl6whOeoIc85CHKZrO64YYb9KlPfUpLS0t6y1ve0vX+TCajiy66SKeddpqOO+44fec739G3vvUt/eM//mNoyzvhhBP0ohe9SOedd562bt2qk046SclkUr///e914YUX6gMf+ID+9m//Vvl8Xu973/v0D//wDzr22GN16qmnamBgQL/85S81Pz+vz372s5Kko48+Wl/+8pf16le/Wscee6yy2awe//jH3+49JZNJvetd79Jzn/tcnXDCCXrGM56hiYkJfeADH9D++++vV73qVeG973jHO/TEJz5Rxx9/vJ773OeqUqnoQx/6kI444oguouqO8LjHPU5f+9rX9OQnP1mnnHKKbrzxRn3sYx/T/e53vzv9GQ6Hw+FwOByOO4aTUg6Hw+HYJ/DRj370Nl8//fTTdfjhh+vHP/6xzj77bJ133nnqdDo67rjj9IUvfCE8JU1amd10ySWX6OUvf7ne8Y53aHh4WGeccYb6+/v18pe/fKenye0q9PT06Bvf+Ibe97736XOf+5y+/vWvq6+vTwceeKBe8YpXdLXV3Rk89alPVaPR0Pe+9z398Ic/VLlc1sDAgB784AfrNa95jR75yEd2vT8ej+uiiy7SS17yEp111lnK5XI655xz9OY3v7nrfR/72Md09NFH6+Mf/7j+8R//UYlEQvvvv7+e9axn6fjjjw/ve/7zn6+RkRG9853v1LnnnqtkMqlDDz20izh66Utfqq1bt+rTn/603ve+92nz5s13SEpJK3vZ19end77znXr961+v/v5+PfnJT9a73vUuFYvF8L7HP/7x+uIXv6i3vOUtesMb3qCDDz5Yn/nMZ/TZz35Wv/nNb+7UGp5++ukaHx/Xxz/+cX33u9/V/e53P33hC1/QhRdeqEsvvfROfYbD4XA4HA6H444Ri3zSpsPhcDgcd4hXvvKV+vjHP67Z2dnbHVy9t+L000/XV7/61XtF9c9RRx2l4eFhXXzxxXv6UhwOh8PhcDgc8plSDofD4XB0YWFhoev/MzMz+vznP6+HPvSh+xwhta+i2Wyq1Wp1vXbppZfql7/8pR7xiEfsmYtyOBwOh8PhcOwEb99zOBwOh8Ngy5YtesQjHqHDDjtMExMT+uQnP6l6va5/+qd/2tOX5riTuPXWW3XiiSfqWc96ltavX6/rrrtOH/vYxzQ2NqYXv/jFe/ryHA6Hw+FwOBz/P5yUcjgcDofD4LGPfay++tWv6t///d8Vi8X0oAc9SJ/85Cf18Ic/fE9fmuNOYmBgQEcffbQ+8YlPaGpqSv39/TrllFP0zne+U6VSaU9fnsPhcDgcDofj/4fPlHI4HA6Hw+FwOBwOh8PhcOx2+Ewph8PhcDgcDofD4XA4HA7HboeTUg6Hw+FwOBwOh8PhcDgcjt0OJ6UcDofD4XA4HA6Hw+FwOBy7HT7ofBeg0+lo+/btyuVyisVie/pyHA6Hw+FwOBwOh8OxBlEUqdFoaP369erp2ffqMxYXF7W8vPwX/34qlVImk9mFV+Rw/N9wUmoXYPv27dq4ceOevgyHw+FwOBwOh8PhcPwf2LZtmzZs2LCnL2OXYnFxUQcccIDGx8f/4s8YGxvTjTfe6MSUY7fCSaldgFwuJ2mFWe7p6VEsFtPCwoLi8bja7XZ4LYoi9fT0KJ1Oh/eMjIxocXFRtVpNnU5Hvb29ymQyajQaarVayuVyisfjajabarVaSqVSarfb6nQ6Xf9eXFyUtML+F4tFtVotLS0tKZlMauPGjZqcnFQ6nVZvb69GR0dVLBYVi8XU6XSUTqcVj8c1Pz+vnp4e9fb2am5uTgMDA0qn05qfn9fMzIyOO+44lUol9fX1KR6Pa3l5WVEUqVqtanZ2Vp1OR/Pz85qentZ1112nZDKp5eVlLS4uqlwuq6+vT51OR+Pj40qn05Kk3t5eLS8va2lpSc1mUzwMMplMKpPJKJPJqNVqhbVbXl5WLBZTb2+v+vv7ddRRR6lQKCifzyuKIkVRpIWFBbXb7bAerVZLN954oxqNhhYWFhRFker1unp7e8O9gSiKFIvFlEwmlUqllEwmlc1mdeSRR+qEE05QsVgM93X11VerUqmoVCqp1WqpVqt1yQT7X6/Xgzz09vZ2yUV/f7/m5+fV19enWq2mZDIZrr3VaunWW29VJpNRIpFQMpkMcsB6sIdjY2Nqt9saGRlRpVJRuVzW4uKixsbG1NPToyiKtLi4qHa7rXQ6rbm5OS0tLemmm27Sn/70JxUKBeVyOS0sLGhpaUkLCwvq7e1Vs9nUwsKCYrGYDjvsMB177LGanZ1Vs9nU3NycYrFY+JNKpYIM1Ot1tdttZbPZ8OeWW25RX19fuO90Oq10Oq1kMqn169dr/fr1SiQSmp2d1dzcnOLxuCQpkUgok8lofn4+rOO2bdu0uLiomZkZtdvtsH59fX3hXufn57W8vKxSqaQDDzxQY2Nj6u/vV7PZ1NDQkGZnZzU/P69cLqdms6lKpaJWq6Vyuazp6WlNT09LUvhMzpOVlZtuukmtVkvtdluLi4taWlpSLBbT0NCQ1q1bp3Q6rb6+Pi0vL4fznM/n1dPTo3a7rdnZWcXjcY2Pjwe5XVhY0NzcnOr1epCZZrOper2u5eVlZTIZJZNJlUolHX744Uomk5qfnw/6hzWan59XIpEIZz2TySiXywV9EY/HlUgk1NPTE85zq9XS4uKiOp2OqtWqbrrpJmWzWc3OzmrDhg363e9+F/TR+Pi4Op2Oenp6lMlkgj5CPmKxmPr7+9XX16dKpaIoisJazs7Oqre3V61WS8vLy8pms+G6ksmkent7tbi4qMXFRcVisXANURQplUopm82q1WqFe5iZmQn6LYoiLS8vK5VKKZVKaWlpScvLy5qfnw96BZnOZDJKp9NqNpvKZrPasWOHUqmUEomEoihSu91Wf3+/DjjgAA0MDGjHjh1aWFhQPp9XrVZTT0+P5ubmtG7dOuVyOUVRpEKhoNnZWbVarXBmY7GYenp6wrWkUin19/er3W4HOZ+amlJfX5+mpqaUzWaVSCS0Y8cOdTodtVotzc/Pq9PpqNPpBHvS6XS0bt063fe+9w3fu3HjRg0NDanT6XSd+0qlEs4tNqtararZbKrT6WhyclLj4+NKJBLK5XLKZrPq6+tTq9VSoVBQMpnUwMBA0D2pVCrsH7ooFoupWCxqZGREo6Oj6nQ6kqR2u63e3l6l02k1Gg3Nzc0pnU5rdnZWt956qxqNRjiPktTf36/+/v6Qwe7p6Ql6LJPJBJuxfv36cO6wwbFYTMvLy6rVatqxY4cqlYo6nU7QaclkUrFYTNVqVf39/Uomk6pWq6rX60qn0yoWi0qlUiHLnEwmg04sFApBh3G2Y7GY5ubmVCgUVK/XJSnsc6fT0fT0dNC3sVhMiUSi66yj45LJpPr6+tRoNBSPx7WwsKB0Oh3OBzLEGW2324rFYorH4xoYGFCn09Hf/u3fqq+vT5dddpkOOeQQVSoVTU5Oam5uTgsLC8pms0qlUqpWq0EfTkxMqFqtBlvSarU0MjKidevWKZlMBn0lKdxzMplUvV5XuVxWLBZTOp1Wq9XS7OysGo1G2A/0Ivq+3W5rbm5OkrS8vKyhoSEtLi6qp6dHi4uLqlarSiQSQTbQ4+iNcrmsgw46KHyWpGArlpaW1Ol01NfXJ0ld67WwsKBOp6N2u61EIqFUKqXp6WmlUinNzMwE24VtREawT6y5JGUymeAncT3tdltTU1MqFAoqFothXyuViubm5sJnx2KxoNeQ5Xw+Hz4/Foupr69Pc3NzQbZKpZLWr1+v0dHRsPbxeDzoy5mZGdVqNc3OziqRSKivr0/XXXdd8LFisVg44+j4Vqulgw46SLlcTvV6PVxPLBZTu91WKpXS2NhYkO1Op6NarRZ0bbvdVqPRCPfEGd28ebOOPfbYcM5vvPHG0EUgScPDw2q32zryyCOVy+WCP4SNjMViarVampyc1MzMTLjPqakp1Wo1bd68WQsLC5qYmFCz2Qw+xNLSkhYXF1UsFsP/Z2dng1/SbDbVbrfD7+C7DA4OBj1eq9UUi8XCnrVareALoovi8bg2bNigTqejXC4XdDQ6CRvAeW21WqrX68rn8+E96I5OpxPsL/K0uLioZrOparUarhfd1Gq1go+cyWQUj8dDNUw8Hlc2m5Uk7b///lpcXFSj0VBPT4+Gh4e1bds2rVu3Tv39/arX65qfn9fi4qKmp6e1uLio3t5eSdL8/LyazaaOPfZYLSwsBH8XH6darQZ9xTojf+12O9ikeDyuubm58L5arRZ0GbYWO8w64wNgo619xh855JBDgu9VLpe1bt06NRoN9fb2ht/HV+P8o9OWlpZUKBS0tLSkpaUlbd++Xb///e+DbO5LWF5e1vj4uG6++Wbl8/k/+/fr9bo2bdoU/E2HY3fBSaldAIwyBgznDkfJBjgoSUmBpEkkEurt7VUikQhKFccK5ZxMJkOwh3MFCQORA8EDOp2OSqVScFpxTnDoCWxw5JeWlrRhwwY1m02Njo6GoBISBUIjlUoFY5jJZNTX16dEIhEIhYWFBQ0PD6tWqwVDKa0YvHQ63bUW9nMJNBcWFtRsNsP9t1otSQpOaCKRCIaoXC5raGgoOB7pdDqQDATxvb29yufzwfFOpVLh82KxWAgwCSDtZ2HY8vm8RkdHNTAwEAKn3t5eDQ4OKpFIqFKpKJVKaXBwMBAEiUQiBHSsI8TB/Py85ufnFY/Hg3OGkYdIYz0TiYTm5+fVaDSCc0PAyzriKMfj8WDIh4eHlc/nA+m4sLAQgiGcz3Q6rYGBgfBzgktIv/Hx8eCkDg0NqVgsKpfL6dZbbw33wh+Ca8qicS5wwgqFQnA0LEFWKpWCczkwMBCCu8XFRRUKBTWbTfX09Kivry+QCRMTE1pYWFBfX19wqAcHB9Xf3y9pxSgvLCxoeXk5fHY2mw0OyNDQkNLptDKZjAqFgmZmZlQqlUKQlUgkguwiswTiyEkmk9Hk5GQgR9hXHEyIyVQqpUKhEIgb5B4Zq9VqGhsb0+TkpJLJpCqVSrh3KyvogUQioXa7He6N8zkwMKBqtapMJqN2u61cLhfOa19fn/r7+8OZhZyTFIKcgYGBQKDs2LFDuVxOY2Njqtfr4fcLhUII8Hp6etRsNsM1oV/4DHRio9EI+m5paUmpVEoDAwNqt9tBziHf0FvouHg8rmQyGZz92dlZLS8vB9mBlMJJt2tLIGKJL64ZOWRP2V8+I5FYMY38m/vhfLFu6PMoijQxMaGhoaFwNgkupZXMZSqVUm9vr3p7ewOxARkfj8c1NDQU9CHESk9PT9Aty8vLwVbYIBnyI4oiJZPJ4MTPzMwol8sFQo5zZPXG/Py8Zmdng6wiA319fZqdnQ1kPzqm1WqFNSOoIHnANbN31rZBghKsZjKZYHvQoXNzc+HeCVSQWa4hm82GYLivr0/FYlHVajXYPmSQ78rlcmq326rVasEWo8tISkDsoFshYQhyms1m+F3WFiBTyAlEEvuFLCBvJKP4TJIeJC/y+XywP5ASfI4lnHO5XEiOcKawl4lEQgMDA8rn8yFYJ+jDNlSr1RDIzszMhKRSIpFQPp8Pvsnc3JxKpVIgillP7h0iGrITv4R1aTQaIaDP5XLhWjqdTiAO0ul08H0gXWxSDR2Pve3t7VWhUAiyi52GALM6Gn2CHmAN0fFc79LSUpBjSDJ8KwJybLq0Qn4uLCwokUgEW8CZRjew5olEQouLi8pkMoEcJXgn0Yg/wveReCChk0qlwjrx/SRIsKHoov7+/vBzCPpOp6NGoxHkHz2HbsTnJOGArS4Wi4FIgEzP5XKBALT6sdVqhdey2WzwVQcGBrS4uBj0P0Q3JGaxWFRfX59SqZTq9brm5uYURZHS6XTwR5BV5OOGG24INgNCkTViDbEdXB9yS6IE/xfSiTPY39+vRCIRiGXsUyaTCWcIu55Op3XggQeqUqlobGwsJHTw47LZrMbGxoKNsgQPfhL+FvoriqKu68FHZR9sgsPqS/ZudnY2kMlLS0vBJuJHY0/xT6vVqlqtlnp7e8Na8/7+/n4tLS0F/5lYBnvMeeZsxGKx4LtBoiG36HKuAbmvVCrK5XIhgcR5gsRi77FbxBokdIvFYkie4qsXi0UtLS0FWUK++vr61G63VS6XA1mzL49cyeVyfxHpRkzpcOxuOCm1i0FgjsNoHWybyZ+dne0KTGyVysjISMi4kmGzhBbGlv9bIiyKIs3NzQWSw1Zo4NAQ0BKMYZAGBweD44zTJCl8lu1RhijB2bKBHc7l/Py8yuVycJTJ/vX29gYHkrXBGOIo4tDUajVFURSuHUcFh3Z+fl7VajUYShsc40iw1hjtTqejbDar7du3B2e0UCgEhxZHK4qikKWNx+PBkVpeXg6GHyNMVRCv4bTg8JDVJDOUTCY1ODioVqulvr6+4LC12+1Q+dLpdLR582bNzs4qlUppeHg4fB/OSTabVT6fV6FQCGvN/fb39wdHBOeU4IF1t44cgXwikdDU1FS4Z4J11gZSEQIkn88rm80qHo+H7DYVCH19fcrlcspkMmo2myqVSiFDDgmBg4HzbTOBrDnZZ+SLjBfVC2S3CQDYfxtwcI+JREK1Wk2Tk5PBebYyY88Y55Yzg4zjzCaTyUB+sX8E2vF4XMPDw5JWCBkCHrK0VDCxZktLS8GBz2azWlxcDJVUxWIx/B+HgapA/g9Jk8/nw7kgqMCxJmCp1+shQEHHQLZAIOTz+RBUQqYQbJN1pCIAoojf4wxQGSApBLBUPOIwSlKtVgvELVUjBIXs6ezsrCQFooQAqNVqBZJCWnFyLTmPUwzxTiAJubK0tKRyuRz0Vm9vbxexIknNZjMQqfV6PQSYnU5H69evD6RoKpXS3NxcyIpDcDQajUAUZjIZ1Wq1YB8IWKjkhKRg39BZEInIIfqtv78/kH/Dw8PBWU8kEqrX6+HzuDb0Gr+7tLSkWq0WkgaQE5D7kKzLy8shKITcwz5Q8cA+FwqFUKkBKRmLxXTrrbeGwMLq/7Xkpg00M5mMlpaWwucRjHO20dWsAWcTgm/t9VAtyP729PRodHQ0nF++D9uKXYbE4xqoamKfIL4IZufm5roy9chzs9kMmX3sM2eHyqBcLhd0N7qLtSUAQzZJWPX394d1sOQq8kagTVDL+SRhQNWGJeEKhUI4g6wvv7+4uKhEIhESALVaLVSbIVf9/f2BdJcU7CmVhDMzM+FnJEzYJ6pCuB/kjiAbQhGyEBIyHo+Hyk90BgkNzg06H/sHeYccUj1pKy7xSzKZTBfZzP5zrbyX5JSksK4QYrlcLtzL8vJykAPsEWRyX19f0OsQyugdfDdklbMKWcN91et1JZNJDQ0NhSo8W8W9ffv2kIiErMG3QL7QDaw9ZAS+IgQEFTr4IZyv/fbbLySqSKZA0EBOYY8giyE07N5zjkZGRkICivvj7JGAslWltjJydHRU9Xo9yCBEErbKVoG22+1AlGC78DXxL5At7MbS0pIGBweDXEDAsH622hFZm5ubC3oaW5BKpZTP58N3k8CyhCYJP9YoHo8HcpvrojKJ6hnWHcJncHAwEDgkPPCnqGxkjzizQ0NDIYnMWeA8oHfR+dggbA56iHW0/jYxEeQufiykNolIS2RbPVepVIJ9YN+QUfyldDqtoaGh4Lvsy7BFC3/u7zkcewJOSu1CcJBRyihf20pGBpfqIgLFhYWF4KTjqBO0YIDInlJNhDFaXFwM5fM4VQT2tuWPoLtUKoXKLAIKrpHst6RAEBGAFQoFSQpBF0EgGRdIF+4DQ1+pVJTJZDQ1NRUcfoIcSrdpL8AxsO0tfId1qHDayDbtt99+XVUcOD3cM4bLZmtZZxxum+nE0cbYLy8vh2CU9iFIMzK6fAcEGmuPU4fTi3ywP9y3pGB0qRZiHcgk4fTatgkCN4KMTCajer0eSJtarRbauQhgJYVgZG5uTrVaLTjf5XK5q/2LvcQZpaKCSi9kCZnHmcEpwzEnew4J2t/fHxwdgjdLbpCpx8EmWMJplBQCx1Kp1EXWSAoZNq6NlhLOig0YbGm9zZJbx3ZtJc7CwkJoV6FKIp/PB7KKa0C+IAWpwuI7ybqzhzhuOHGsPc6VzUxCDEDCWPmCfMWhpEKEwMW2AUFIdTqdQNDwnZx7nF5k3RLJBHCQqmTnqBxbWloK8gIptxZUceFscjb5XojPgYEBzc3NaX5+PgQClmAnCLDyaLOuVH0sLCwolUoFR19aIViQUT4XchJZhkShigFSYL/99lOlUuki5QjsCGgIPGh/QfaazWZoYcvn8yFD3ul0gs6hwgV9Y1sveS97RjUrJBLVcxMTE6G6BHsE2UJFBcQpCRRIBipDuBZJISBGjgl2uR/bBoc9xO5xthqNRkjCQEyT0aYilrY7bBZBPEQD9w3hMTc3F2TbVoJYYshWirIWBL22LckmFvjZ0tKSGo1GqEZrNBohUKZNlMoD9gu7CuGG7ZdWiDtIJmz39PR0qC5gHzlf7BNnl72BNKfiF3lPpVKanZ3tIsm4H/TK8vJysLnYAsg8bBgtSlS8QH7Pzc2FNi9LLnAGSSJAXGzfvj3cD7Jg28dI2qAzsFvWbkKkW6KJIBVZhki3pAmkGrqCs8+64jNYe2ATHPg3iURCw8PDoU0JPch7IX/xKfA/2GPIGZIt2BvWlnOEvqUiDtsCiUf1YCy20mo3ODgYzje6aWxsLFS/QSZyBtBJrAFkFXuGrEIEYNeRB/xA7Dg+HnIM0TM/Px8qsPgufCt0HIQJOhPZQJbQV/g9rLclyG1ls/XjisViSK719/eHyj7OJsQHvpWt1LVVPVNTU+rp6dG6deu0adMmJZNJbdiwIegESPyenp6QuLNVdqw1uoB9tokUa++Rd3wWElj4rzZhTcV0MplUoVAIJH1PT48GBgYCUYgvxVmg6gl/HJIQPQiZPD09Hewpvp/1S7Bxth2zWq2qr69P1Wo1yJr165BFzpGt9LPJMmwJZzqfz2tmZkbValXDw8NBVkiCQeISk7CfjCW5N5BSDsfeBieldiGogKKUFqfQOhI4ZrSvYDCXl5fDTBAyZxAudjYABs8SBNJqJpBAPx5faR0cGhoKAbFtYcIY4HBC9nQ6nTBvCQIMMoXWFO6xVCp1tcfgpJBJbLVaXY4lQTdGD2cfpxADSzAorbbyECxI6vq3pGC4cPYJmG01GO07BEoLCwvatGlTIGHIqOBQ4qBSFYKzZSsuCKRarZb222+/ELwy2whSDEKLbGMymQwZcdazUqkEQ04wyT0QfON8UIVECTh7h3OBw4FjzlMhaVNc6+za8nsybXw3ThntEjjY/B7XC1lDJRjrRZBpM1pk0dnvubk5VSoVFQqFMIthfn4+kEjJZDJU9iSTSdVqtRCMQhKk0+mQOUc2IDaQ71QqpVKpFPaPPed6k8mkisViCK7YdwgNZBOZgGBqt9vB4SfYsRVBOJNUjbEGrDF7ytng3sbGxsIsJmQHvUGG3pKuXCtVE+gNKmKKxaIkdVUJoZdYB5xdSvAXFxdD6wDyxfmjzYHftwEMJBttNzbohKjhrBCMr62ggrwniCI7zd6iT2yWm+AcghniAmINp7W/vz+0U6RSqTAnheDGViXQXoEcQDjwGbQqp9Np5fP5LlIJhxryiurRZDKp4eFhDQwMqFaraXx8PATO6Khmc2XOGXMGOQ8Acmxubi603LRaK7Pt+F4I/3Q6rUqlomKxGILr+fn5Lh2CHiBYxPZA7BBQUiVD+yOVCJzncrksSdq8eXM4F8yEKxaLgfTodDrasWNHkFtbGUNVweLiYpjDBunA+tdqtVBhQBUEn0V1D/KJ3NBaDsnGeYjFVmb3VCqVQNBTyWlJTMgI1tAmnAgMuRcqCCBquAZ+1+ombBiVOHw/5wY7wnv5HHQu+83+WJ/B6mvsAq9z5gnOmV1DhSe2GL1HkMcaYGPq9XqohJmdnQ2tcJ1OJ1QEJxIJDQ4OBv3GzyE/qRZmTVh7fAqItlwuF6qQuG4CVNp0aDlCd+JnLS0tBRKDihSqSSEpIIQA/ge6nGumOqNUKoV1RTfa1lpbVYnfRUs28ofuaLdX5kK2Wi0NDAxIWqnsGxkZCXuMbuK8ogOxY6wb19LX1xcqZSAT0IPW54F8g8DAvuJv3HTTTWHeKG1S1heDSKTqDh9xfHxcs7OzGhkZCQkZ7AxjJbBDrDN6GAIf+9bX16dmsxmIX6vj7HnHdvOH5ApJXKqjIPRzuZzm5ubCGrEn9lo4T1STQhDRBpZOp7V58+ago/DvIMQgmG1yrNFoBHmjsrbdbofKfZKLNkmDbsTf5MzTrgdRiz3FT8UHmpubC9eOrWUNrP3kvm1VcrFYDHoRoAsajUY4V5C9+Cf4//iJyC57AynIuVpLKvf09AQby3UPDAxoeHg4/K6dGYjdwr6h4/G/iNX2dXillGNvg5NSuxAYAhxAHGqcVUkh82AzlbTIkHmo1+saGBgIga9t0cPRJZOC8yatVkuQlSILSwBJywEZFTvQGideUnAibfBCANTX1xfmF9ggTlIwmihCjAGBLBk1W4lC5pHKMYw97WEQJ5APEGWNRkOlUkmJRCIMdmdgOQEgTjPOYjweV6PRCLN6JAUnDCKC9jLumWBUWp0TUS6XNT4+rpmZGY2MjHT109u9IGDA4WV/bVVGs9kMwSiyc9NNN2nDhg3BeW61WtqxY0cw0KwD7TW2tcPuy8DAQMg6secYYwIshpIjO9yDnT9E9dn09HSQK/YN41+pVCQp7EOn09HIyEjIuvLdBDcMmN+4cWOYDYPDSHaT88FeIBs49VEUhSHy+Xw+BN3sPYEFgf7g4GCQUbKFlJdTlYSTyu/QctvpdEJmGscnmUwGuUkmkyETSSCF3FMR1W63QyWVrZqjcjCKouD0Q1AiozjKOHBUK+JYc6YILEdGRoIjaCtmOPPsLTNiINggUm655ZYuh5IgYmJiIlRCEIjhuKP/CAgWFxe7srPoQKp20AW2VRNnFB1p27uYcUHVlw2sWCvOOQ4vxDBtRQQ4Vg8iX2SgqQKdn58P+hbdCUE0MDAQWtZisZiGh4e1vLyssbGxsGaWsINU7nQ6yufzwTluNBqhvc1W+NkKDkuucS2cc9bIDquFeGZdaFuw1aj2s6m4wl6xjiMjIyFxcN111+mII44IZ4G15UyTuea+IRTRaclkMugDdAHBVm9vr2ZnZ7v2giBr3bp1QWaobKGSpLe3N1QmUMlkg0aqsrCttmIUezM3N6fJyUlt2rQpVOBSQdXf3x/m1VGhZe2XJf+pRGKAP0AekT1suiW92CvIZtaGNiZINoI59CLEDzYP24tcUyGHjidg5Lr5gw1FtiyJc+211+qwww7rItzQqdhBEiwE2yR9kslkmN2ytLQUEhScxXg8HogjyDHOMQG5DXhjsZjGxsbC+WE9IVMGBga6yDnOh9XdAwMDocqKVmjOAHsF2cGZtecS/UHSDJ1kqxchvqh0tpXGa6thrCxXq9UuAhOCTFohxvg3rW2cP1sxTWKQNWA2IdVHtkLRtuNzfiEG8B3XzmuiCgZ9jz8Ri8VCkoL94D4gWdH5JOaQF4gV9oBKW9s2S8IV4omzQdU6fjD+C/duE5Tse7vd1g033BB+jzWZmprSwsJCSOJhVyE9SBRiA7LZrAYHB4M9HxwcVE9PT0gssyajo6PhZ/gx6L5EIhHOQLlcVrvdVrFYDFX5dug+LeD4PpwNbAcVhVTUUTE6NDQUWlk5e9bPRl7QQ61WKyQh8W3QOcgFSSjmUVmbR9IZ8pm9tmeNakPb+mrJI84vv0fVMXpobm5OIyMjgYDHJ0TXIwck3gqFQiDVOU8kqvZlOCnl2NvgpNQuBG0TEAcYDsgFFOzaUno7BJNgg8wpJafSasbOVhbwx7ZWEFxiAAmiMSz29+kJ53dxuqg84b5wsmwWxAbEZOkokccB4AlilgRC4dkqEq6VIJVrJYuEkbIzHfhOnHuMDI6WJe0IBnC66c8nawaRQOBItgaDCJmCcxmPr8wLwiBzPThOlrDrdDrBIccRxHCSPSJAwrEol8uBUCIQt5VBXAe/j/HnvnHybZsXVU0QPlRb8Zp1cAnQyBi2222VSqUwp4p14ve5VzuXqdNZaQXDeajX66rX6+E+2AMyjVEUhcwdQTKEiK3YkBTOEOQQ5ea2XYcAA5nFMSPIsxlsKlMgCKXVLK2t5JPU5YTZoJ91pFKI80FWslKpBHKHvYHEsS0aBGc4ocgWLWM2Q0qVALNtuM5msxmqZyBdcZJtYIQsWqeQykb0hA10+G7OL/fN2bUBHPKN3iAQ5HMIyAi2LDHLNRPAE2CilwgS7PUx+43XkBObPcdJ5d44B+hiSGgb+DNTi3aWVqsVKk6piqDKFdKcc2l1QrlcDlVbZMIhlQqFgm699VZls9nw/nh8Zd4H90HwgzyQESZzDvFPkEOLKXLc19cXZgtZ4g59wrlgD2lPZNYZ581m4SEFaeOQVmebce8kYlhj5J/qNwJmMvzWfnKP2JVEIhEeSiGttltiB7hv9BK63bZ5ct3otoMOOijMXerp6QkPnoDQYo8s0U27HteCHsNm2dYviDMCLlttxMwX1gcijAoKu77YdVt1aAlM+4Q5KoRZQ2wwBJmtkAG0uGCL8ENuvvlm7bfffkqlUqpUKju1spEYsD7A/Py8RkdHQ5KNClRsPuQ755nzDYmBXiVoRZdgX2wCCx+GteHssR4ksbAzyD4JBjunj+8mGYGdAzywQlptx+PMSyvzjQYHB0PSgwpZW5VLFRV7ynlBdtlD9LN9CA6yyH7a6iD0GToQHZrJZAKJQ+KH1kxbUYifGEVRICkh0WkB7OnpCXJvW+n5w31htxlHgI+GLwzpzOfbyl1stZVb28LMuWa/8EdYR/Qe8siaUWmNL04Ch/Nqq8+oumR/omi1jRlyBL0LEYOu5Fq4Vlv1jxyTXEJmre9mKxO5ZtrWLJnDd6AvIfWiKAqVX2sJQSoJa7VakFmq6ogt5ubmwgNyqEglAUyFGvdF8ob9RMfgF1AZx9m38sk8UltdxdnEf7PV3NJqpZr1vW1bH9WWvG6ryBlHwd4j4/synJRy7G1wUmoXgkARRQ2phBOIIYUkwCgw44agAuecwAMHzWZrcApRxgQedrbB0tLK0HTK3cniYBjXklc4gQRHzMtgVgZBH8YWB5PvwwEmW4bDg2GZnp7uKqvGiNrqCgJ1jJyk4MRLCoaTSgecPxuUUCKNY0KlEo44Q7whETB0tiXBloxj4LgPHIWhoSGNj48HZ4TrYz0JlJnTQeUFTjVzDfg/DjYDdOfm5gIxddBBB4UAktYQBkiSCSWgY1gyT7IZHBxUo9FQuVzuGszKvCHW1M5nIGNnM1U4UwSKzCwgu59KpYLMQwBBOsbjcd1yyy2hBRQ5rVQqymazYT4TTgTX0Gq1QvtYPp8PAROtF7QQ2JYjnByCYAJuAkCqqdhjSaHqCqKKYJD2LtaJNZJWSBScN9owIQF4AgxzbDjnsVgsZLohLxhu2263AxHFUw8hdnkv+oPWMc4ZFUtUSExOTmpgYCBUGzCbh+AD8hvHERK1XC7r1ltv7Zr5Jq1W4eEwQ9wRcJAdpiLLEmlkuXG4edoblZcQ3LelP9A3tDokEonQhkHbEC09ksIwcEvk20oVgvipqSmVSqVAVNuqp06nE6q7cIipGMpmsyGhQLBk9QH7BbmFI0yAumnTpjD0dWZmJlRmoSNsdpkM/dpWHFo80V2cTYbks27SKtFgA9h2ux2+j/dDuKDHqOqMx+Mql8uhdY9qMlsJQUBtEyCcedYBMrPT6YQKh56elceV33LLLV1tQFavl8vlMIgXOWbeHrqWBAIk4dqnPZLUgJgqFAqBaKCVndYvEhLIPy2zBLO0kIyOjob2JElBD0MAUGVZqVSCjPEZdq4Rdgu9zJqVy+UwDB1bBtFHoMxnMeMJv8ESPJD7PT09Qc9C/mOzGXIMyZzP54NtzGazwd5jP6hGYF6NrYCQVkiJ9evXK51eGTxOsohWVNaD80tFHftvq21IpvT39weytlar6YADDggk4sDAgEZGRlStVkMVLvoa4mndunXhHEBiQ9yzttwX92TbM63PYqtpsdeQTUNDQ6FKldeSyWTQ8SRPkHNIbZtUojqY6j/0LkkQdD/3iC1Cb9F6R7ITG841oBtswIqO5P44n6wliSH2Z3h4OLQgcg5texnVRLb9Gr+BBArED4QVhCI6whKzS0tL4dxbO0HFDi3RdjA4/hgEK0P3sZNTU1PBfoyNjQWfCZ+Ue2FN2B+qQHmNlmDOH/pOUmgNtW2BdpYTf2iLww5HURQexIJdxe4MDg4G2c/n813Vr5CP6DZ8QNrM8Y0tcYkc26pW6yvYp00nk0ndeuutXTOZ1l43OoqKM2m1ndImDIkP7FmicoxqMtYR/xLCDGJs3bp14fqsXHNvnGOqSjknJA32dTgp5djb4KTULoQtGbfBnnVmIBbIIhPskHnCOFA6a1vCIAVw2iGicLhtKw1tBAQPtkIFJxbijMoAaXVORa1WC9U6OPw48Dj3lBTjvOEg8VQxnAGy0hAKBMVkmqhmsFUqZAYlhaxPp9MJRn5oaEiTk5PBGcIwUvWAM0JrBdkqjJmkYPhsVgZnHacZYoLgau16Q0rgXPX09IRH5zITgswxDhxZSmm1JYCgi4CWTDdripOA8yipq5ybdZS65zDg3NKuxefxPu4Rh8RWX5EB5JG9ZJ/JTBHwU5pOBpOqGvte1pmAkEDAZi/ZOxwXm1mGzLFOONk6nG1LjBFscCaZydHpdMJgTAhavpuMOntkCSvWizWnBJ1rgfy076PVjVYhBtZzTThHyDAOLRVE/IzgjBYuZBGZhQiHWLNBz9TUVMim2tYSzhsVG7algOAY+YMUwglnjVgHSwxAEBPEcH6s7mMNILjscFj2wWaJ0R3Ikq28pCoE5xWnn98lqIOIt7KPs4os0gKHzoDEwrmFKOG8QexCYqJXkSv0Ap9nh1UTLLAX3AePJIdUgDCu1WpB73L9rCHOPA44M6k4HxC1zPLiMzlfrC9EgCWg1hJ8yIikMJTdtjJZMsTKuW2bYF0gjammIriwVStzc3NhRlEURUGnptPpMESYAJcghn237VS0Bdoh5LyPc2aTScitDbatfoFYZO+o2qGVHMLBPiHOrjv6g0pMzg+2z34/QbRNXFidj2xC7tjWT/Q5vgX3a1vt0FfsP9cyPT0taYXonZmZCeS/PROsCeeepBpBK0Hk8vJyCIoJliEjbPLOgrXFB8C+szYE7NhF2oBpo+QzISepkoWgkKRt27aF/YA0QQ5nZ2dDhRMViPw+Npl75b5tYIzut4kDS3hAoLNX7AWkBfaqVqsFctBW4kvaST5JvlkSk7PB/23Fok2IYX8lhYetzM3NaWJiIlQBQobg8+Fz2opbkg2QxCQXIYuGhoaCPuBzbcUQdiabzQZ/FFmg8o7qdBKutjqZz7NDuLnXmZmZcE34J+hJ66cgk1wT6w9Jip1i36hUZG/xjfjDWWTtqdpFzrlu9AGVPNg/2siREZvIsfO1+A7IbdaVa+Qe7H7xb3STJWfR19h7dKbtAoA0xybh3+FXVavVkJThmrGzJAGoNuVakFVJgbSFlGatucbl5eVQnYgMQEIhF9hgzoaNVxwOxz0HTkrtQuAYkWEkUxWPx0OJOorRDpy0jhbtHQQsOB82QMTJQcHacm/Kb232wWYxMCpkQVDkZImKxaJyuVwo2aXlhnkNGMRisRiMG086ymQyXfMFyHhAWFiniyAaJwTjZltsrHMxNDQkSSEzDQHEbBZptXWM+Qix2MqT/8jo4KBIq9VXOBeWmLCBgy0ltk4d1Qo40qwlg0+5Hp66B1lD8I3T3tfXF4ZZUnlD3z8kFY59IpEIxhZnGCeKdggCN6pXqHai2oAWDCpZbqvKCZnj3wzXJluJs0+7ErNkIGwob4cIkxSIK6o1eB2i0e43TgdBEPLJE54IPCSFQIPAGpKAYM5WglCGbyv7IODIRtqZNjx6GMd/bTl/NpvV+Pi40unVQeiQtn19fRofH9fAwIAKhUIIaCAwuP7+/v5QoYXjZlvWOFcQjew95fcEKtwnQ/Yp0Uc+CSBYfwI5nGdbeYmO4TzixEP2MtAYx47PsJV30uq8ItreIA1isVhXVRyE2VpimuuGiIM4qVaroVKPCixIvGaz2dXugsML2QNhZYMVHFwcZn4XXcfaMWvHtsRxBvkeiAoCBT6DfWq1Wpqenla5XA7EDetKQMfZpvWUNifICK4tkViZBVQoFIKs0soZi60MkS8Wi5qZmQnVN1TNsNYQI+hHzgLk43777RfanAlu2FuGjBM8s3ecYzsPhSodWsWtDcIWkqSBiKW6B9vBOvIUVgYn33TTTRocHAzBjx1iTIsnARAEPVVn7FcqlQrBLbLB/rAvnD9IWhIckGK0G1MNY88b5ws9T3BKooZgDGITm8Z6c/0QZsgpcgehgG6F+EVPpVIpTU1NBTIB8soSX/gGPAmQp9kih5w19ndwcFBRFIXkFfeEvqVaIplMdrUrk0ghSIUMoiIH8oZ14kxDlvI5zMuDDKCSqKenJxA+EKiQQ6wj91UsFkMFHnaB6ieqIu1TBUnMMSC9UCio2WyqVCopmVyZoVWtVoM+xs+hZZEkFPYO36bVaoWnlFHNQ5V1s7kyE8/aT+wQJBm6aHh4OMxo5Hv6+vo0NTUV7C06G5nhnjudTng6Wj6f72oz4+fY3Onp6eAXQfBwDRCutqoMv4Y9JRkLUUy1EFW2+MhUSqN3kVnIdmSVa2VNLJmOr8HsVh6MUCwWVS6Xw1ltt9saHh4OyU7OLPbf+kV2BMTAwEBYo3w+31VljB1At9qHF2DX8TuZZ4XviKzVarWu6mDuF9KMuVbcN/aBRASEFvoYPUOSEWISnScpnD98KeZv4QvYqmP2GH/Rdl7wOZxZSN/5+XkNDw8H3U5SxyYU8PG5PnuGBwYGQsyAPse3tRXBxFXoPQoAsCf7OrxSyrG3wUmpXQgUI9lZlDFKGqPGoEIcN5xSDDnOP5kcMhZkiHA8CZgpd6YlQ1qtLiIAo9oCB8s+HtuSX5KCk03W2M69sN8J4YTzgPPB+zHqGBeMJGXIEDNcHxVCrCWfj0NnSSqMmQ0wWRMyzhg0nOVMJqNyuazR0dHgvFKBQE8794uzR1sZThczfRhGjbNBm4Z1HOr1enDkKGVnLgHtXhhPW46OgbfZ7nK53NUOwzBSArqenp5QfUXwDiFBQIWRjsfjmp6eDg4ickg2lbUhw4RRt+XWOGI4+RCRmUwmDL+ENFxYWFCpVOoKFAkuJAWH3soTARxkINdKVRQZY9t2BZlCWwlrPjAwEFosoihSqVTqIsC4fvbeZg5tVSLOtM3M23MrKVRFsR7cK4FQo9EIMo/s0KI0MzOjUqkUSEh+RuBJcGlJRNtWSHsRj5Lv6enRfvvtp3g83lXCjiMqrVa3LC0taWZmRuVyORDbNrs5Ozur0dHRsO44wFQ12TautcRjOp0O5yWZTIYKBNt+xDVAtuCoc93IBzI0NzcXCNJYLBYqQWwFGiQCwRcEsa2mm5ubU6lUCuQEgZ8lrCB8efz05OSkBgcHQ4VJIpHQpk2bwlPnIEg5c6wZbSYEmLSmNJvNQKjwgAueYMW5JBAmOEZ3Y2cgeDinnU5H69atCy2uEL2WGGQAtrTa5khw3NvbG6qS7Dw7yAH0E+cUeeaMQeANDg52VdbSakzlAjLE/aA3mFVUKBRC+xi6yQ7NpcIhilbmqFAhw3mFQJYUKuEgXJEFiKqZmZlAIqO3LZHAa1QK8nAGro+KJKq3SJBAQFviDnLGzgeDcLXVSDxZjz2zLYsQG5B09iEakI9RFHVVZHGO+D+fhbzG4/HQUpdKpbRhw4auOTr4LthTbDV/bDWhbcUfHR0NyZDp6ekga7aNDlmEvKdlGR2KbVubqLP6uVwuB/sIKYB8YcslqVwuh4ShrYzG92L/rF9EgEuCjrlyVmchu/F4XKOjo+Fscg3Wb7LkMrbcziFCh+NDQjTYChyuvVAoaGZmJswQtOQdpCr+kl1bZAj7RDvy2iThbfkT/N+eW8hLfDCSdyTJ7ANF0EVUeKHDGMi9tqVsaWkpJIGozhkYGFA+n+8iwCFdWq1W6BBYXFzULbfcov322y/4Y9gqiOShoaFANtkKRjoHIInQNehEdKwlg7CbPASASjqbgOD+7Hlh3/CTbAsqewJpavU2ZBIJWNYUkotzjq7AJwF8Dq/R4rphw4agX/F78Q9JalCpy7XhB5CEgbhlH619rlarIRHHPUHKE6Mge8gCVceJRCLILNeObcS3sRWlyD3Xzprty3BSyrG3wUmpXQiMNcoVZxMQhNr5RQSJ1kig1O3TfqxTimND6bQli+LxeJgpUKlUQiAByYRRoE8/nU4H54Ty2GazGf5tsz+U/EurGVyCOKo6IF2q1WpwqnGGcEQI0HA+KRG21WCULVMuTfaNoLxcLoeKJGl1pgdZLAw/2Snr8NKawh6QFcYx4PvYC4IhMvU47OVyOThWkHZUkdjZWThr3B97xuOQ2bPZ2dlgkMvlslKplAYGBgKBYKt4CGZzuVwgI21AjSziXBDgQzgAAnEy/hAHVMxQ5cW+4qwhxzgzkGPIAcFyLLbyqHUCXIhHCKH+/v7wuGTbPsAsLVsdiIO7uLio4eHhkFGFjETekB+qXDg3tkKIz5UUgggy4VTy4NDjbFJpAWklqSuzSbsBBDFPxMLpxEkiWOX8EjAhm8ViMXwnbULMqqGKCKcB+SHoJ4sM6cLMOdt+iqMCSdFutzU7Oxv2DUKI9eKzY7HVx0ajn+wsNRxSW81JBpsnS0H+sGcQzrRbIsO2KoBKJSqzkDVpJeiZmZkJBJStaESf2qwuejabzWp6ejo4+8y44mwQ2LL/EDMQSvzNjKOhoaFAvLEOnc7KjCVkhKoLqsogZJrNZth7SYFUxX7kcrkQgNqZgDapwNlsNpthgDGvc45tZQRBCmuGHCLLtqXRkiPMObJBDNcPsQB5aklz5ICqHM4mugp9iwxkMpkQUNgWo3R6ZcYT+q1SqQQij4AOueTsQeYhb8ViMbSYQ0LQ0sssuFgstlN1CvILsQpJjr6w+m1iYiKQkZY45vMI+K3uQU8MDAyEygR0l21twy5y1tG1VOdgU7E1kId8j9UBa3UIOhB9S9s+dmN5eTlUVXM++vr6Qqu+nSFm2/pYB6quqRSE2EIGqADiWtkf9DKzdVh/KiSpDsSG2YCTc40OJuBttVqhZbZYLIanVkIgoD/wmdb6P/hOVG9AIAwMDIS5ZsgvrbO2Mpmfo7t4qAsVYLbllepb9pLEIkQWckWFrdXFNgBfW33J63zu7OysstmsGo1GIHZYJ/QydptrR9dYws2SoPgg6XQ6tLdSTbQ2KYr8Ip8QtHb2Xr1eD/4lTwOkmpqkkd1/rouqa/zder0efDWbvORpkZB7tvoT+4Ks2icRotOx/5BHyA33xL2yVsgntgida/Uhfp0lZ+kSmJubC/dgbe/AwIBqtVqQV/wuiE1bSW51Bj4rZzmRSHStFUl0kjUkoTm7+Ld2j/EZEolEaLu1CSRiDfQ0RKjVgZDryC82cN26dSHBzblFBvBJqd7GprD++zru7aTUpZdeqkc+8pHhydyOez72fap4NwKligK0mWAMBZlzm43HEBE0QZigqAmoaJXCwSNrzN8ElbRa2fYca4wIFnCEMFYYNTKTxWJRqdTKzB7a4exTbiAWCPrIQkurSo2+dhxWKkjINGHQCYRo0cLIUbZMmT4DMHHUcYBZXwZv41BAoDBUHOOIc8H9Y5QJpC2hhRMDmUBwRvUCQQ8Oka1KApA1vJ89pk1gbdafrDSBFu2Q+Xw+DNSlmoBqNIysrbQiO0mFnG2Bs0O6IRwkBeeWYZ44hzhgZP+iKAqtabaagD0haOHzSqWSNm7cqKGhoZANxBkk05zL5TQ8PKyBgYEw3NYSVgQDZJdxzMmM830QMI1GIwzALZVKWrduXSC8JGlgYEDr1q0LbRwE3KwRTqN11njdZjEtMWwddwgEWx5vg9xWqxXuw2a27R9kUFodaMsZp1WVPSD4txVwkBAExmSi5+bmVKvVNDU1pZmZmZBVJgBgf2w1BcGxJbEt2EcICOQcwozgjYAXXcN3sLcEnJwp29LG8GQcW5sp5jvRdQRIvE5Gnay8fR0dyf/tjBL0mZ11xbWSabcBCE6/tOL80tKTy+WCc1SpVLraGKkA4Hdsiynn3+pYvocgnIBkdHQ0kJIQo4ODg0E20EfDw8PatGlTqEbC3tjKWqpzIb9p16OSCnsDGYNMc/4hFSAMCKDm5+eDblrb6kEShso/ZBMyBn1i55igC9GBfNby8nL4HgJsvhPyEqIJW8M5J8hFrvgsyOSpqSlNT0+Ha7PEB7bIEtLsl7W3kHz2DO6QhrQAAQAASURBVKBHra3lnrg2S7jb9mWCN94jrT55Fr8BksNWTbEHBJTICOcL3VUsFpVOp7V+/fouEsDuDQkMCFlbKQc5wf5yD5bcwNZKq0+fKxaLYa4Pdojvs1XjpVIp7Cu6utlsBiIH3YQMM68Q3cU18X90nSUFqHaFxFheXla5XO5qJUNfU83K+kEK8bvoD2b7sd58Pz+3Ix7QDcgCFbhcC+9DD2K78Zfwb/AtbNXk/Py8qtVqIL+x69beWbIZmbF6mDOFzaENlOQo148soTu4b9pPISe4BvQpCTZbId/b26t8Pt/1oCC7FplMRmNjYyFZZfWOpEBM85nsOfeMTuZMJJNJjYyMhDNNFaBNyNmKQvYYXWQTn7ZykYq15eXlrkHiXBd7iFygTyCM8L+wB8yYJMFtOzdYCzteAj1kk1vcM/fEOV1LIFp/DnIUOSfmoSKOcRzxeFzValXVajX49fgLXCP2zt43cmpJfpvA4Exbfck5xK+9N1VK/SV/dgeWlpZ01FFHKRaLaevWrV0/+9WvfqWHPexhymQy2rhxo9797nff5e+79NJLg4xDnB5++OH693//97v82Y5dA6+U2sUgG0hmwmYqrKK1Pds4wFEUBfLAEio4+yhXjDdBJzM0cEQwRHbOgx0Ci9Gys1e4NsqyCdp7e3u7SrNtEGrL9wmCMPZUVIyMjGh6ejoEpz09PeFa7EBlSA7WhsyRDe7oGbePYrcDPKvVaniail0/7o/MLYYc55zgE6PLPbEmNkOFg0HVFkELjlV/f3+YscF90aLAHhGIW9LQOseQaAyIhXTCGUKZct+sow0A+ZxisRjalnCMkCPIC5th5XfJ9NlqKZw/W6lnM6S26o0Ai7Y91oh9I0AhqLLtC6w/a4tziJPe09MT2hkhWSCPIBBpvaJ6xQY0xWJRlUolZEUhI+xcGUtMcj1cC9UYvb29mpiYCDPAaFmitJwML/uZyWQCibh21gLXTDac6qFarRYCG/aX/9t2HVuJgsNOgBBFUaj+QMbZU0u+2KCAa8Axtm0d/JzPWtsOgFPNwFScRghxiA72lDPG99vAmICir69P1Wo1XAukIbLK73POWBcrq7ZShfOBXmDeSKFQUKVSCcEzASHBE9UMXD/kAHqFs8nrVCGSkZZWqiV4sIVtiyXwQk+RGbY6zla6oDttMDA0NBRsSaFQCO0V6B271wT/rEs6nQ5nCTKYVsJOpxMC/lgsFioUbJUXVay0d0B4JxKJQOhYeYDU5/o5Z9g627YFWcraY1ttKzaywzqiO7kGApNqtdo19xECnjYce2bJ8tuZgHZo+OTkZLCNEFZcK1XCVg4tAUQLFUEU92XtOToJkh1C1H6PbTUjwSUpXCeD763+lFafVsVeobMhiSR1tbxi49hz5Iq9x85CIkDM4xfx+ZBxyAq6nn1HH0K2IoucBZ5ASeULv08wxT4lk8lQWWGTgePj48E/4tyytsgi5xD9zHpZMgr9xLxQu+4kfVgTW+2JLDIbD1uID8LnktSALONakAEIGzuHC5vFmiwtLYX5UKwte8q+2zWzxIf1h+y5s8Qd8oyehiCkWnFubi4kfGgLZT4mOhIZsq/ZZGen0+maY2gJRvbcPmwF/5bzyPlmtASzu7C5i4uLYe4WiQFsBEkCkqacF/QT5Dr21lauo+c4c9gm7pXvR5/a9jfkxZJj6FeeEoqeIH5AzjqdTiD/OLP8wWbYlmtkCb8MXWITpdhk28aMTKIvkU/8SGQaG8+5Rx/yeTbRhU6y1XMksrmnKIrC7DOqsTg3yJO18cQnttXXElf7Mv5SgumuklKPeMQjdPrpp+v000+/w/e97nWv0/r16/XLX/6y6/V6va6TTjpJJ554oj72sY/pmmuu0fOe9zwVi0W98IUvvEvXJknXX3990Af/8z//o5e85CU66KCD9KhHPeouf7bjrmGvpoo/+tGP6v73v3+oFNiyZYu+853vhJ8vLi7qjDPOUKlUUjab1VOf+lRNTEx0fcbNN9+sU045RX19fRoZGdFZZ50Vspp/CWiJscEaGVsUPkQCLSE4ByhnDD6AFCLgxHjYahOcAoyIzczimFrDT3CAwcZxozS3r68vrBuOAFldjCCkDE4i18o9SwrvwfgRKNustTV0GBEydwQE9klnOEu0TNj5Jtwfs0WYOYDDB2lDkEg2D4OJoYQ0YC9sttJmkCEnrCGHuKEywFa3YKRtpZitdGNeBY4dzhDB5fz8vMrlcghUqCLieqwTS4UFn4VDa50RMnN2gDOOA8O0uRfkDSeL13GUcrlcIK4KhULYe0toTE1NaWJiIlQfcV+QcNLqPAO7J1R1Qe5wZtrtlXlbk5OTgbRBxiSpUCiE4a9cA/swOjoaAhAcF7Loa+dKINs45lS5EXAjdwSbVHRJq7NIMplMaA+yJAPnRFJwatkDHGw7uwFyGTmGnOX/BG7M78H5IjCGrKNiT1KoQKKajGw1ATD3wWcQ2PC5ECg2CIfMsdUKyArkPZ+DY4kjC3GG/HHuIGuoQoEI5rvT6bSy2WxYQ867rXqw5z6KovB7NqgmQLVVj1bPNptNTU9PhyqFRqMRKnUg1Qn2aG3qdFaepLV9+3aNj4+Htm3IzNnZ2aDr0QdUiNZqtUD2oRNsJRd7xDDoQqEQ2hogXgk+WB9LhnDP6GhaBpPJZFcbKt/DOg4NDYXkBGtGJQyfyxP00C18F/oVebaVvpyhUqkU2urQW9gMbI6tQuS8sj/lcjnYImtPa7WaKpVKeOrc8vKyJiYmwmfzGnqK4JRziT0nKcQezc/Pq1KpBFvK3iO7yJwNitBVVtZZE1rm0LnYdnwI5IbEE9UCtooa8hlZR6dae0s1JcEza4rtwt5b8nUtgWRHCEAq8D32acL4F5Yks1VX6Dx+n+QE+4Bc4gtQfYc9s35XLBYLA8NtpRBzj9D3+B8kYyyhyfcsLi6G6kZsBnLHQx6oBimXyyExgo9CwpCqqrm5Od1yyy1hAP22bdsCWQRRzPVBztBWS7UvdhhdYKtvkHvri+FDkNzgjPIH+0UFFmvI9SNnyLP1a/mbpCZnEDKaFu6enp7wEB3OAsQLhBNyYquHuAfskiUQ8RnRIVQrceYg7blHmxy0rbHYBc4ZOg15RkaQP/wkqiFrtVpXtaf1AyGqeT97bckxqiM5m1YWLdm9tLTylNXp6ekwGN+2QaM7LFFIVTv6FbKHB2Vwr8gP14GvzJpUKpVwLtBFVL8y8J1rxl+wCb52ux2G1pPkIsmBTNpzb/0gu0/4vdyvbQHmbFrfy87lYt0dew7f+c539L3vfU/vec97dvrZ+eefr+XlZX3qU5/S4Ycfrr//+7/Xy1/+cr33ve+9w8/89re/rfve977q7e3VIx/5SP3pT3+6zfeNjIxobGxMBxxwgF7+8pfrgAMO0C9+8YtdcVuOu4i9ulJqw4YNeuc736mDDz5YURTps5/9rJ74xCfq6quv1uGHH65XvepV+ta3vqULL7xQhUJBZ555pp7ylKfosssuk7SiHE855RSNjY3p//2//6cdO3boOc95jpLJpN7xjnf8RdeEQ0tAa6tRMKQYKrILtO5hpGx5PhUyNsOF4sW4EEig6G1lgqSugMNWYWHw+bkNHCCgZmdng4GTFDKf1khLq48mthUzZJl54gVZEQwZWRbuieuzpKCtACIrCmz1GFkhHBEcBq6L6yUgnpycDEQcxokKEEuQkWHC0cIY47DyGoTA2oASGcBZstUt3KeVE1udRECI04WjaQkinkBGaTOOIWtFlov1t1lN226GvOKQEjByzZZUxKmgms1mk8nYYfht5V2lUlGtVgvOFY6xzeSylmQFyWrRhmDbNcjYk/GgMod752k+tImxPmsH7UNI8dk4+jao4T7tvCqCd6qu7NnDocvlcl3zQyBIIVDJ2JPxo3oRnWHPMJ9hyRLkhXYJyDSuk/NGkMzaM7zf7qt14iC9kDXOBIGwdTJxQJEDBj2jg7gnS8BRNSCtEhw4lawj8orDTbbTVhPYiiHOuSWWbMk/98O5yOVyIdBqtVph7hwkC8EXeoR14toh09rtlYGtURQFUhnCAvLMElm0SUoK1wjZgqzycwJw9IklzmwAuHb/WG/OEfJAUAvJC2mB/mf/CM6551hs9Wl+yDQZfvaD85PJZAIpTSAAaY5eabfbYb4Yep8zYYM0zinrjE7kOm3bmj0nnFlIFYgdqpeogqISqdlshkoy2lepxsNGUpVCmw6ts+hkdD97xrqhz5F99g/SiGpk7Cz7hf20Z98G2vgFnE+IGfvkPWwn94qPYium0PO2upM5UpDI8XhctVotEJv8Pv4CthgSmkoUzhaBKmeWSs+1LYnIEYElgTOJJq6RIJ97I0Al+QKhsjZ4lhTIKQi94eHhoFep6EF/29Yt1gsCaGlpKTzcABuGXZ6eng7rhO7hM7HJkPl21iMJK0gf9BdrhZ/DzDH2EjmE+ME3YeYW1wEJgCxyRtE5ltRC5u38PXtm0X8QBrbaDz1AlRR+pG0jhejkfHIv1udhD6wfyGezJ/gjdCjYyh58bqtDIVDZS2Qd2aXSlO+k+qpYLIY9RudDsFq/EztgZZ5rhRTkXvhOOiT4DObZ2fukEwE9CEHFOUXXsG5Ut9PWiF5kj7B1yB5nh7VAD5P85bzxnTbJauWX+yBRhB4jwW0JZ2SQM89ZIT6xyXNJwZcgkWkJQOw6BKQlNpEB+0CTu1oNtDfgrlZK4RMBWzxxVzAxMaEXvOAF+sY3vhFk0+Lyyy/Xwx/+8LDvknTyySfrXe96V5gjuRbbtm3TU57yFJ1xxhl64QtfqJ/97Gd6zWtec4fXEUWRvvvd7+rmm2/Wcccdd5fvy3HXsVeTUo9//OO7/v/2t79dH/3oR3XFFVdow4YN+uQnP6kLLrhAf/3Xfy1J+vSnP63DDjtMV1xxhR7ykIfoe9/7nq699lp9//vf1+joqI466iide+65ev3rX6+3vOUtXQfizgKljHLHYbKKF4VO1rjT6YTsmyVEeHrG2gwB/ydAwXCSuSag471WkSwvLyufz3eVPtvPJxi2zgwOS6PR6CIPbFWDLaHFmCaTSU1OTgYnxpZdk1GhzDsWW217sc4pn0cw3d/fHxx1ghIb1BAMYCRrtVoIjGkdstl0HHACEQIg1tZWU5CN4355xDpDqiGS7JBMS2QRqNrKIwgA9mZmZibsFeTe2qHGOF47duzQ4uKiNm/e3BW4YLCZcRKLxUJwTNbTEhbJZDKQnzgSDI1sNBrh8bvxeDwE8jx1DPKCvSUgp0IM8s7O77DEJFUuOH4EtmTf7AwgOyODvY/H46FFEJIGh5R9IkDBQcQxxnnq6+sLc2GoFrOVEDjnBC7sFQ4oa9Db26vp6emuijocY7t3yBDBAdeKjEGyFAqFQHBCPNgAFGcMx461ttV+OIAE53bgMc6ZnVfF2VvbzsP64tjz9EUcVAJLzjI6Cf0GsYmc4dhzZrgv1ho9yJmem5sLOhRinEd7Iw+Sutpk0CGsLw8zYA1sdQDtG7FYLOhczi8kvSVKqVZgr9FzBHg8kp32NILqRqPRtQeQnhB5BK7IG3vLehC8QKImk0mVSiUNDQ0FooeAiECYSgG+izVEb7Kutm1taGgoVAdZvVUqlcL8Mv7mmpBvnEz0DGeVYBlCGxLOkhvoRPam0WiEdbG2DBlB7/T29oa1pgoC28L3ok/YD3QsZMXAwEBI/Fh5spW8kPfSKik6ODgY2qR4QAWkOToGIpcKHiofIJfYU2wjBCprDyFjdQQBWSaTCfYUopJ2ZSoAbSsi1dCW+LFEEHvOHkD2o6PYHwhNS5Qic9hsyLre3pWnqg0ODqperwcCwg7MZo35LEsAQBa2Wq1ABCUSiTBbzv4eugpi3BL49j3YJGbsQfRQxUxliK0wZs+azWaosmPgsyXdsftULrL/EAmQaOw3ZANPI8Mn4HdpX4Lww8ezPpcNxrlGS8CwfsgwOpK1wieAAKPdnaelUjWLHGLPqW7hu9Gb8Xi866EBURSFofLYtFwuF9YZew6BxJMpIeqo+KeFEjI9Hl99IAM+Dj4cvoM9v+iupaWlkHjlzELkcraRH3QP/hpnk6cdEiRj85EVa4M4Z9bPxu+ECEIvoA/YB2TEEj74pp1OJ/hpliwmfkGuIZnw0azfbkmznp6eMGeQn1vZHx0dDf6l3TM+h/PFPePrci8kHFg7fDTkm/VBFm1MYKsGkWHr6/B9rDt7yp4Rv0irTyrcl3FXSamNGzd2vX7OOefoLW95y12+ptNPP10vfvGLdcwxx9xmNdP4+LgOOOCArtdGR0fDz26LlProRz+qgw46SP/6r/8qSTrkkEN0zTXX6F3vetdO792wYYMkBf/grW99qx7+8Iffpfty7Brs1aSURbvd1oUXXqi5uTlt2bJFP//5z9VsNnXiiSeG9xx66KHatGmTLr/8cj3kIQ/R5ZdfriOPPDIIu7TCxr7kJS/Rb37zGz3wgQ+8ze+iPBhYNhkDZDPwNltsy2txMFHwOJjWqJMdY64Kxh+nDwJBUhi0i6FYmzHgc8kE8TsQUDZjS8Ymk8locHAwOEezs7OBBLCPfcbh5x5xvilnJyjAYOAYcU+WzLMDtm3vexStPIqX8meqYvhMHCsMEMaPgDiRSISAlXkmvM8SiRBWEBk4s7aSgwySJTBwXiCTbCbYkoRUndnZGOwZvzM7OxuILsg4CET2fm5uLjyeHieKYApj3tvbq5mZmdB2giOL42yHrtsKIYgTnF9bVcWTHO1eQ0RYEgwnwJIhZOK5P2Yp8IQ5Poe1Zwjx0NBQyLbayon5+fkgn7adTFpt9+CMUdlEJpWzg/zbKiBkEgcGZ95W41h5wcHl/fV6PbSIsG+07NZqtUDC2dYi1k1arW6ExOH88X7IHEvC2Gvk+zijrIutIEQX2SoiSJZ8Ph9mgHDGcAD5bAIJ1oCglkBWUthfZu6QdeX82aoNzilOMIFZPB4PGU7OIIGNDRyoMuE6bYANKZVMJsMMECrMcIYtYUpADGFhA0UI1XQ6rVwup7m5Oc3MzGhoaCi02hL0EODQisjn2nvm/7lcLjyUgBYV7pmnd60lNKhWgqi5+eabg2yhX2u1WqgAIRC11biQX9gvKqVYD9aQKinkmaDenhXuhTYUK1cQ+AwUZtYbbcJW7yaTq4P0baabpAPJEvQrJAm2wAZF2GGqSFg7bAzfMT09HaoB+H50PAReOp0OT0rl3mg9mZqaCpUc2AhIMGwz5xS5sJU99ufItk362AQXJA73wv0gxxCM2DzadpiBgzzxGfwewSwVMMxQk1ZaQ23Q2+l0AhmGTkJ+LJHY09MTziuygE9kiTOIVkv6Ud3GGSYxQcUEa9PpdLoqVmyFI+vI+tjX0WU22Oc9Vo9wnubm5sLa1Wq18KTLSqUSWuo4E1wvZAwPaUEfWn8Rv4dKGtt6x3XZGVMktmwFGPaNc2KfkoZNx6fkLPb0rFTgz8/Pd9kvbMPy8rKq1WrQbdg+/CWbcMEG85RRSwgnk8mQyEKfSupK1qz9XHQUa0MrK2SYnW+JLsTXoJUMPWHbb23ihdl+pVIp6HLGByA3rIlNZsZiseAH0xJqiX9IVZ6obG0IlV74RnY2lPVTmKMYi8W6Bsez38gtPp3V4zZhDWldKpU0OTkZYgRkj/2GPKe1slAohCfbIqOcPWILzgh7yH2zDySxisVi8Lnq9XpXUq/ZbIYWZOTJVlHhz7F+fAbXzBldKwvsEwkYkhbEXcyo3JdxV0mpbdu2hbEakm63Suod73hHV3fRwsKCrrjiCp155pnhtWuvvVabNm3SBz/4QTUaDZ199tl/9nXdEX7729/uVO20ZcuW23zvj3/841CMcNVVV+nMM8/U4OCgXvKSl+zSa3L8+djrSalrrrlGW7Zs0eLiorLZrL7+9a/rfve7n7Zu3apUKrXTYyBHR0c1Pj4uaYVxtYQUP+dnt4fzzjtP//zP/3ybP0PpEXxhfHAKcL7J/mHECPw59BgY3rO2/972bOOI4+ziBEAkYMSoBMLIko1AuVulb4MVMigYMHrkCWqsgbF/cIJwAG2mmvu2zqKtKOIaycRJCkEh1Sa2j59ZQ9yXdTqbzaYqlUpYL4wYa0PWDUfbOujS6pBdgkqqdgg8MMY4ohBMOJA2K0kQQBaM18nWZbNZTU5OSlIXscn7+Ox0Oq2hoaGw/5BIZPzIIrfbbdXr9RAMY7y5FrunNuvIzwjipdXWVKrOWDucLpu9JwjGubJl6ZBHZABpV7DDoHGEbJCFnNuMaKVS6aoctPMscPSWlpZCJpzAieCMcn7aemy2kLXB2eG6cJ4ghaxjxL0QrBGY8hrzH3DOuW9k3RIFXAvXYAN2gqlKpRJkCUfd6g+IbgIaW7FiCVNbYQEBxPmyARKyj16ybUScVVuFidMtKfwODidnkDYUzi+yx8+ptoDAsi0XVIixBpwBu57sj61EZd4G68/183AB9JGtduOP/Xx+1ul0woB0iGAIPnSllSnum/0h0ERuksmkisViqMbE2bdPK2RfOO+QCFQg2PVDjggUmLHBNVj9SiYa8g85oEUI4oazDgHJ+URn2oHD6FDODlUGmUxG09PTIRDloQEQFZAgyAy62p4Vgu7BwcGuOWWcF76Xx4Gju/gckjS0YDYaja7WItYbwogWH8gq9gvbxD5h862cYBOQs7W6EXuBHOMbQBRhs9GT+AGWXEMXsP8EurYydy0xBxGDnLXb7VCRMzU1pWKxqIGBgdAihg9i7SPni4dLoFOoNsxkMqpWq4F8I0iESLFPf8UHQN/iXxCo4ifZ6hGq8NCdPGGQ9Umn00EXY1fs04xtBTbJJ0v82WuBeGXOoa0QbTQaYQ+pgEfvcw6x59wvhBbXOjMzowMPPDDIP8SrTaCxx+wza5ZMJkMVIz4gOotkD/cBeYT/wr1xJmylIucIfWmHR+MHtdvtQMRwPyRG0J34IpwpOzOU62cP8C2wD5lMRrVaLRB4JO2wWbaS0BLv+Jtc7/z8fHgqoK3CsfJERSAVwZaUsn4ilUjW9rAmJOHYZxJN6A3uDbsK4Skp2DNkAnuLTUMf8Df+G++HBGIf7Fm3BCPtcFSZU/lqfR/OH9+B/8V7bFITvcDeWJKI+7IVT9h/5qQykgE/BztC+yiJD+y0HQ9hfRCSeLYowBJf3OO+jLtKSjGv+f/Ci1/8Yj3taU8L/3/mM5+ppz71qXrKU54SXlu/fr0k6Yc//KEuv/zynQiuY445Rs985jP12c9+VmNjYzvNf+b/Y2Njf/b9rMUBBxwQuIHDDz9cV155pd7+9rc7KXUPwF5PSh1yyCHaunWrarWavvrVr+q0007Tj370o7v1O88++2y9+tWvDv+v1+uhzBEFjyNmW1EwJDZDSxWRrVLA4e/t7VWlUgmPqSdwxoHEmUWxk+UgiLAlrjgytmULpwvH1ZIaOCCSQraGIcwQTmTWqA7gnqyhkRRINdbGZrjsLAtew3DguGSz2VDyTlBFdYOdG8LakE3DGaGKwrYb2r9xQGmRsBlS68yxv3ymLQu3FTXWYbTOCU6ApK4y9GQyqUqlor6+Pg0ODoZghP222WNbpQPxaInFnp6erpkM09PTYU0JgLhWmzm2Tg3EKfeHPEFWsT+8j3vCeZbUNUcsilbbRvgsHqdsW3/4fVvdQPCO00m23ZKLzHgZHBzsymRa4g9ZbDQaXUPm+R4qHpCzTCYTHGVLYiITOH2Qgb29vdq+fXsIMOww0lqtFs6KLZ+vVqshKMNBtbNkqJTjWtcSPpBtPBXNEgXIJw4kLbicKWZ72WovBloTqLCWkGjIFESHJSCRCwIvqsAIxq3jT1uVbX/jfFhH0erNgYGBLjIEPUprK0/moTqAII3KA6oP2TvIHSqJmIGEvmSNyYLj3JNwsIQ8BCMysWPHDjUaDa1fvz4EqcwNsyQzARotrNxvsVgMjiDZfPSbrVRBt1pdUyqVAgGZTCZDixwz9BYXF7uqIEl8EOxICg49s+qovCIwJWCdmppSqVQKOpjPwJ5Q9clZYL2RJYJYvkdabdfEflAhhf6yCQ7WAF0EyUCAgzxyr5w7AjGbdLCDlDlnJACQbchw9iKVSqlQKIRqKp52aGeCYTeQFa6HRBXEFfcDKUxAxvWiEyEUbdUe54f/Mx+Gz0AeqGDEl4CAwK6hU1l/9DwkXbVaDYQDNh2i0FblQBIwLD+RSKhWq6lcLgdiGnmnmtXaJM40VTz4CXw+97+0tKRqtapcLheqPGy7rK0EpbqW67LVZdgK9pYguNNZnVNpZRG9BgEzMjIS3j87O6sdO3aEWT5UgVhbg8yh40io2WQK+0eSgf3l7Ni2qXg8HqqvOavMdmTtsAesJ3beEu+cbWwED8qgupg5a7zf+nm0cQN0FQQWCRubLOP+IJDxMam0sXvCflI9h12DWMZ/skkP7pHXuC7OM6MBJIWqGeSSJDG+IwQesmXbYmdnZ4Oc4FNxfZLCjDfskU1CoNvwcTindgQB5401isfj4RxCiJGUkFaTA8iGpK6EHIQ6685Z4734CTYZzVra0RZWTyPLVtfbNlVsNq+RrKBa2dpPqoql7ieDQmSjd3nK9dqKdkuYWdtIFaP1ZR27BoODgxocHAz/7+3t1cjIiO5zn/vs9N5/+7d/09ve9rbw/+3bt+vkk0/Wl7/85VDptGXLFr3xjW8M5LAkXXzxxTrkkENus3VPkg477DD993//d9drV1xxxZ26fuJnx57HXk9KpVKpIPhHH320fvrTn+oDH/iAnv70p4fSY1stNTExEZjWsbExXXXVVV2fd2fY2Dsa9obzisMjrTqOOC5cN8EIQQLBBs4rLRkEgQRABExrS+4JJAm07HBVSnJtVg6nAEePIAVjSmUTxpnsmw3WuFdL+GCsqBKgqghjxnfYJwJhODCOkEGLi4uhzFJardbo7e0NWUr+tkEXs4EsicN3cG0QSFSJWcfQXg8EHutjq6MwejbrbZ1hsq88spjMfaVSCXvY398f9srOl4HU5LtZa64NR5P5KVw/BOfExEQIPvheZIjADAfUVnc1Go0QWOEckpHj/qyji9OAI4VDYKtU2Bs7l2Ft9o0gzLYnWKIrm82G2U+0zxSLxfBoZoJ+5BNHCseG84gMUJlDZt8GMtLq0+ZsCxf7QOBlHeDZ2dmuLDsyiAMHUUNlEdfGdXBOcOi4FzL1VoYhftAhrDH7S7YUJxACiWoEW6m5Nvi12V7armhxRP8lEitDvHH2cHLJZOKs2oCZCsdSqdRFUiB/tkIP2bSEWSwWC22e6EMqZVKpVJjrgpOMTLGmtjrEkln2AQ9khXH0OX840pBcrOHaACCRSIS5cLaqgkALMi2Xy4U/ZLeZj0VAwJqRSEAebHUMQRTnz1bBMseFJ1tia2yrjK2wIAikqiafzwdZ59x2Op0Q1BCoWx1LVRf3BcHOtSNr6G9mMeVyOU1MTIQ9XKsH2Av0JXvG9dGuxFoz+87OLrQBkm2hs21iyB3nlT20BApylc1mg8yg75BZrhkdHo/HVS6Xwzm1a2Z1AfeOvNmkB9dvK4Ns0GYrjGzFCbMB7aw0bCPn3BL31Wo1EOvoGdrTsFnoU3QmQTnfy95bEpVkEhVEPLHO2jOu3SaNmG/IPkFkYp/RnzzlzVahQvCk02nNzMyEvcQvwyYi71ZHYAO4HluthP9gCS0II8gem1jhDCNb7CH/bzabQZfH43GNjY2F+7A+C7LPOaYdzZJ96FGSUxCfJJrYN/wpdCWv8TmZTEZDQ0MhsdXf369bbrklrAVniTWya846QRpB9tkHo3BPyD22BbLTEhZ27yHS0Sf4Xsgk77X+jq0WorKtWq2G66Nq2tpCkkoQojxVE91gCSNL5PMkSWsb8BvxJTirfI9NJtmKVeagWiLdtsBSWdVqtUJ1IuNF+vv7Va1Wg5yhtywRaGMO1o+5iLayEzIdGeGc2gpsXrcVUDZpTDKbteFzScCxrpx1rhcfQFJXazT732g0QoxnzyZ61xJutP6t9fX2VdzVSqm7A5s2ber6PzJ80EEHhVlPp556qv75n/9Zz3/+8/X6179ev/71r/WBD3xA73vf+273c1/84hfrX//1X3XWWWfpH/7hH/Tzn/9cn/nMZ27zvZOTk6GS76qrrtLnP/95/e3f/u2uuUHHXcI+dyrJDB199NFKJpP6wQ9+oKc+9amSpOuvv14333xz6DPdsmWL3v72t2tycjJUblx88cXK5/O63/3u92d/tw1kGLKNAZdWHyNtA00CaOvs4tzjENqWBWm1jQrHFaNGYGKvh/cVi8XgwI2MjAQDRICJE9nT06PJycmQiZRWHAV6vsmYlUqlrhYcm6Gw5b0EPpAmVADZjDXOm70nPgOHitJeSaHcn95/HFSqjyDIuEdaEWxWFMeHPcAw2soDm/linbjGvr6+EBDgBBSLRY2Pj3cN+sUJwBm3ZA7OciKR0ODgoJrNZpj/srS0FDIPkBy2HB4jj8zbagaeBodjye/jAOEYMq8ol8upXq+HtUBucNZ5zbaESquOIkQGZw+n2xI6DE622W/rlOHEcH+WDMRxhYRBRmm9yOVywdGybScYHQIOgmNL5CYSCZXLZRUKhRBYQJAgR6w9JAvXQ8UhlQ7ZbFblcllRtPLkP7Kig4ODGhoaCoQClUvM5iLAgGwjYGS+lM1M23OSzWbDdVPNwL4QHDH42lY30O5mgy3WGlknQwxZt7biku9hzQiy1gbPBDut1urTcpBXW7lHUGwDHO6BoAKH1maXrZ5ZS/ZZOYWI4vuY98E5YC/5bkti2aAQRxzdBAksKcxZQ7ewl/l8PpC9y8vLKhaLKpVKQR7ZG2yAJZgghQmwrH7nGtFd0mqwkE6nNT09HcihwcFBTU1NBcIJsLf8HmeQ4JDghXtiflWj0QhVUhDqURSFwA69xuwfBpFzrQQatMQRnHNfEOz2iVmW+MI+osOo4oDoxNYQgCaTSRUKhfC9s7OzqlarYS5YLBbTtm3butrOeNCAJZexh+gY7BJ7aBMVVMugOwmkIXoJjKy9sxWx0krGmUpkSyjYqh5IGa6Jlj+bcCI5QmUMupv15t8QUbxndnY2yBD6H5lGl9kHMUBIQiLz2b29vaHdvFKpBBtnA2BIMchmfBh8C9q9SfYMDQ1JUpADmzyQFM4ba0SVGX4YewKxSFXS9PR0kAOuBV2ArBL08tmdTiecf7teBOackd7e3iBvkGP8rF6vhxljVJeiG0loYYux+5Y0Q/6QKew6CQRIZggE5JB7wc5xZpEprofzupaEwh8imTI7OxtmbdnrhbRlL1utlTlvlUolkFD4cehO/CXsD3LGOcenKhQKwVfimvGzIHDwP2zATWKUM85+MpgfXYZdoRKoUCiEamN0L34f68W6UiGO/UaWsGv43tVqNeh45N62MpN4YU4qJDM6jT1Ex3Bd2Ftasa2dp0KLSjtsDfuFHZ+dnQ2D1NFFnG1b2QVphI7udDqh1Z5KdNpoh4aGAlFvzxJ/sAesp6SQXMG3w1eFcLUkJz+zlY/Ly8tBPvnMfRn3RFLqzqBQKOh73/uezjjjDB199NEaGhrSm9/8Zr3whS+83d/ZtGmT/vM//1OvetWr9MEPflAPfvCD9Y53vEPPe97zdnrvIYccImlFX2zcuFEvetGL9Ja7OMDdsWuwV5NSZ599th7zmMdo06ZNajQauuCCC3TppZfqu9/9rgqFgp7//Ofr1a9+tQYHB5XP5/Wyl71MW7Zs0UMe8hBJ0kknnaT73e9+evazn613v/vdGh8f15ve9CadccYZt1sJdUewgR5OCgYCYNxwnJaWloITiSEi8KOlyLZKkT3E6bdzh5iVgSNARhzFRLBMmxNBKkaFUkkqrqxRtC04GETaz2xGzxINODAQI7R0VSqVrmoqnAKcaIyHpJCJwXnFEPHEG5xLSvO5/0wmEwIoMnaVSkWzs7PhiTI4UslkMsyDwZlh/TBo3DsOgyU1IGWoSrAOCcEwTqgtJS4UCioUCmH9e3pWWiHr9boGBgaCo44jjsG1lR/SajBIJQlGd2hoqGtWAJlz2x7Qaq3MirFtPVRCkJmlggOnwZJ1NlCyWXxLOFoS0LYPkFGjFN22IpCZo+3CEii9vb0qlUqqVCohELCyieNrnR0yqay/pJCBxwnHYbeVQtwX54Of4VCyPzj0yDrrPDw8HKq5kFs+S+oeXM19cH22LB4iRlKQWdtmw7XaGVmcx3q9HgJAfp91Ym05e6wzLUAQPOwZe8BZsxVua8leSeG6Cd6TyWQYbI1DzBnj89dm7zmHEJ/oN2aA2OoGfg5pZCtiyLBbEq5SqXQ9BADdAUnAevF3IpEIlZu2gsYGqxCSVO5QGQJxbLP6llArFouBNKNVhPuwFbV2n7AT6B7IxGw2GyqkaFOxLRHIla3GgwTkrPP9kD6QLOgFSB6bmIBAgHgl2OMcWhKO9aHyIxaLaWBgIAzUplKA/eL8MrCdDL3Vx5Aktgp1eXlZExMTKhaLgcxFpjiTBO2Dg4OhpRKC2lb+IGNUtxL4oo8hW6g0guyzMgnpyM8toUpVxPz8fCC0bKBqK4YsKcHfBKY24UEVBbJmq0GsruIJX5Z04JzY2YAE+oBr44xYooIzL60ElDydlMSDDaatXNqgnUoYyAbI+MHBwUDc23tij5A39oh7hYixvhhyTGUJZ97Kt61K5L4soVer1YJdt4kgrgkd3263w3tYB0sGo7NHRkYC4QBJSyUIMoxfBukCKcP94QuQuLF6CzuG7kOu+vr6lM/nu+QSXYA+43fxz/iD3qN10Va82GSqlReq+JLJZHjwytzcXNALnB8IbK6Bymnkxq4l55FzYB+eY6sMkUFsCb+PjcM3hxCEKFt75qngTSQSXa2U/EGebKWcrTTHj0Dm1yZmbLsmOgBfxLYP8rmSQusl8k1bZ6PR6LIHnHeIbGQR31JSODecDQhIfHWIbBtr2CerUgmIXefftsrUEu2cXSuDksITL21cQazGWbYJKXwyEoz23v+SGG9vxJ4gmC699NI7/d7999//Nq/x/ve/v3784x//Wd/7uMc9To973OO6Xnvuc58b/v2IRzxijxNujjvGXk1KTU5O6jnPeY527NihQqGg+9///vrud7+rRz/60ZKk973vferp6dFTn/pULS0t6eSTT9ZHPvKR8PvxeFzf/OY39ZKXvERbtmxRf3+/TjvtNL31rW/9i64HQ0FAYQ0ETop1wnBsyNDE4/FQtWEDYxwGFDfGjMNFmTaGCScbZ0paDcAhqlDmOE7xeDy0O0gK91AsFkO7QSKRCA6ODagoy8ahI6OE0SIwwBmF+CKot8E1QSSBDO1GtEosLCyoWCwG8oc2DQg6DCzOIVlKetHJJmP8bUDJ2rEm7EssFuuqnMHxImtPtj2KIg0MDITqNQgyu284F1wHhpd5YFwHjidPh8G4s1cYZF7j3/F4PFQF5fP5MHPDkpBktZBZ7hc5JRPNdzE/xcozzoStrMGhxZFndoStOoOA4VHRBMFWHgnsbOUdT2aTVpyPbDar7du3B0cD55JqIYbs0zbJvvGEM75r7dpCZlonHLKK4AhSiEoO5qvh9BHwJhIJDQ0NhTYV2miXlpY0PT2tdrsd5sXhcNPiZ+eWQGTRGmUzprbVjGCU9i4cQeSQtYNAhWSD+GYNkUdkhipLHL5kMhmqhaTV2XY4jsg6jqcNNpPJZKhQkRQIXfQG8mFL+NE9tGlCxNgZQ5YQsM6xtNpuSFBpq2ogaCF2LHlnz6c9ZxChBNu04tpWLgZ2U21DayYki10vrq1UKmlmZiZ8nyVbIXTR6ewNlTCQF1TncT0Qcehfa3ssEYXepfKUoNG2VVj54TsgVmxbIyQRQY8NwCC5sVFUOLButGET0EL8I2OcAeSGSkPkhwpDCG2CsOXlZc3MzISnQFFJggy3222NjIyEtnoCeGk1IEN27O9ghyB/rJwzo5BgC7sjrT51DDmkepE5K6wf98r3ETBLCuQk5xIfAj1IImctecWZsnqMCinsDtcXj8c1NDTUZZ/xPbDfawNJ9Do62+osdLklhSD9IfftmUcmqXqjZYknzhKw4gPYIBSCARvK+cFPQP+h7xhXwHVZ4oTPkhQqVahQ45wsLS0pl8sFEgQCliQe88L4DHwA5LZYLKrRaARyH/KyUCh0VZP19PQEws9+FgE3ugAfi/20rePsPTaPai3I52w2G96P/Nk5cOwNCUHkjz2CwMGfsEmzUqkUzm8ikQhDrW27G3aE74Zgs0OsSYzaira1lbK2ktpW+dTr9VDFA9mMjibJYStKbbIYW8ugdJ4ITTUR+h4/GCKJNef8WHIZ/Yyt4vwhd5BWtkURwmx2drYrGWCvGVni87E3rA/3hCxTtY7fiD60MQK2levGRtExwDVzH8gifoZ92Aw2jGouu+eW8F9YWOjSS5xdq88swbyW7Me245eig/d17K2VUo57L/ZqUuqTn/zkHf48k8nowx/+sD784Q/f7ns2b96sb3/727vkeggicaKoiCCzIK0Ol4YAsVkNHFebpcSwrM34SatPvUA547TTKmYrl+bm5oLzSrBtrxvnAQO3sLCgkZER5fP5MLB6eHg4lOWTfcexwWHhKTPSysDeyclJJRIrLVLcB0GodRwgrBjujcGGOCLTNTg4GAgXnDOCVAJMnCM7UBLHj+w8gSDOE4EA2WBae6TVYIAAzZaWUw1AkMNcgcXFxfCUGPbUkg8YeObypNPpUCFFlp1r2b59ewjSIJaoHGH/CELt3I9WqxVmIkBE4DDgfNuAnkHXtODQXoas0CZm5QqHnmAlm83e5myP5eWVp7owA4wZAGSHuRecNYItScHpZa8IQPnOcrkcqpG4nnQ6rcHBwUCEUfnD3BAcZ2l1+PnataSUHceHNbWVavyMNoC1FSk2K8h5scEmlSzSKhHMzzkj3LetkoMEqNVqwanDWSY4opKMc29by6g2QWb4XmSOQGVxcTEMvLWVC8g6GWSrn7h3Ak6ca0izRqMRAlb0kXVebRsJZ5HsOXsG8SkpPDVtYGAgyDhyx1lAjpAx9KStJiPoI4AiULIEIMPlIUNLpVLI2rOu7CP6FN1MoLl2YHs+n++atVGr1bRhw4YQJKEnIYHYZ8hiHHdkmVZRqhCSyWSQ/2q1Gs4WRDs2iM9Cfq2sQ2ST3BgZGQkD39FlttJ0LRGCHqeiCRlBJpGH5eXlsBfoPNrP7P7Z6rV6vR7ISoJrAjDuDXmt1+uqVquhQtW2PkLOFIvFQMJg0wm2qCrku0qlUtCNNnkzMzPTdQ5isdX5aTwd0FbCUYWKbbFzpyAyrfxwpmzlxVo/hLWzJA/rY5M3JFGazaay2WwgOGwLpg3K0WPoO9YDotOukSWt8It4eh/3aSsiOasEmewLCah8Ph+q60ge9PT0hAHn2Gib2IK0sFVVkGSQHQSsEGiJRKJrTqatoIQEhWxkXaIoCmQRfgl7lcvlNDg4qPn5eTUaDc3Pz6tSqYR2JHQqOotWMPaV9cYvQR9AVqGfICcgRoaGhtTb26t6vR6GsFPBwnpZgsDqbYhZa+M5z5BrkkL7pq0iQ4eyt/V6PVRfIe/oLe5bWq2O5fPxF9EhtH7hy3HueJ8F9gGdbitpaB1DlrCfnGV7fxBzrLn1Te19Li0thaQys1hJOiFT+IF8X7PZDIlgOjrsU+Pwj1jDbDYbCCSbdOGasaPWn4IctVVJ1pbjT1r5oaLdJtLZH84KdpQzxb7hC5fL5XC9NjGGD4wewX8nWct3oGuo0kZfQIYRt0BWotesX4b/wHs516lUKuiDfRlOSjn2NuzVpNQ9DTiD1pm07D+KnYyrzVaitMnSk+klk2UzwShpHCscH0nBwKPc+SyqhnCyyLxQaSEpzC3BAeMpB1QGrB04i6InqLQkELN0CEIwGhggMnKSQosdjgqOD59F1QCOEg4MwTzBGU4ThBTEhW1BYnA6jvL27dvDmttsGo4TAQQZOvaXgDmKovBIc1u+bjPcZHVo7+zpWWnPYf3JVDHLgiwzlTQbN27sctohZgjeGHReLBa7Km0wxvF4XDMzM8FxoCLFVoNls9mukm2uaXJyMmR4Ke2enZ3tesIXWWKukSCca5UUKol4wiDnhYo2yBS+H0eQ4J1rIsBGDnO5XHi0vK2SKBQKgdzDUYHExPmGHMDx4RwSROJocz5wpHCMFhcXQ0aZ9bVnmf22+8Z8GFudxjyoZrMZAiU7AHTtOSUYouWuUCiEM0VwC2FYLpeDY0lQRVUalYMEKLQ20QoLqWGrOzlX9uxTuWer6JAtS7pzBq3DbCt/7EwlSDgceOSdlmaCaJ7WRJWmtNqSgk5gnwi4aC+BCIEcQu74DII2ZJo2Kq4fEr1UKqlcLoeADDLFkuVk6wn4CBIseQLZhXwjRxBHEBn8DrJKcDA4OBgIclpPILo5q1QZIEPsNRnwfD7fVTVlCaW152F6elqFQiHsl61aI8jodDqBLGbPIQmwOfZ8ElAjh5AP/C6EHPoD+adFGdsEacg6s9edTic8LIEniWETarWaJAWCDYKWNeU+aW+GkKQqlrZOW8lGkM1e2zYgKgZoJ6eSmTNhq1oSiUSoCrZtOlRDkgwB1leg+op1iaIoDGTGZksrM3HYY2w4ZIjVn+gMzoS101J3e06j0QjyR1VxtVpVqVQKZEY+n+8KdLlGZBAdb4fj20pa9BHAVyIpyH1jay2Rw+u2ugpZsXocucIuYjOQ61gsFlry0HHoD67T+jfN5sr8SNvSis4gMYe9YU8gDNDvNsmEDmFf7Pwy9pZWPptcgcSDQCQhWavVNDo6GtaRdWWPrS0gmcA1SArfD+ELscyoACoWZ2dnw++hZ20bMMQk+8A90iJrkxucN5JJ9pyxhjaJS/UkPgZ6fWZmJpD/JDgsqcHao28gxwjkkd3+/n719fV1Ddi3sgjJhn6nSt8+BYwkju2m4MxxBiSFSihrM1kn7pvPADbRxb5ThY59wx4g71wre4S957NYQ8hqm7i2iejZ2VkNDw+H62WtaLHGblqym2Qpr7HWtkqXamT2AF1uic3Z2dlwrw6H454FJ6V2MVDykoIRw5B1Op2uklWCTlvxg/PAU1ZsNYzNYllDbLPD/B7OOxkegpl4PB4GRONQEOxQ6dBsNlUqldTT06OZmZnQbmPLZAk8GTZO0GnLuyEycO5YA1vRxGeyXhgY1oxr5pHmBK2U5VcqlRCIE0ASDFrHBGNOEGErhRYWFoLTayvbuGZbeUELysLCgiqVisrlclepva28Yk1tywU/twGUdeQYlL64uBgCSmaL4EC2Wi2Vy+WuKhlJIbtUrVa7WqSiKApZWUgsskgEX7Ru1uv1EKSxz3bgva0YwsnCEaRSz5KzlGyTjcO5gQAlI2zJSKm7EkZSCLJpCSSTCNmCo0O5PuQeVS6cM85jKpUK14BjhHySqSPzCEGBY4MMU11H1R6kk237QG44NzjqtLTOz8+H+TW03MzPz4cnxJDxhnRjr227Hi1KXB+BTqFQCJ/PuSCTSWCNfFjSqr+/PwT0hUIhVJeUSqWuoa2cEz7DkkI4sLwPgo4AkooPnFXOGw40wbRdf0gCSwTYWXPMIsNpRRfZthWCTktEQt5yftGNXBek3trqEqrtbLUHMst3o+dsNQvvRec3Go2uaiSGa9vqhImJiSBrVmcj5wTC9txa553KOUgfdC0ySLsrNsxWNLG+JDsInAiM+F0qB2wVAJUCMzMzXe146BoIxnK5HKoLqGgkk48+mp+fD63jkFvYWogXAtmFhQU1Gg1Vq9VgL2mR4zwgS5aggoBnxhQ6wlZLkEDJZDLhoRLYHPtUVSo6mL8GSYu+tDYPHUTCBDvIbEFbZWmrGLD/+AAEiFToUr28cePGnZJJEAsQKNhCWjiRUWQTcslW51ERhQ9g9YLVV3NzcyoWi+EJZjbYJDHAd7OPBOfoOe6bgJ6qPSqSCcKpqsTXslWgiURC1Wo1nDHOKUQGdoJ1snab9bXEJzqt2WyG6njbsslrlUolfB96JZFIhKopdDPyxVOjl5aWNDw8HKpnIR7QJ+gu9AH+hCV3uFbkln0hUcaMLnwI/B58O/RmtVoN+2Gr8ZBxdL49LxBwfX19Ya4b/s+OHTuCHcIvomqNajTsAzqL885ZjsfjqlarQYa5NvxOPgNdDcFMYtEmj+gggOiiu4B7tPPRGM5OVRSz4DijthuAJCSyjozZijH8XAhz/CHkr1QqBXLQ3hd2EFmkwpE1KhaLgZCr1WpdFU+2/ZlzQuU08sIIDpJjJE+oduYesdH4OVRLkRSyScu18tFoNDQ8PKxcLhcq6XkPcm6r9Egg2AQ8XQuspbX59izz2VT37uvwSinH3gYnpXYhCAhpXyKjR4BEVRNZxHZ79RHdBAJUYUgKhg0jhENks+sE2QR4ZDXI5OBg4JSh+HkN48DnEUiRUWBwNg4ulSizs7PBaSLQpLUFQ9VoNFSv10PWzM7fgcSwJf5r2z74v7Q6x4Gs14033hiIFTI3ODc4KFwX1T2WfEun07r55puVz+dVLpdDUMDn4dzYkl+cAlsZQuDO/dnyfmsQeCoNVWetVitkhzDovb29qtVq4Zp37Niher2uwcHBkIXFyOJE4tQuLCxobm5OIyMjuvnmm4PBpi3tPve5T6isorIMRwHHwWaXCQqoYMKBw5m1MxNsRRMknc3UWhKp2WyqWq0qn893nRNbiUCgSGaM6gFp9WECVHYQ7PJzKmcINHFucEJt+5NtK6VdEpmx2Ua+H3m1MkRmEXJjfHw8OLUESFRBUCnG9VUqFUmr80h4zy233BIIQBxjzrhteUF+bDuBvQeq/nB44/F4OHvsC5l/O/jczq3IZrMhkJQU5INzgXNnKzn5rLm5uZAF5X0EVbRyotPYf+sMEZRyPegESeGJh1ROcd4gw+0wY4I2AmhIWF6DVOG8cj4lhepAS8AR/KIHaJFDFxaLRXU6ndAOCymcTqeVz+dDIEggSsVnu70yowi9ik2xrW92ZpataqhWq1q/fn0X+VKv18MTlwjiWT/OD2QoCRN0nKSg99h39gt7AEHMZ0rqqrCKxWKqVquhaglCzSYl2Adet5WfyDXyC9k1Ozsb2sppCarX6yGRgt1gTlA8vjojr16vd5G37LmdAZjP50ObMsPMWat2u61arab169eHIBqybG5uTtPT02HOTLVa3SkZgk6wbdHYZttiz15AxtO2hDzYKjv0EoPuOZ/Iz/777x/Olk3aEGjzGmvM+UXfxmIxjY6OBptOIEgQbvU8xIu1FdwjcwALhYKuu+46bdy4MeyTnaNlq8A49wSSltC2BCTfbx98YG0wJD36C1+C38N2IGP4TfhJBN7oAPSZ/RtSnmuDMGq1Wl3kJb4abZJUctxyyy1B7mdnZ8PnIYdUtUHUUPGYTCbD3CxJXTZjZmYmnBEIPGQIYtXOx+Kz2bNt27aFinl7XqmSQnYscS+tElfNZlN/+MMfwtOu5ufnNTg4GPQZfpf11+yMv1arFc4dMkwCLZlcffIt5CA22c7cxKe0nQPYddu+yp4z05Wn79nKTOwj/7efT+WXfTo0iTPkxFa38Tc+O2tLFSOE1Nr5o6lUSuVyObR8I6eWqIb8xh/Ch1s7dB1/lHXAXpJ0wSfGHmYyGU1MTAQZwO/DT4e4wy5DhlEti09CF4IlsJEHSF2SmVaPIJex2MpTpoeGhoJfzNnB90MvsXY2Hujr6wv+174MJ6UcexuclNqFwAFh6LW02gZiM+iw/yhiDAj/plUFo4niJsODAYA8sIaTp9jZCh1bLSStzlbByJGFsgai0Whox44dIfvOwF4cCNvGx2dRhWVLza2RIGPG99jZAwRMZJk7nU5og7PEF+QQ8xJYsyiKwgB0MlE4KjZ7lsvlgsPDUEqy9QQwtuWCeyEosRUVrAeEBY4fTzuDQGE9cZgJZm2GCcecWSSlUknDw8Oam5sLjwpmP/v6+kJVTaPRCPO9MEDDw8Mhsz43N6exsTFJCtlvHFru0VYQQZBYoocWGYCDhVOP49Db26uRkZFQ5QExISk4eAwZHxwcVKlUCkGstPpIZeSRmSE4bMhBT09PcNrZe4JmAs1qtarZ2Vklk0nl8/kwkNiSMayVbQe0GfC1Zw8HTFIgV3Cg+TzuGUeJgddkIO0sKwJu6yylUikVi8XQ2gMRQdUQQSTZS6qs2AcCHdZp3bp1odqC9ZVW56TZQIK1g8SAnCXIIUvJYHnbisDnWL2TSqVCoExm2LbAcM+QZAB9RsBC9Y1tcZAUstMEqehXzrykUBFJwMxncG75fnSqbd0heCTAw7lFr+HwViqVLsKvv79f9Xo96EOSB5BRdi4f7ZWZTEZDQ0Ph7HH+ILPRdQR66F1kBH2CvmUvmHkXi8VCex9nkiCMqgJmbJC9z2azmp6eViwW0/DwcFfVLtVGzBxjrdk/PseuYbvdDsPGuTZLBi4tLWlmZiacdXQWpDFnjOoTyES7NzY4tg+tYG4M+07b0PLyciAe2Vc+yw7Dt21DtqLIVmk2Go2w1tPT08EuYrOoTEU+CQBt5Sl2FHIZ24COg6Dls1lnSxBJq0/+ajabKhaLmpmZCToBm4m8EOhzr+wrQSdB9tLSkmq1WiD/CLBJ0LBHmUwmBKF8J7aYWWQ8KKG3d+UpurYFDzm3rW7ValXDw8NhrZFfAkuIHAhRPgP7wJnGB6EVkv2ihRo5sAOdaY1iz/DVmM1kK3+XlpY0NDQU5AHCBMKNz0ZXW9KN2U/Wf+N8UG2HbNLKzOw/7Hq7vdoWyvrzvZaEYa05z3wXSRPsCw+6Yc1ZH2SD1yAM0YPoT0goqu+51lgsFlr4SNzy/bZKGl8O4gfZZcg3/hAyZskr7DMJP+6Dqrx2u63R0VEtLS3phhtuCJW32DUGsnPObFKEamxmwFGJis7D5lodhf9AQoa9xSdBRlgLZMeedXQE/8Y20sqPHrAVvSQgmce2ffv2sA6cI+7LJqZtVadNAGQymZBcwTfmum3CEl3Gw1YgX7kO2yK/vLwcqlXR3fhsaytV7ZNp11YMY/s4s7aNGp2OTrk3wEkpx94GJ6V2ITCcOL209eBIkcEhK20NqH1EMhVJCwsLwRHDSUex4rDhzNinpUkrGSmCBRwTnP2pqalQbUGmh0w1xmrHjh1aWloKDqikULXD7xKoQuiQrV07VJFghSDaZhu5Fxw7yCoyvVQGMKgWB4TvJlgn40cAYINkBopbZ54y7UajESoTMJRrqyxs77xt+YiilfY0ghdJITuKw9BqtcKsGFsRV6vVAkllnQaMOuXR1WpVU1NT6unpCftJpRSzsAiMaAVhz+bm5sKAY64FYodAAIeCGUbIoG2JwtmRVgeuQtxwPziqXDOytLCwEB7dzWBoKnzYf0sQ2CoVZAzwc0gy++QvCBucXDLCyCrVMRAMBGSWnJmamtqpfYN1Zf+5PhvYcn5oMyHAp4IHWZOkcrkcSJ1cLhccsN7eXk1NTQVnDqcJ2cHxt+Qx/4eQ4t8QvxCuXL+dv4Ejav9PYIquqdVq4Wzadl+uhfPKGvNzqhcWFxc1MjISiEg718GeK544RZBBEGLPHH8IyAqFQhhQj07lPshOcy2sFQEEwQHJAdpJqBCxxA5VOpBKlhAhMOJ+mOtGJVGxWFShUNDU1FRwzslOQ6o2m83wdK1UKhXaZ9F7OODS6twQ7AzXw75SXYM94Lxns9nQAkcwbgNciCrOEqQZlXucCfaZtbNtH+gVW7HHeSVxQtA8NzcXnqTI7xMMWnIRHWurZiB4Ie8J8IvFYhh4z/djl9AdtMtAviF3VH3xmZwlKkloB0Oecrmc/vjHPwZyI5VKhZYwhpKTqaedFzvLWcQuUnVhq5pJLNFuTXUVbY+sZSwWC9Vn2Hh0AzqYc41tIGBF/tAtVNKxXraqkX2bnZ3V6OiooigK1d609ywsLKharYbg1LbwQoazh53OaltbPp8Pdh6ij73nuqnUYCYSMjMxMaGenpVW5Hq9HogazkQikdDc3JwajUb4DEg+7Eq1Wg36Ev+iWq0G+bc6BMKLc4Wu5zPR3VNTU6rX68FngRCxhBm6CB9xenpa2Ww2kB0kBuLxeEhK5fP5QOTgc1AdZluSrL/C3kIaUpGGDWdvbWUwSZZ2u61isRhIDD7LVivT/mWJAknhM/H3qBrCv6Faikon9A56G7uJX0qlIPav0WhoamoqPJUREgqSyhIe2F+bWOJvEgYQt5wn/Djum4QNlUDIga2qI7nGuY3HV2Z5Iq/YWohIfPZOZ2X2Iz5nq9UKT2FFd3E2aaXnnJKgpbrKVgBaG2ir0LgOK9ucVUs4UlnPA1XQIZwN20YsrZJ2EFdWHrgGzpttr6cqDVKJNUL3c1Zp+WYYPLYJXxtZ4hzk8/mwbzbhCClp52vtq3BSyrG3wUmpXQgcQBS+raiBbKHKAVIqkUiEJ3BBThBUYLzIsNoKJIwxhoJybMiwRGLlsbfSSiZsYGCgixShcoWADKcEcoJZNJLCoMZNmzaFnzMMkevhGhngzeBhGwDRpmCNT6FQCIaLwMRmNzCw/f39gdzie21LH0QRrXi0O+GY1et11Wq1MJScihZbNSOtEgw42msr2HBAcLAhFGnhY03t3lHpQ2aT4AKHJYoiTU1NadOmTSFzNz4+rpGRkeD80KLHnlSr1RA04ozYSgac7Gazqenp6TAPAscY0gYCAFmVFK7bVnkhU3y2dbAw7tw3Do1txcMpQA6pOCiXy+G6bXUazhZEFy1ZtFhAjuFcchZwkqk+gZSk0q3T6YTgE7mgYo9gjZYd2wbDvrNGURQFwggnjQANYpMsMXJVq9VCVRsBB3LKGszOzmp6ejo4VziWtMRYZ23t2vI6gSHOObqm3W6HknqqFKTVx0DjBDNrgYAHB5fKKatH+B0+n72DVCFQm52dValUCqQEBJptGUO+bGbaznlhLWKx1dYXvpMKGjs4lyCC/Vor+xDB6Gaq8qTVKlQyyOigYrEYiAEbmHNNVEaNjIxoYGBAPT094RzTtsnZsK0zEGFURUG6secEqhAvZOSpGqAqDz2LXqhUKhobGwuP+MbWQJyxppxdEifoKQIw1gbbFYvFQjDENTJDxJJM7DFrWiwWVa/Xw5DbiYmJoEv6+vo0MDDQVQEBcUJLMMQvMsq5T6fT4cmCyANz/2yAtbi4GBIJIyMjgXhC1iDkqGizFXHIQiqV0sTERJg5RbBkn+ZI0EgQl8vlwv5ikwiUCTghKG0rI7/PmkO6WmA/beCLXbVVBthh1sgSvXYPenpWn/THUOparab+/n4NDw9rcnIyXAvyYCvB0LnWD2ImHoQsIICdnp4Oc8HQRXz2unXrwtpjpwhW2+12mEEF+cD+20q9TCYT5kz19PRo27ZtwfdCX3BeCcAhOfi3pKBPIKb4Tubw2aoqhkSTxEB28AnRhVRXNptNDQ8PK4oi1Wq1rspe9kFSmE/Fk2TxZzi77A1ECetO6zq+Cfdkq72QN84avgXnCXLaJkkhGZEZCDr0B7YM39Qm90jMYG9tdR3Xjy5C9mdmZkL1N+cVm8NaYoc5u8gFcoQ/iY0jIQgJjbzgo3M9dgbX8vKyisViGMsRRZHWrVvXVQ0Zj8cD+c35hNhCb9H+iy+OnZqbmwvnmCeMVioVLS0tBV1nR2hglxkXQEuxTTjz3XQHVCqV4EdjMyFS+ffaCiR0JvEO9pokDnoN/UECbvv27UEHIy88iZP32ieTIv9UsNlKOHw2qu3Rj+hC2xqNb9TpdJTP57sqjR0Oxz0LTkrtYmA8bUBIgE/gaWdFkUmCsOIxtbxO4GxnokgKSpsAmCytrQIggKR6CQfBVrrYgJZqmEqlEhyDmZkZLS0thScLUbKLg41BpHqAihiy0XwXBh7mHsIJ48L7uDfuHQNoq2eoMJqbm9P+++/fVdXTaDRC5pPrxAmy1UqWyCIrWS6XJSkMF6f9wZa844CRTaJ0WlJwxPL5fGiX4DPs0xAJ1iuVSggGFhcXQ6UOpfpkqqmWs0Ek5efW6OP84VTz3Ti+OJA48JCGZJmZ+URWkkoMSSEzS0tCsVgMw7UJ6MjWsu84CLlcLqwLDjktjrQ7EJQRjFGxgoNOEM+cFoaBsyaQRFxnb29vuCZmJdngBAeN68RRgpBlTpCkUHknrVZLcWZZLxuMQjBwhqk+JHiBULZtNEtLS12tVs1mM6xJX19fV+aKs0ZFBBlD5M/OrLMzOebn54McQGLzHs4mZ7lWq6nVamliYiJ8ryWcLHFMENRut8M1o38IVnmdoICKFYI49KHVoQTzdqYUgTPnm6cD8jAAssq20olrpw0JYmdgYCCQOLQKIG+cJasruWcIPao9RkZG1NOz8phxqoAOOOCAQPJQyUbAQbY6nU5raGgoXPP09HTIVOOwS+oKuAlyqZ7hiZuW+KC6kTbyKFp5GiWVcNgi1ov5TryXakJLNnG2E4mESqWSZmdngx60VQrINLJAOw9Zc8gC2yIIaUWrCPrMVjPQigP5hnxQjShJY2NjQW4hK3K5XLBTVG4gL8g/Z7RQKIR2Je4fMpvKG87IoYceqkQiocnJSaVSKa1bt06dTidU2RxwwAGqVCqh6oI1rdfrgZRBNtFTyCJyZisTIQRZN8he+7tcN/vKHmAHqRRAz2I/2CdkwM6dIuC2w+cJBGu1WrgGdAKEJud/aGgo6CKbBEJvz83NKZvNamBgICQDIJrRl6VSKZCSzOhjv9Hz2ErugYo1CAbIP1qRUqlUICqonELHo89sYEwwD5LJpCqVikZHR0OlJK1n/f392rx5c3hPuVwOvg5yNzAw0KUPqRyiWpBkHD7e6OhoqMKEkEMf239z381mMyTVlpeXNTw8HPwN1t3qNUgtm2iw5yOXy4WWZIgCkkvDw8PB/4GoIBmDbi0UCiqXy8HOYW+w9eg9dCS2gPPK/hWLxWALp6amgr3o7e3V9PR0SM6xl5Z0hfCC3GIt7bzHarUaSBHbDdDpdAIZ1d/fH+wFZ4g1RtdNTk52Ve82Gg0VCoXgK0D+QURB7rPv+OmpVEpTU1OBYMMG8MRhCFg7kgN5oOKdfeK+LKFs5YXkJ7aJ92QyGa1fvz74ndggErucfbtmJL3ZU/S3JUlzuVzQ3za5SYWk3T+AHeV8Qp5KCutBogYyH53JNdx6662BtNvX4ZVSjr0NTkrtQpCpQkn39PSEUlOCARtU4LxhCAgoy+VyyBLjqOFg2yocCC9rbFOplKanp9VqrcxvkBRK8xneah+ZSuCF0w6RgjGZnZ1VrVbTfvvtFz6frI8t7Sf4JNvBdZIZlrrbn5j3wXcz+BWDSrk5cxCazWZoe+rt7dXQ0FDI6EirAzppy8pms4FYoq0A590+2WxtFRSBJM4XwY8tu5bUFaQ2Gg0NDg4G0oNSZNsOh8NBEEHAArk1MDCgVqulycnJML9r+/btobXEttDhQLXb7RDYs7/28doYXvaiv78/tAMib2S5kVfIksXFxVBR0mw2Q0a52WyG4B7yAdkjo0dlB04OQS1D76lOwjFbXFwMMk9gRaBNZg7nnX0jU7u28o0AG2Kp0+mEeTgEmDjIxWIxOOI4KIODgxofHw/OqiXKcIhwvqjGiqIoPAEPp9ueEa7byozUXV3EWcGppZqO6glIJchiiN4dO3aoWCyGDCAOJQEpbbWsqaSuqgUIgWw2GyocOTNkWG0F3rZt2xSLrQ7fxvFEB3CvVMpwBtLptKampkKGm7PGgF2b7bWVK7TYQjxDhlO1QWDC9/O3HcCPM48DzxOfyLBaEoC1IqgnEOZ3IUxKpVJorWm1Vlpmh4aGwhMzyaRD0hKAxGIrLVdUIJBJp/WIR7Yjf+wV5DjnZm1VHKQFGW8qiXK5nMrlsvr7+8NeU2ECqWgDHl6zQQt6mUqN6enpIBe8z1Z6JZPJMNeMQIHKWmwjJDAEi30IBCQqZ4lAlVancrkcyDLWgCf59ff3BxuELYD8IlAiSKTVi7XmntBv2HR0JK1VECnYKeyMrQijyopqEGm1JY6zA0mDHrIVObbdDns1MDAQKjJtlSvVJuiVTqcT1p9qKGSX/cXOMleJmY+0UKFDmeXE/MWZmZmgg5FDyBOedGqJAKor8VeoZEEv0LaEfpUU9hziCLKfxEMisfIEvXXr1oWzT5IFHY9vQqU2SaxisRgIxv7+flUqlTDjZ207PevMZ7Jmtl2P++A8rV+/PsgQbVZU3dmKJMiBVCqlSqXS1b7KPvGHtaEKibk8tsLZVpfhX9ZqtVDZViqVQqUwZwDyB7IanwAdBXnFHkLw2ifmQV7g15K0szO7IMBpZabyFX8AOwpBjp9EcldSaK3ksyBdsI/JZDLoTkgOu3Y26YEPhT4lkWdnMNmqb86atDo/i3ucnJxUNpsNSa/l5WWVSiVVKpWQlGJfsCvcG3rajh3At4yilRmpyWRSo6OjwT5gz7BXVGfzWew9/gSVcwMDA2H/bKIPQo8zhgzYKkHrp9kkRCKRCLO00MPEAdwD5AbEcafTUbFYDIkqCNa1D0iALKbil/vjPSQasZ/YJs4Y90ZSG1lA/iH+9nU4KeXY2+Ck1C5Es7kykJNBjwS+lHHTkoQytqXXtFNAaszNzQXHA4cEJwZnEsNJBpngBeVLkBpFK4OfqdKwQSUl97TpEKjhZPK48qmpKR188MHB2BOwQ+hIqzN/MNA45BiCmZmZrpYhDIYd/ss9MNwVJ8CSboVCITgiZEMwrrZtkkwWBnV8fDzMNOh0Vvr4BwYGuloGMcbWyZNWZ3lls9mQtZUUHAEqP1qtlm699dauCjQqT+yjwSFbyOxxf53O6swcZlMQrOEo5nI5DQ8Ph2GZfC6BwrZt23TYYYdJUsjgEXhSoYax4j5su5q9RoD8UdmBk08gZ9fQBvAErKxVvV4PVSXJZDI4ubb90Fbi8PucC2Y/WLIN8gIHdHFxUTMzM8GRJWjCsYzFYiH7TlsKAV0ikdDQ0FBwrmgHxVG1FStk/8maMlAdMspWRnFvNmhgP2KxlcHR69at63Lsk8lkkBuIHVttSWUGQRCfzbwH7hlZW1vtg/MIWc6+Uc1h22MJGnD6IbDItEoKg9wJMm0mWFKYmVIul7vaGFh3CFuqiaiEgiQmgICAYHaQzZBCakFQ2VYR2yaayWRCG+fw8HBwggmmIcEgBtk7SDgcXQhOHi5QKBRCBRYBKP8myOnr6wvVJvV6Xddff73q9br6+vo0Ojoagg+uFcfbVqWkUqlAwtiqNSoAkI2hoaFA8EkKdqnZbIanatlgCPKYR9LTRjI4OBj0nq1u5f+WFCAA416RA+YsEdQTRBKsYZfQFZbw5vd5/+zsrNavXx8SOq1WK5xlZJbPoFLTtlvyM+aSDQ4OanJysqt9iT2nGpLgFnIUm25bmmyyg8CQs8cZJoiFREd3ICNcI9UC2Ww2EL2WVGItOL9ccywW08zMjNatWxeCfvwFbI3VQ7bKGAKRZAnyw9mYnp7W/vvvH1qqbeUWFaokBmz1RqvV6iIVqAgvlUrBTkG42fYazsjS0sp8SzuEm0rOUqkUCBLbzkvVK3pucHCwy/YReEGqQNSjK9hLkkq2fd9W46HraS+nOgnfwbYzkbhAb6K/kCPIUusP8X0QGNgB9BJkOnoYchTZguRDVvDPIBJsRbi1lSRV0fdDQ0OKoiiQEFSpYufxudDNrC9VdVRFcv/oERJRVATT4o4/CXhAgl0j9F+7vfrUaEuyUBXJTEn8WcgXdJGtFLPEtu1I4J5ou06lUhodHVWtVgvzqBiZcdBBB0laqeaC/EMvoiPL5XKYPwXJgp9GtQ+JGkuq4BtD9C4uLoak5szMTJAr9EK73Q4+ttVPyKQ9D+g0zg/+BCRWNptVuVwO9oukMT6JJSdZX9r1SUyw17b6mQo49sY+pAK7T9xDizykInYBGSQhw+fbxIcl+3nfvgwnpRx7G5yU2oWg1NWWChNQ4RzhYONYMOtjZGQkOPYbNmwIDjYBCU45TuDaaieyWrbdgSBqeXk5tCPZWRwocrLBkD9kCicmJtRut0OlDqXyOOe0FQKCY5wK1mN5+f9j705jbN2z86Cvmudp165d0xnu0O22b7s9JgTbYHVIZFsQJJQAHxKBmwQ7abVBCQhZQCCOUWw5SpjywYEPJBIk3wgCQgSxJWyCktDCEHW33d32vX3vPUONe6h5HvhQ+q1a+7SdxO6bxPdSr3R0zqnaw/v+h7We9axnrf9FtNvtdAhkxDKQgHYNjmWOOetutxvLy8sJ1gSPslPb29vxxhtvxPDwcAJ+mURBRKPRSIKIBFsWUGZKA1jjADxFRAY4Xj80dNcjCQkZEQkmEJAXFxfR6XQSKEZEPiNQYJ2YfwFhs9mMr33taznXsrLmT0nF+PjdsfSC/G/6pm+KhYWFbJZvndS/BRFAqKD/+Pg4s3xAISJL8DUyMpINzMm3qzpIk86hoaFotVp9yqvHjx9nEEaxMDY2FouLixm0yHLXPRNx389jeXk5Op1Oqr/sPWMpiJmens7MuB4G+qHJbhtLAWUlGpCNgLf7QMpq2klRg9iSqQSckDGCbAopZQbAVW3sK+CgMBoYGEhy8VVC27watyrhbzabOVaazer7VgNcYE6vM2U6QA2ye21tLba3t3OsKkGOFHQfSjt2dnZSTVWVOAIja6WOT0T09S5hqwQ2iOaqImBX2FdjQSVFnSpodAleIiKDVuSWfeLzlSwJepxEpFcSFZQGucgWgQKVw+DgYO41p5vWEtnl5eUMGpHuSlyqiqKSUcbTuAHw5hYJqxcUBQ8i6uDgIN57770YHx+PbrcbT58+jV6vl+TjxcVF7OzsZDLBHAs86vH2/BuyEcHo//Ytu4lUZG+MN9KLPaKAZcPsQbaokkSCoEqYU+cJOpXr8ZsUr/a4sRMo6vNF3cv/CBD39/ezh5gg3TMiumtyhZ9AyNjbe3t72XR5YWEhiYQa9NmbiJtKiNfSVL7KujW+1tfg4GASZdYYNRH/65lXV1fz97BNVUzzgdVHmgf+y36nKqGcs45rqaux5derLaqN4pFSTi2WaEO8+T2iypqUhJOsss6RB0hV98KOOV2tkvUINr7C3I+MjESr1cpeR74TvpqZmUkbL4klAeJZqnIMSSipqDQMfrNu9SqjnrTP4EdBP4LRXrG3kOnIW2Pz7rvvprLLgSmvlm/5e3FxMZV+R0dHsbq62ncID1JGCZ05YzONY91r/DqbhrA9OztLrCoRg+RRSg4L7O/v5965uLiIZrOZ+/zly5dJtNg/t7e3MTs7mwf9UC5TMSO/KOQkmpE2sBYShhrYM1VsyJYjZynvvQ5JA5dIUkxM3J1+bPyo/2pFhHGFo53eXH2ae6QKpdxX/iphxhYi7t2/NcHGswMwtdYQs7Oz2VMKaS3hTDHuua3h+fn5TEogrv2Oz/BvNq6Sk5KB7M1H/XogpR6uD9v1QEp9gBdHzOiR9dfsdu1NwalQgJyenqa6QyBF7VRVBwJ3DpVjkzGhBKo9RBAtgIbsAgdElVHBJWWMMofh4eFot9uxsrKS2TOBlCCO4xXAadALfAE3AFWv1/u6AJuTr6eARNxlymSPer1eXF5eZvaMs0KuVGC2t7eXJ/twmLUEyzgDRu5HAOGeBAKAEULx/Pw83nnnnVhaWsoxODo6ylIWzwJIAvQRkQCZEkfZJrXUyspKBrC1tFGT7fn5+VQkIHKUgwDj3W43gZu+S4A4gOK5qBkGBgayJ435HBi4671Sm8sjSSqotc7q+ru9vY1Hjx5lDxwlMTK/FAQR0ZcJB8oEMPVkqoWFhTzlCBA7ODhISb9SlKrGQE6530ajkfdcQZxeB0CxYE5PEMGSz76+vo5er5ckMOLBntfQ2voAtpAwAOrw8HAsLCzE5uZmXF5eZp8ihK0gBzk5NzeX3y8bub+/H81mMwMQpa5OrkIgVnIUCJG1FCAitDzL2NhY32mVEfcnMsq4U92xh0tLS9HtdpN4Q45RWpgLWfZKOrvsP4CezRMAkfYLXgHOepS6ubU3vDcisrRVGRoAzU7UPzVQRmb7v7nY2dnpK9+otvbm5iZ6vV7s7OzkWmWDkdjf8i3fkiC62qbax6SqC5CjnU4n99Hg4GD2pZKNZyt8jrmiiuCH9LixLnu9XtpeCh/PjJyqfWpqGZ6y4tXV1T6lgj17fHwc+/v7SSRQFBk3a0rG3R7a2dlJstc42ysCHXZfkOb1+rohY05PT2N5eTlmZmYyIENW+2xKpHoUfKPRyCbqvV4vFZjsvxKyiLvTLJ3qxZc7UATJQrlsH1Six5qNuCfzlONUwsleRXJIBPFFg4OD2X+SzUa+IJEajUYMDg5Gr9dLm6yHozmh7qL+qQQjMpHfW1hYyEbXNXkxNzeXJKPnQNibC0QUwkVQenV1laocfeIQEj7H5yIvIyL9oLlEzrIN3suO8Lv2/eDgYPa6o3jSL0rCZmFhIW5ubmJhYSH9pD+w1dTUVB56AK9RXZlHZJrkGoWJ+Ybn7Jf6c8SHQyYconF7e5u2qbYtYGvYVvb5/Pw8cSU7D2Pal+wLnwgDIVgQzBJ2lKE+vxL/iCD7riYt4C2+iUJ1cnKy75RHa51tcAIjZa79FnGf7JI00A+Kj+z1ejE0dFd+CKPqp9loNPpIp4mJidjZ2UncQBkuLnB/7mF4+L5Mf3h4ODqdTt8a4b/Mkb6flZSm3vZH2wX21d7VM5UqDuZD+CFzqJasDb9vNBqpBq5KVj4c4cPHRESuafayEkjmUOLOXhRriDGQ9jCh9QIbIvnhASoxpKzkpfFQMmveP8rXAyn1cH3YrgdS6gO8lFadnZ1lyQMwBVxwErJhQGen00mA0263Y2FhIba2thI8TExMZP+SiHtjQwEREX1lCgJY3yujw8BrFC3QriBOACeLfH19nSUhADkQJussgBTEjI+Px+LiYkqFq8QaOYNwApBlYwGziMig0fv39/djcXEx9vb2+u7XM1VQVcEVBU2n08ln0v8F8eI9ABqyyj0Bgzc3N329lzhdWTggQzAMjABtSBz3f319He12O0mLsbGxPO5a9hv5EHFfatdut+Pw8DDW1tYSLA8O3vXpaLfbERHx4sWLPNlHE2YB4NzcXBKLEZEydqTq4uJiKuis093d3ewvAphSRVjbeobI9DpBxrMDqM+fP4/Hjx8n+HtV5YHYMAaIOw5TBlk/J7+bmJhIoq32XIiIDL4qoWJOlcBZd+awyscpzwQ+5+fn2SML+alfDrWJgAHhhDxD9gJZFVQBjhGRwJ0qqCo/gE/3R2WlzOX09DSWlpYyWLcXaylJROQ+1VeGAs58yTq7z+Hh4Tye3P5UHuEZAG5BKDJDo2KKjVqmIKNbywqNn31MiYTwM0ZVQVWJZwGy3yGF2RRrwHMgXoxZLXOo/UqshbW1tdjf349ut5tBqTWKtEcE6fWib5egqdFoxPn5efZ/sm8QJBVcVr9BgVRVcu12O2ZmZmJmZiY6nU6qADyr0tder5frEAHVarVy//gOgB/xYG/wQ/UQCwGnUmllGPae9cmnUOdYb4gAa0fZVrvdzr01NDSU/Wg0uBfc20NUqtUHCOolRpRAUeAsLi729W25vb1NZZzgW9kKHx1xT8KwJ+5NUMU/s3F+zm54Lvucn0DW83HWX7VfCHXfYa1SWknCaHpdg0ykRB1XKih4gfKoqtUEy0rVjHvth+TzrKvb29skFBApjx49SnIdjmAL2Q9KnVqCc35+Hi9fvozv/M7v7Pt+tgfhhKRGcLChkl3tdjvXQS2nHhkZydODKxawxpUP1cs91lJpChNkMbItInIeR0dHY39/P+bm5qLdbsf+/n6Whpkjfs93wiK1fLTiLiSXZurIbq87Pz9PkoZd9XsJEuuJAisi4vnz5zk+ToGraxFZZZ0iDz0PnIRIpGCyJowzTARTss3WYSVArK1X1at8RLfbzSRaRGTJr/0FRyJl4LWNjY0YGhrKRCjsOjU1FePj49FoNHLfb2xs5AmnsLqkqbI+6mQHUPBBMMDAwEAeUAMbSubUpJvkhbI9vg9xV0ldfsH3SETMzs7GxsZGny2pieFXy/ree++9xJjsuz1U1xH1GZKdTbPPrq6u8t/I8ddffz0xTO3DeXNzkzGHnqDWR1UgHh0dRavV6lM38uuSshLUVdVd1+3D9XA9XL99rodd+QFejCLHzjkAckChcq96hLUmnBXcRdw3yI24z+gIogEcwBtRAkhxMDWA3d3djbm5uQRqMv8ILIHt6elpgnSZMAE/p0mujmRDgHF2iCKB487OTgIERAnlicCn9sFy2oreAfoaRNydEMiJIUOeP38e4+Pjsby8nOoJ91qfsZ66cXFxkX1ukDScPPJsbm6uLwtcFQLA/tDQUCqLKOMEA8bCPCn9sGZImqkGWq1WHB4epgwcGUHtA1hy+lRUEZGZ4svLy2wCTYkATCIRa1ZY+c3c3Fw0m80+wgwAQKrUngRVTSIoFVRqBgyAnJ6exvvvvx/n5+extraWSgTBkMAaYTswMJBrXoCiv4tnBrSq2gcokp2r/SkqwN3b20tFYs1GUhbIygGC9VmMcbfbzYaiAnUBlb5nGs4jjY2fdSbDKot8e3t3WhqQpwTWvdunlC9VcUUGzy6sra1FxN1JVTKS19fX0e12+xqnC371opLF/+pXvxrf9m3flr3XamZd0CD4r6AZeSaIrBlhfUoqkeK5EEG+b2DgvjE44lZgVMkka8P3+zyvN2ZILUTGq5nnWj4WEano9PtXlWXWPBJge3s7A4SI+2A7InLclSwIBJSyUAK1Wq38nWdjb66vr7OJNtJgZ2cn7fTk5GR0Op3o9XrxHd/xHfl8AiUksnIagTdigpJXgCML7/vqPhQ4z8zMZKBYlVMC6cXFxVyfyBvvYY9brVYSKOybvYQ8Ue4m+YDIu729je3t7ZiZmUmCm+02R4J7RPru7m6qpCjNfK85RR56Jn5J2djAwEDs7OwkSWN+3nvvvb4yXQpo9kcAbRydmsiWIsiNgbJHwRVFC3KiJi8QD0g+a5jPRWCxs5VsZseQOfXzBXDeS73DT1Q7cn19nYEnG1lJrd3d3RgfH88Sc2ML4yB84ZPaLuDk5CRtBPLn2bNnERFJBvt5TaZ4xqqaNC6ILP4facKvUCdV+2IMKm7S69A6Q17BeL4PnqqqHSoYCvba6oFdr3YPAaYPmCQEJSkfL5mlhQCSwj2dnp6m6gzGs8ckQmtP03a7nYlQa8fYWuOe0/3ydfx8fb3kEdLRmoJL2ByYjV3kV823dW29sF0IjKoINz6wkvJCZNzAwEC89957sbKyEsvLy0kgWcOzs7MxOzsbAwMD8fLly1Qzw3eU6i9fvsxnNU61TxKSBL4dGRmJ3d3d9C/m3L0pT66qQn7mVRWbMaOagjP4bkpweLeSPgg/5XVvvPFGn0rfPnZ/tTUFWwsL2cf2DILUetNKQYIcKc4PU3/xbzAuu9ZqtWJycjKVT7DIyMhIKrv4VjEXBeeDUurv/76H6+H6J3E9kFIf8AUMOK0MuKnBtiBeI1lggoKkngoGMHCswIeglDMCyBEiFCKcVj16tfavqCAVwXJzc5P9LCiBOFUZsHrkrzK8Cqz39/fTcXkdhyqTRc0j+BLMCCDGxu4agevXoreKMkWAuRInNWCr5Vc+rx4F/ujRowSLEXcBpBIKgQOnVkkEwKPVasX+/n6cnp6m+oCUeHR0NEvCBCYylDLkNQNWP5uz3N3djZcvX2aQag6UrykPFVwCafPz87G5uZlOnbz96Ogo9vb2cl0goyjwlI1aB71eL8klTSLn5uYyMLCWAX+gDKiiAHv8+HFMTk4m4EK41B4btdcP4K10zHze3t7GyspKNmqenJyMnZ2d/Kxa8uE0L5L8sbGxVEksLi4mwEE6NRqNLPWphFwlM/xtvSpBAOw2NzdjeHg4Cbdms5llrQgphxjY33q0mVfZfnbDHkDSCRqQbUCusiCgHOjWZ0VjeaBUkFvLJUZH705YqyW5r7/+epIPAKjeIuyTwK32BBMEr6+vx/b2ds4Fu+Q119f3fXwQfTKd1pVA2Rq5vr7OzzKGVHbsCcA/PDzcVwoqOFJeWdUF1r6T9SKir29GVfCwdbUMRFAzOzubKhxrBqg2LsPDw6k0RUazEQJHhIXeM1RGAkTBG9JS8CIIkn2mWkSaGH9NrJ3W6j3IQsFyRGSzYAEnP4fUZbMODg6SYLC/lCH2er20tYL1qq5BfBwdHSUR8+TJk77+YNYmIrf+HGFnzE9PT1MNqFcJPyzw5nNfe+219LXmnS3zGio4wTSiEmEicGu3232KxIi70r1afjU4eFcuqfyk9s2xnhGHxgTZq/dhDQYRTj6bz7WPBHeaVO/v72dfpIjoIyLtseHh4fSRJycnWS4JtyBYqqKHnUO+2xf8HFKzqmyOj48zgXBzc9cD7vb2NkuZhoeHsyH92dlZLC8v9x1OcHh42FdeSkFjvyhPRCrxwz779PQ0Hj16FBERe3t7+fzKRCsZqMwckSlAdoKe8WGfTk9Pc7/b3+wcxcze3l7Or/lAjrIpDlipytialKk2ChawBhYWFjIYd3IpZXpdLwgcvgBBjcg1nzXpCL9aL9XWWsdsGaKFLUQisfFsC4UynyfRBbchKayTqgBEIElGsnXI7W63G9PT0+kb2HTq2P39/Tg8PIxv//ZvT4KXfVNSi1SpBL6kmjGgbpc8rP7b+MEdCGBryWccHx/3lRNT8Nn39p2EKCzsdyMjI1ntgHAyF/alMWSP6yEe9VmMOf99dXUVzWYzx0DCyDr0nLD+7e1t+nn/ZguqCp6P8lw1aeX++GT7ChGlbLaqDKvtgT2NJ0XlR/l6IKUerg/b9UBKfcAXg6op+PX1dTpaoLuSRVQXlAkc4f7+fgZOAscqr0Z0APRIKdkSRp2hFwi7rwpYETDAJoB7eHgYZ2f3J8oIMCgx6r1UmbkAstfr5Wfo+VAzlhGRGTVBEOAh2wng+K6Li4uUgAtWZU1r80b16YA98ESpJfClLODY5ubmEsgAlRw0x1azX8ZyeXk5+7cobUIgvkrMjY2Nxfr6el8DyYj70wuRghMTE/Hs2bN4+fJllqMIJldXV5Ngq0oa/WQQloIEwEMAYK0gnQAlyhbEEgJCMFXB4as90Mx9bfQtgEKeWtMynBrJA9hAcs0SagJdG9MjbjTqNH7WozUJcJuTWq5mD+p7Zn/Ozs5mz62Dg4MMdKqC8fT0NF6+fJk9UWrZYlWjKC+iCqGU8wy7u7s5JgiRL3/5yxEReWgA4g45LROpR9Lo6H3zbERUROTRy/ra1JIIe6baoVf/VsKrb8fIyEisr69n4DY/P59KByQNQIjkELxvbW0l8eYYbeuI/WEjqb8QLwL+6+vrzPYjdPTxqVJ8gQIbCJQ7PdM423eCGGu3ku8aa9cePRUIUyGsrKyk6sL966FX1QNXV1cxMzMTi4uLmTVG1rBx+hudn5/H+vp6bGxsZEBaVVvj4+N96iHjiHyhJlWKND4+nqoAe9leEwRTmyirpsowpxQDSB9BiHk6PDyMVquVmXHBAkJ8ZWUl1QkUovyhAFAgh0i3FhHWbGhVnVCzej07R6WGUGKnamA5MnLXT3FnZyeTLextDXAiIpUHVWkTEakGu7m5iVarlUpdZMvS0lKSeQJ4ZALFa1UqUVG7B0En38UP1RK12ucr4p7cQ5Z4LfKLcuP6+q7vF9snWLy5uYnFxcW4vLzMUzBhlKWlpSzdrQQHsrsqiVutVs7J2dlZX+nTyMhdw2T3ND4+ng2SnYLW7XZzvRprpanIDgklxDgVERIDmYB4nJycTD+PgJJ4gUXYU8QZdRT/XPsyDgwMxMrKSiYjzYE1IWnFT7tvKkn9N+GXqoSTaKSqgZf4X5iy2lLlTPaWBJAkR0RkMkpSpCpMEQHUOwg5WKkevlJ7plqj9hD1J7tNRby/vx/Ly8uxu7ub7RgkEvS9tN/hLG0oKBzr6a9jY2Px5MmTDKb5OvuMD0RQ21uw2cXFRWxubiaJguSPuO9L6P+UivaLkmz+Dd7XFNxnVRJ1dHQ0fQB7YM6oSM0/YpVPHRy87xlX/QESSa9TfZ/4y0r6Dg8P58nC7oG/rKS+yo5Xe/Uhr8QgVQmGyKw4C9GpdHp2djaxtnE9PDzsI/j4HCrGZrMZ+/v76X9UbVSlOv9b1br2m32CBKvJk4/q9UBKPVwftuuBlPoALwZALbdAHCgQKFXQR+5aM6ftdjuD2lrGIrNLHRER6QgEANQgXi9jWINSgQnHwqEIvgXZnqfRaKRjRyRQOVErVDn/3NxcvPvuu+kwX7x4kc6hBiUCEYCzljQgQpSxIZwiIp/XaS6yQqOjo9HpdOL8/DxWVlYyOPe5glXOH0Gxv7+fGdROp5NlibVmH7k1MzOT0u2qZNN7odbuX13dNclUNsXRIt84RsGYNaBsC2n1/PnzzBa6D+qJxcXFJHbMaa/XSxCNkLy5uWtIKxMoGJDptiZrkEQ5EhFJYrlX4Lk6PUFPbWIKUO3u7qa6QeCN9BDsj42N9QVJghzBweDgYPZo8H8KoIh7NWAFm4AN4I3MoaqrRBriRWNwgULNKNdMPwWbwGFhYSEVg54HIDfnTgoTpAmWBaPu4fr6Op4/f56NlCsZiNgSLA0ODiYxI0PudMaNjY1otVqxsbERH//4x2Nw8K55sYDS+mOvyPytNSo++47irRK0SI2bm5u+hsn269TUVMzPz0dEZGBSezvZZ8bM3tKfhx2sJUKvqpwoN6ptVdJay7gq2Uw5osxwZmYms6+eCci2FvUA2tzczOasyAE9pawJKiafNzQ0FM1mM9esgFtprUyu79FX6unTpxncymxT+7g3iozDw8NUYzqx9Pz8PNURteRxb28vlU32IAJIeZvPRdxQR9qXmudGRBK41mr9PIoQ/qhm4fkndoj6inKDqsW8CTzqwRHWvTKlSryx8RSDVdHBT2q4a1/yrbu7uxkM+wz7fWRkJHsSUtRQN1jLSvUpxWryxTPrWcPmsttIZfuUvxJUVd8vUWMvVwUTe1L3dyVYrSfjjuxEkjrVywnB1p1EFFskmKRMZZfZhHfeeSft0szMTBKTgtNaooyg6Ha72aNOL0v3e3t7m/ZNwF4J6VdVZzXZgZipjedhBIE4RWT9nX1HPcaWm1NqHM3KJYzMG79FbSypI5Cn+mIvYSrP52d1D3W73exvVm0hsgehZa8MDQ1lLyWkDdLl8PAwtre3E1MgV7e3t9MWUqzUxKIT1fiBqtodHR1NJRjf6SRZ5ESn0+lT0/PVVWmq5KruoS996UvxO37H78gEkL1mbOq6QqZVlW7EXTnYO++8k4QmAkmlAL9VSxyrch1WiYhMbknmISndM3K9Ju/sMTiXb7OPKY2Qt+7DOtcOQtm9BBWbIvHLviKA2R1kGZtJzV0JT/eB1EdySmLBuMaGr0HESyYYe69XNu4zKoHEJtXEszUgPtCDkb2WAEE+2VtiADa00+mkCvWjfD2QUg/Xh+16IKU+wIsaRdbZpTkiIw+4ALKckIBHMOXUIg6qlqnVIKL2RuCgbm9v80h3wJSCi4xaZsHpN06oAXZPT08zqwmA+jzAR3kfwMIRAlADAwNZ/kXFw/lqsiuDhxQBZgHsiEgHAvS+9957mZVCKFFDHB4eJqDqdDqxvb2dWVPSZJlhZQQAk/EB+iihzFVV41QSqDr67e3tJD+qgmNoaCgajUasrKzEzc1NAsM6tzJr5vPJkycxNzcX77//fkREgtq9vb18doF0xB34EUQKwLe3t6Pb7fbJ2a2BiHvQUXsJAOM+o95jLQm13mRxKTRqCRkVHvAREUlK+buStPaS4EYW2LPpRyZ7KvM3MjKS6gh7TdBDOYZMEvgZC2AbUKf0QoAAsADr7OxskrNIZyUZVUovSAAIkXWCDWWewJLs5+TkZHzTN31TrlWBE7A/MnLXsHp1dTVJDxnytbW1JEgfP36ccw3IynLXsgjB+ebmZiwvL+c4WDeICK+vDeNfVW+yDWwUu3N0dJQkU1V4+K6IyACaEkmvreHhu35mGxsbCXCVPslKj42N5VhVyT+i2D2PjY1lw36qUEFOVScg1eqaZAuVCSC3atAqgEMwKQ2Znp6OhYWFtPPtdjtevnyZ6lUEB4LFnC8sLOThBBRjxtZaAeCVoLCTTnyrvYPYCcEqG3x+fp4N5G9ubrLU5/b2NoNNpNLY2FgS7pIMynEEuNYHZUAtQxe0+Oy6v6raDonCH5nHSnAjR9m9zc3N/Dx/a3qMhFheXo6Rkbsee0p6ZNs3Njai2Wz2kU+CJwHQxcVFBpC1f8/BwUHMz89Hp9OJiMg1hbCtahYEHEVmVSALni8uLvLUTAR/TWSxcebJeLDZ1rXEBN9qLgSBgjjrmDJWSeTJyUk0m83sJaQBPD/rPWydeUbKCXZhAKVFyBb+l+1mcyTEJFWUbFffAGM4/dTe53uodfxOkGuvwwFUVVtbW30qU8/ID1W1ay1ls8/5RGqqbrebpeHsN0KeulrJvGCb4pZ/RtJXxXTEfakXPGKvucevfOUrsbq62pdQQuZ63cnJSRweHsb4+HisrKxkY2mkSC0P5GOqEoktQTCzt3yMNTY0NBTPnz+PpaWlWFhYiLm5ufSVExMTqYizXu3dujZgFuPz6NGj2N3djbW1tSS3vcfFnmrfUPvKDQ0N5d6HI+BHew5O0Jri/Pw89vb2Uils3hw6IxFBVQmLGT9ke01SVoWXcaNkQxZRpl1eXmZCBM6ylmET/vXq6ipbaZgDvs3+Nma1DLz+Qa6aZ1cla8UslEvIZ/d2cnIS+/v7qZxmv6ndXO4T1kRuW1NKoGECp8TqDwqzGSfPdXl52ZdIp/D7qF8PpNTD9WG7HkipD/AC+Gs/kYj7Js21TAGAq41ZlXuRrZMGczhAENLL5zHwJM9OK+KYOQyOTZaQo61qlAqYBABVtSK7yZFzHkCywNdzIWYuLy/zeZSVIco4wirFv729TaWXwLVmSBcWFjK7A1xrOiubBmzt7Oxk1lw2T+YVyKGacT8AhOyMMTSv+nCZC7JiJGEFgUB3s9lM6TiyS9bT+rm5uTttZGNjI0mdVquV4Fx5nbK/r33ta9FoNGJpaSkJjNprAfCZmpqKTqeTAZg1A1BZOyTnynEAVCVAShaMEed1cXHXGNhVCVOBoPINQaTeEUCNPhPAdQUosmCNRiMBirkzftfXd42kAe6674xvq9XqIyz1K7u9vevL5gS9gYGB7NUl6wnMeX9VuQnyBJCDg4NxeHgYR0dHSYp5n+CfygQJQGXh/RQRjvNGjNbMomaeAuPao0f/JyVjEZGA0NjYX9apEkd7cXh4OHq9XgYP1gtCoPaRAYqPj4/j9vY2iToEivJG5Ku/3at9bj5dtWxsaOiuQTk1X+2lI5hjh2vQZHwEVErZBNxzc3MxNjaW/TqsawDWWOm7Zf3JUGs4PDQ0lASUkjy2gc07Pj6OdrudJSvWp6RCLX9S2lfLTQUXALu1RZlZlUy7u7sJwNfX13NOa/k2koNSdGhoKNbW1pI8Zafck1NlkWRsjT4hghXBKHs8Pz+fAZI9vb+/n2tNwF+VBoKLmZmZWF5ezn3osA7z1u12MyC7vLyMnZ2dbBrtPubm5jKLvr29HUNDQ7GxsZE2udox9pGtpDyi1HGAgCDWerYOX758mQETWyiQYm8Fl9ZnLYEZGLg/3ZHSDRmH/EVqC6Dt+4GBgVhcXMxS2fn5+dzvY2Njfco5PqcS1J7LPAwNDcX6+nqfksVr+MX6b6owp7/BAMpKkc3KG/kJGIUNoL7iF7a3t2N5eTki7tWXr732WhI6U1NTWaZobRsfJBocwn4pJT49Pc1TxaoftVeqArCWMFWFt9OSHz16lOSbcjSlhsi7qiRGOvELetrVcV5YWOjrE2X91F5B9obP54/Y/YhI4k6SEUFTk5HI+ouLi2xKTzXNlkhqUl/Vueerrq7uTlujckHuINaQ5Ofn50ns1wQhP3N1dZV9uvzs137t11IhCeceHBykDbbvrHljINGIjKmKpqpEr3bW/FQFGHJFjzC26+zsLEsAe71e4tpK+rIFbIz9Pzk5Gc+fP89nlnC8ubnJnnTUSMaJkpvPQuRV+95oNGJjYyMajUbi+6Ojo1SDKz00h7WZ+8uXL/vmzzpD2sIPNZHOloyPj8fs7GzOC5vtoI+RkZFYWlpKvIF4rTbDWqg4hS+EY4aH7/p4SuQi0sUaY2NjiRU2NjaSHLcnHq6H6+H67XM9kFIf4DUwMJCn5gicOTvACSGEFAHSlNVofq3ngWAvIjIoBUiRNzIJHKLMMqchcAYEms1mAiny6oi7E7omJyeTPGC4T05OksxZWFjI4FTQJ2iTyQHghoaGMmhwZPfY2Fg8fvw4lUU10EbmGSuSZ2qJjY2NBGbNZjOfT0BI2swZRvQHGRy//gec+dzcXIIipXMAG8Lt9vaurE3vEg3OAWrSb84d2aLHD6coAAdQBXFInsPDw+y3s7GxEQsLCzEzM5OgwFh4rf4FVVkCsNYSEo5fKQFAo/QDwLbWqqJCo1RACdl3dHSUxMn19XX2LXu1NMwpZ3rO1PIeajvzdnJykgo6p1IJjBBSEfcnPlayUDkfwq6WLZgPYHp4eDjl6M+fP09yoioJqHesBX2t3DPybn5+PhVFsuRVbVJl/8onkYC1LFWAOjIykkq4m5ubJH0ExhQ4k5OTud8FtVNTU1kupQxSsIawUf4E5BkTJNb5+Xme6CbDjwh7NROpV0UlnzwP5YHAjA2xh4BmtkRAWgN5YNS9rK2txdHRUQbHGp+Ojt415tUriooq4l6VNz4+Hs1mM4kz94GMRcQqg7Cm6z3aqwj4y8vL2NraiqGhoWi1WlmWg8CoZWlK0WSNlV4qYbE+bm7uesMJZO1nSYyqLqtJAFlRe6GWdFPjVCCPANVo+ebm7hh5JUnsSS1H4msQgwgp/e3MXW3aK6js9Xpp29lgvsz60xeI3VpZWelrTMw+CgyVWl1fX+e+q8pR9vn6+jpmZmZSzSSR8fTp09w/nU4nVldXY2VlJYl8ZaPWmu/W10qpOH8uGH/99deTVKy+zH3xVRIvSAe+hcIJeRIRfSXIbKAgjS2tqsxms5m+mD2CJ9gU61SQbA8iI4eGhrLR9tHRUfR6vZxX/rUmt7yXDfUsm5ubSSAfHR3F/Px8KpM9C9tkb1kblJgLCwvRbrej2WzmupDMu7y8jDfffDOVXMa8lkiZQwHw7OxslnMeHx/H6upq2nWKJ3ulEhL2gDWAiDw7O4v5+fmYn5/PJAush3ytSS/3VEuZjYG5iIj0YTVZpgyrqodgQiSl/m58mfdJFvCBSFI2jh3Rl00SyXy4B/jVWoCbYC/kKXy0tLSUpYYSXtYLgsK8Ka/jD+AJlQUzMzOJP/Rg2tzcjIWFhSRCYKL5+fksb5TQYyfhB37EWt7b28vxmp6ejunp6Tz5uR7Kwj/wLdZ7bWKP4ESAKTU0J5IR8DXbvrKykoeoGHdroqqT7Udryv044GJ0dDT9H58K91vH1d9KxLKt7XY7bm5uotFoZA9De78eSiEuqMkpiTMHESA5vU7FRI0bELpsCx+GgIUj+MHanH1oaCgPHZBMoKKanJxMUpt9+qhfD0qph+vDdj2QUh/gJQtdM68RkeCrytqBQwGzrOzAwECeJsaJUNNUkBRxL2sGjiLuyQTOneGuDVY5hVdr02VlNEocHx+PbrebwUlVpAioBItUXk60OD09TeUHqTNSTICh9KRK5wUsggnOU3Be+8YIlPf29nKsBKDKDsfG7k4rEnjVLK2TmQCMiMiGpAAfybYAHmnGkSJCjI3sVkT09Sg4OztLIo7ayTwiOags1tbWYn5+Pra2tjJrZ9wECPPz8339SmopAlBvPZyfn+dR9FXNBpgJYknbZawoR5AlgBFwjIzy70rWGcOlpaXM5tWASd8MASjFG2AC1A0MDCShKasmsFWid3p6mqdFCoyUcS0vL+f3397eRq/Xy3Vh7bVardjd3Y39/f2Ym5vLTG4NAo1xVdMhhQRCVXmgATfCFci1riIixwy5IePqJBslXtaQgK1mNY2Xn1dQK+tLyXN6epr9sqptACC3t7dTBVMl89ZLJWiRHAIICh9BMjIZURERSX5eXV3l8enWUgWzNSCrz2qNWks7OzsZDFgHSngRCZUkqao2hA5bEBEZpFS1Ug0Q7ZlOpxPNZjPvXda5ktfAfLfbjfX19YiIVPHJ0M7Ozsb8/Hxm/AWu7AelDHI54r7HjOewBqoCZWRkJLa3t9PHvHqs++npaRKbtQwZsGePq1JSKYv7UhKIsDN3rwbVtWyJioPdHxq6b5bf7XaTKKMEccBGzZivrKzE1NRUfv/Ozk6q0Gp5Ersvc28/UI8YQ+NeS1Tsaz2Urq+v06fz3/VkMkoR32GtCgrtCUGjf+urxHYjEp10RRlizO11+w3GQHhbA+bAnLLnnhkRoHTLd1DA8BcCfwSL0nifqXS19j9Clg8PD6fvUl5XyRO9ykZHR7NcqqogYAF4QtC7vLwcT548iaWlpSSOarAp0D85Ocl1zG4h5aiFrE/vqWr2RqORfqDaef0YR0ZGsjzLGl1ZWelLIFRFUKPRyESEP+ZPGZHeZRRPSAL4j12z35QznZ2dRavV6iMd4LinT5/2nUzp/t2zNVNJ96q8gUPsX3hL6Z21gxDlM6tCW28wJal7e3vx6NGjxE/7+/tJTlasZU8oI4SvBwYGotFoJGlPLVxV/8gaNplCq9PpZDnn9PR0KsArocFmGM+qCIcFlGci8/hE/uHVXmZI+FcVjbVETpKWTfd+yWEqr4jIpAYCHkljvcLTcJuxhcsnJydjcPD+5FUYREKEnbD2q10ST0gcSFAYU7im1+vF2dlZHvLAPiLifV6tGqgHKYktlPk6bAF5WMlReFO1QsUVFL/2uiStcfmoXw8E08P1YboeSKkP8JLtRUzob6PGW9Atw+yYdCCH8ayEy+HhYczNzcXIyP2R0VXKygloJri/vx9LS0uptom4l3trBKlPBUeElACaEGRVcVMBMeKHYqIqI2RaBTG1RMR9ciqAPTmvchTgvAaCZ2dnmWETsAMNCwsLeQ+9Xi9BlyCA6iHiHiB3Op3MclKWnJycZB8ugav5iYi+zGXEPfFGzcTBUg4AHhrpCg4ofGQKkS4cpaaha2tr0W63Uxli/s1Xq9VKwsW4AjPW3vDwcH43IAu81GwrBZrgRTkEgkfQYF4EVJRPVA/UCjJ5AnQAjKINeEX6AYYRkQSPXgGjo6PRbreTeBKITE9Px9bWVpyenmYAhciqYLKqAhFaTgwE0vX1qVJ9+4O6yVocHBxMoCYwsifNL4Lm8vIyVQLGUDnE5eVlbG9v58ldCMCqGtvf30+wjTQQeF9e3p+KRaGhVA85Tm2FtDL23mtNCyCdtET5QZ2mrKTT6SSpQqVoP7BrytQETGyIUj92r/buqO8R7FKlCEwE/z5D9ltAoxzSvq7zKANe54oyzPgoY1GmQFFWFQSCA03wqaIo1KiC7EPr/ODgIHZ2diIiotVqZe8xqkfNhLe3t+PjH/94kgWV9L+9vY3d3d1cJ1Ry7q0GMbe3d02glUUKZgQe5sP7BaTWSR37qi6p6lX+QEBYywwRDKenp7mmEXIUkII4yQLrEgmnHJN9QU4ZM4SyYAbh4KRX9kvwSxW6tLSUJc71T6vVSjJmaWkpT/2kHrBXrAfEQqPRSIWtsUDO84sILDZW9p8K0Vhaj1UdZ48g+9lwwRx7W1Wu1B1TU1Oxv7+fpEEtjxXIdbvd7KPUarWSSOz1eqlS3d3dzYMAjAF7yOazQTc3N0na2rsSS9YYvzg5OZlJI7bCfUZEX7ny3t5efOu3fmsSr/z21NRUlqkZJ4k3wTrcw69p2q+foTmtahyJDYmcquSuJK99wg7ZB+bWM9mXx8fHGbD73FoaXhNcxootpahHtEmeVMWrvUnBwqe7D8/Ll/GZyBHjrjcQHwjL8i9VjUkRyd/aCxH3paD6Z1GtSMYdHBxkErGq/15V/iPR2OCpqal4/vx5ll/XObT3EbgHBwext7eXhBRyRbkhvwm7UoFJZiB0kM1LS0t946mXEgzrlEL2E6GojB6+5D/qvas8gA2sKypyc6t3J3toT1Yb/tWvfjVPJURO8If2Rk1wwYWwFxVqs9nM99vv9pLy2MvLy5wviaCqglfKbU+5h26320cMwhewlPJOv3cQFBtHec7nU7BK9ls31hNCFpn+Ub4elFIP14fteiClPsALSAAUBwYG+oIy2VhNU72+BjyyEyS3SIgKlgA2AFWGhZPRLL0GsYD42tpaAjiZA/8GjgVA+/v70Ww20+Dv7e3F8vJyOqWI+9O0rq6u0pkisDhdJIgSKY0sERnz8/PpjAAb4Ab45HCVFwEVxhWZR2Emi8/5y9gh6xAUsroyWcYWacA41wwNAguBRykkeKdoQRgI5JA0ERGNRiPLGZAbk5OT0Ww28wRAZXMCa4FWJUSQi0A/0giQsxY58VrKRkkhoKzPY90AbrUcbHp6Oh29ABBQcopZLS9ChrgP4M79AgyyoJW86vV62ZvF51cAfHV11QcQa1mYchvfAZjX0kAqACBfcEe9JbD0f8GgslNrp6oMFhYWYmFhoU+NI7ioysTBwcFsAG8fAXuIJs+CzKpB3vX1dXQ6nSypVaqq/xgp/Pn5eczPzycZYz3XMgkBAnvU6/XixYsXsbCwkFlRBAllEOVPBZKVwDk/P8+sM3s3NzeXpQSCLUA9ItImUKQIMObn55OcHRwc7CvhQm7Ush12s9piJaTUMGyWdedefAb7UkGyuby8vMwT7syrsg3f6Rn8rUSr2WzmCae1xEkT4MPDwzyNqvoVl898tSSjBifKFD//+c/n6X2IM2uFDzFONVBhO2ZmZqLb7WbfpNovBDluLuqprnX9KrOqCYeqGqh7NyKSTNG4XgPhqr69urpKhcTOzk76QuV7AnvJnoWFhb5+ePbB+fl5zsXi4mKMjo72lTD6TAQ1ohLJ12q1MhhC0ExMTMTExET2sKql2mwlP27sqUCsN0ki98wnm3/7m58eHh7OsqlKCsAgEZHPXZ8fQVmDW2vlxYsX8fjx41hZWYnLy8tYW1vrIxGpyDQQnpubS9+rZMsaUUpDITw4OJiKYX27KANrIquSNm+++WYSMGzS7OxsNBqNfG5+W2DOR1SfhhC/urqK5eXlvsb4VdFRFWbI/Uq2S/YYi6GhoVTdse3n5+fx7rvvxtXVVWKPun/59Zubm+h0On0HL0jSVMVUxSLwAII6IvJAl+vru7Jyc3t0dBR7e3vZQ2t8fDzLd/k1ttVYLS4uxsXFRRKlSuOnpqaycb4/MBobSSmH/EMAsq8Vl7iHqnRmj8zD5ORkjhc1bE0mwGy1zK2uUTZ2YGAgx8hhN5Ra7XY7MRBCBKktEcCm2HvWF+Lp8PAwFhcX03eZs6pKh6lGRkYS31i/EdHXFqG2W4C52DYEy+3tbeLYVw/q0UdKshVWrT7LmBlvPtHnwxfsiHGw9mF96x4RRRmnPxQSGrZXymt8lIDDaGwT4tUYswFKApXcGhdYrRKn1hGMYV181K8HUurh+rBdD6TUB3hRflBMjYyMZN8SoB7YBiJkPhhgmRxgovbtAPaRCgyuQEJWF3gWCAIKKysrefpTrSOfnp7Osh3fSaGyuLgYi4uLCW5HRkZSRTU4OJjHXyOfBLru/+DgIIkEACYikhQAHsnN3UMlpmq2cHj47phugL+WIiCMaukjsN7tdmNycjIVTVXmLHtLTg8MVxKjkksIIPel7K729HCkLoBB5eEELiqWWkdPUi3YffToUXz84x/P0isnu1CrVbWdwBAp47uqUgiZJjvsmY0/8E15pVRPEI+wkC20BpQzWh8CCkFDRH/T6TreyAnBgDGX5QbGNckGyswHUlW/GuCo0WgkgSB7KQgaHx+Pdrsdc3NzCYSUqtlXgsiqRDEOlGgAtc/f2dnJrC9QPz8/n2vXXFdCtQYBvruWaAHxh4eHmSU2fgJk18XFRbx8+TJWV1ezV4h5s/fYD4GVz/W9giekKzAuUNjY2Mj/W2dAormjbqGQo2SgqgK22bnagy3iHjSyYwhGzeEFU8gkY1nLA3yPPeVyz/YK9YmeLtaWwNpasIaN89XVVRwcHMTAwEB0Op0sqVWOhICJiCxVarVasbCwkIHz6elpqhkuLy+TFDFfQDtgT2FXAb0AA3GCmLu9vc0SvcXFxeyxIkCnzLC22QWfGXHfw5CNHR0djW63G81mM0ZHR7OHC9tmDih09dfRWFfmHMnNV5hDa14SgS9TQsKG1RPBKJDsQwrB/f39tHOjo6OZFZfQ2NjYyABuamoq1tbWsjRtdnY2S9erSkqgWIkbvZaoo+wl6gp/7Fn7hM/UWB+ZQeHhdea6EpQR0dfMGj7gW73O3NpTtRQQwaIHkH3PFj969Ci+4zu+IxuHf+pTn8rycXasBi7mr36vn0VE2vmqSIEd7DfJhkoqICHZf6WnAtVms5mHFrCPfFRE5D7udruZ5JMss7cpKxDZbJI9VZXextK4IXnHx8f7ynkR0Hxat9vtO8iCIoYfrbZIg3jzaHzMHZLG+HtemOno6CjVQ4iIra2tmJiYiEePHvX5IglCawcJI4mI/LOGa7ke+8enK8mltoqIJH7gpPHx8Zibm8tkj89FgkTcNxhnz83ls2fP4ru+67vi4uKuAXuv10ufKcHls9jsuh5gua2trSRJYEFYh2KxklawjPVzc3OThDh7TAX26j7Y2tpK2+jniPOKAbz39vbuEB+96KhNEfeStPaIuVxeXu6rUnDf9cRZyi+kfSU7YSl+0z2aSwokc0aBb+zMsef0Gkmm8/O7Ewup7Nm3mgyMiLT91hgc7zlrYhAusg+ocitRbD4kZflA6+bhergert9e1wMp9QFe1ExOmxDU1v4AMkSykownCTEA3uv1EtQgamqGBFhChszPz+cJPX5WjwZXYgbwRtwFDQB4VTOoB19ZWckAmwJGllbZHmkx0B0R2WQYmHFqGlCL9JGN8oeDAhZl6z0/VQoiQcD26lHaiD8y9ojIIK5KrgE45VbGliOV6aJkUe/OwQE6l5eX8fLly5ibm0sSoIJbvT1mZmbyZJuIu+AWIAQAxsbGYn19Pba3txMYCp5kwiiyjJnfCTQ0o/V/ALbb7eaYR0SOMcJFgDAwMJD9lUjdgWZyaj21rGGABCmGDKsqNgDW+/yMsmBkZCQVO8CeDPrU1FSWuTl+fmpqKnq9XsrGnf4nIEC8mGtATPBycHCQBCg1FkUCQCRDa994vecFYI2BPTs+Ph6Li4up6rAmarD5asmqcdOMuTZ7FSxSnMhYIxQQZEtLS7G3t5eqK3ONNBb0UXDak8gNa2l0dDTeeOONzEK6l5WVlTxYQJ8fQFTwbL9GRK5dQJf9Q6YKQOzf2vvOfNRDETTDVYalebfMc1VB1bIhAc7x8XHOtfWjXLCW80REfpZg1BxXMCvDS90jMLBea4CoFIM6qtfrRbvdjtdeey3tYe0fdnBwEDMzM6k2MHYOLTDutdTUvXrvxz/+8SxB3t7eThUtIF+/08+Gh4cT4CPv2Dt2lS96tVeiebfvKKoExxIoMvK7u7tZZlHLXAYG7srb3nzzzbwXZZuOjpekWF5ezqbMVLARkeXQAhDqJfZzYmIilpaWUhXV6XSSiLNP+RAkqrVbfTOiS4Ap+BXkImvZZAQI22x/UubYc4gmdiPinrCtRB4CzHrkX/Xaomz0efyPuadUrCWNAm7lkcgLvZpgCXNHLVqJcrYeCYwoME5wB/tmD7iHmtxDCvR6vWwiv7i4mAE2UrCOAf/C7pnHy8vLXEuITso3itLBwfuTz14tTYQnHFwC6+zu7sb19XWsra1l+X5EpNp8b28vS6MRwPqbUaMj76hRKlljnfGr7kPZuee1jvkHJM3AwH2ZtLIxn8EO2z+ed3Z2NtXasBO/qoG0HkRwFT9v/ft5VdcjCJTP1XJ6yU57ig2SZDIP7IIEHX9OCWUtVdKOCo396Xa7faWlyuWtR/uYCoqPev3113NNI7D4YMlGhJ51zJ7Yu5eXl2lXJZHtfePIHnQ6nT7sYu6Gh4ez/+bQ0FCqAKsCtfaircqoitPsZfuglghLPFYsU0k/9/Tq/qhKMjhEE3IEJ5xt3CSNKC7ZJM8xNTWVvVHZCGOqrJZ9sU/YPQo1tun/D6TUg1Lq4fqwXQ+k1Ad4VdDN0AMUnDOQzOHW/juID6qOqorgGIFmxl5QBHQwzhWIUGyR1lZALHMHpAAjKysr8dprr8X09HRm+QSI/kTcOx9gVWYHYL+6usrmykAVwOS9ZMFAI0l/JYdkijkePW6Mn2yiY8lltQGS8fHxPP1EiZpMmXIdQDbiviyx9n3h6OvYMt5UVIAJ4H5zc5MBFbKMJBkxAYwInvRXoLJCRgHtiLejo6OvCziAtwrEFxYWMnAXaHsmc+Sy1mT0gFqlF5XQoqoT6IyOjua6jbh3bFXJ4TRGQRog4w/pfw1MlJUZiwqST05OMvCxdwQTNeOpHwaiFGB8layRsQPogFDrA3g3h8ZEAO50Gfag7jUkJ7sA/JOksxERkVlqe81+AfDOz89ToWTcIiLViRpUUzzKJlNt1kAGwB8ZuTsOnLJPoFUBJom+sTCP1pZnFkjYu0ryHFaA3K1KLwE+G4lcqI2VEaz2QAWZSnZfzcZWRV5E9JVECMQExuaXKsk8+ttesYfY+1arFY1GI3Z3d+Px48fx9OnTHEeENPvZ6XSy2bLyL0T38fFxHgohUVHVjRGRJ/jVdViVg3wAspNNsKatT/vYurSO7RkN5F38Al+k7xJyhH2iAGG77TUHEvgdf2FvCBS9B7Fb7S81I6LMPuCf7FnPjrCTlJiZmYnZ2dlU/lByGk9r4fz8PJaWltLXVgUCMvby8jLtHVWxPYqcMTey87VcXmCK4FFKXMkUhKL9yq8J5n23kk3r9Pb2Ntce28WuUonwd0goKoVms5nE6vDwXW8aJZLX19fRarXSvttDevbUPkwIEAE3O11LswTJVfFSlTbUve59fX091Vv2n7YDi4uL2XfHPh4ZGUklmLIvJHe1o7W0UjAOx1GNVFXT5eVlX3kSP1qJHp9RfTqfODQ0FMvLy4kV2B6HjVB41oSTNYjEYBP5WDimliadnp7GwsJCvPbaa6l2rAco1JItc2GNU52MjIzkYQkwRT251DhV0h4hCd/YZ9TjEnyzs7P5PHWfVTLBWFYlOHzo3hAT1Y/aX/WZYKbh4bs+f9Ru/IQTE80TXMBO8kc1kacfmlJ3BDMVHRxqP8EESDbkl30pSbe3t5drl82zduEk+6/6WusJUSUJCBdb93AzbKp80WdZF+bEeBovWIBtrqok+1BSBx6DNSjTJJYRX9Yv/823Dw/fnzasZ6MknL3XaDQywQTHujcJhf39/STD//9AvDyQUg/Xh+16IKU+wEvA12g0otvtpsJGJrM6DRlUGQnOgbEcGblrElkl/wI1gUglv4DbmqEWjL4KbKriA+BTeoUwe+ONN7KxtKatns9JSbURtmbdQ0NDWS4naFXSAlBHRD4zMAgEy4C7T05UZg3I4LyBZs6Qc+T4BbTPnj3LexFscvRArtI1JI/xr2V9VQ2EgBsaGoqlpaUMyjh/5RCyNkBcdfw1ayW4WlhYyF5DyD8gWwnAzMxMlqgpXZRZEsCsrq7m+wAIAS7SECFYiQvEIWeumWTt3YMcVN5GxXZ7e5u9CABtJTVnZ2cZgAEjAmglegAc8BsRSQz2er0Man2G9wo+AD89Q25ubqLdbsfy8nI+C7XKzc1dQ2GZXqdeynReXl5m83/BlJ5R5+fnfcSsgJ+c3DzUebY3BLX+Bhiph3xXs9nMcaLQcA+IIoAM8BNcO/Ze0C/IqWVb5st8shMy5L4D2WqfCiCrHaJEqfsWkXZ9fZ2njFnT8/PzfUCxki4+lz2wRi8vL6PX62WQSB1l3yKmb25uMlCwjs2zAECTdGS1gKMq/yIiAxrBaiUYIiIWFxdjbGwsVlZW4ubmri+RnlGC5WazGY1GI1U+SnTc+9raWpKfGxsbWW4n4y1AkPSoCjBkNV/ifpGTyh5HR0djbm4ue2DZM1QMnquWS5g3xCmybGdnJwYGBmJlZSXXtjJOgWg9kc06ajQasbe3l0ENe+y+qQsi7ksxakA2NTXV15SZrbK3KC2oPQSAiFPlRkhK5WPWCqL06Ogo51DgKaGhNw1iRQ8ZzbqNA5IMYe/56vqu5StOqKIaqSoiagr2DnnLz0fcq2j4KNgAEcKGGTP3wuYra9bsXGlzTXRJcGhUTd1jryBnBP21ATflnzXAxiM5Dw4O+oi3SuAgDJrNZjx9+jQWFxeTkNzd3e0jMZEl3W63T+WEqNFPqaptDw8PkxwxPp6X7YOZfD77z9ayXQMDA1kqd3FxkdhI0oqthO8iIlZWVrLc//b2/qAC2IMNGB4ezv4+NYFiLm9ubvoIBiQV21WxgRYHkj1V0cSHjo6OZlN1+0MS1Ovsf2S35/Kd9pukGxtxeHiYB9TMzc2lctn9IK49Pz+FNGKfYAR4t9rJmmyT+Ot0Oqkstg+Ulu/t7fXtVf4fJrE2YUT+d2dnJwl2ONyadN9wkXXIJvL1BwcHSbSyOfphmmtEKLznsxCT7CRCHIk4NTUVGxsbuUYi7nvtiRfYYnPMptunDvaAvdrtdh8Wrslc/sWaQbA5qKi2J4C12LiKiapKrqrEJB+sbRiQv6l7uK6N6+vrvqSW33+UrwdS6uH6sF0PpNQHeDGkCIKTk5O+UpoqcRUsCeZqFnVvb68v8AGua1NIQInx4CQruKCY4QA4WZnXShogDi4uLmJ5eTl7TJ2c3B2DLMioJBAQUHspjY6OpvOgcNHzaH9/P8EkYAA4cn6eTTaKagHAAuwALCCEk/ZvYJSkmSqj1pJTmFEzVSVZBfjmTDYMKXZ8fJyKEpk7xBgiUgChpBIolA3Tb8d9vP3221kKNDExkcdOy25RkekPNjs7m0DJWOpLhmyMuD/uXt8TWTTrEigUqM7MzOT36Q3lb4ol60MAKDCkWhGsyFwpSaA8ks3a29uLlZWVDOIoawSPEXcgqt1u51y6d/03lNohhmrPIs9xeHiYhJSg4+DgIAMVQMtaiojcn9SEAE/EveMGLBEmNQAV7CFzrDlkkvWOKEUALC0tJTBHIFiPbIf/A2lVHedUokePHsXm5mY8efIkbm5u+npIeUZyeeoVARhi5OnTp1mSe3Z2lr089vf3s7TH9/v75OQkSVNrmBJIkKOMDphnP+o+VaoXcRfo9Hq9VGBYf/YTkDo1NZUkGFLLnlfaR62GGELK1jVPVWjs2T8nUAG309PTsbS0FBsbG9FqtaLVauUYU54o2TEOVDAI8cvLy3j//fdT/VKVLGw09QG7iAQX7Aikbm9vc5xnZ2czAFcKSPVYiSykNdJc1n9zczPtx+HhYezu7ka73Y433ngjIiKDNoSkEgvBiRIRpIE/MtaSFPZLDZIQO+yVfm6Cs4ODgwx4lPwijCrhY63Yh05opbTZ29tLBZV9bV4kUyh2Tk9PY3FxMfvoLSwsxOLiYu51RLUDIYxrVTPwz/aw8hpE7OzsbCY8JJrsbQRbDSCvrq5SMVJJKfsR6UABy87wkRI5ytglPQSLQ0ND2S8NuS2AlCip6plKJArcrWlr31zUhM/FxUX6E0Fz3dOtViuazebXlRka06urq+zbyY5RYFSCXWlZp9OJVqsVNzc3uRY8GxtYg/6I6PNpVJrDw8N9JNAv//Ivx9LSUszPz+fe84w1SWVe7AEqypWVlXwPhc3t7W0sLy+nf+CXKuGDSJqamspTVPkzwbr1zE6bG/aP+kaCFMGIFLBWauLBmqRsZVd8VsTdyahLS0vpL5DXbKt787Ojo6PodDrRaDTSVsKrkqMUm0gaSiLrWxLz8vIye4pJ0tQSO76XgguG45v5fiQ/3+cEYuTQ0dFRjIyMZB9JJyBbS+yiJBQCi802ntZGLeu0flUuwFjGu85Hp9NJ/2A9VP9mLSK7/IySF/EF17BRtZoA4Wrf1ViEnXPYRo2JYE2qKjbD51RF9+joaB5wUvePPdjr9WJhYaFPYWXPWtfW36s2gA/8qF8PpNTD9WG7HkipD/CqgSHnyhBW+Ww93QKw49ioIThCQSxgKrtST9bz+VW6So0Vcd/kVNAXcX/ynvdr3Hh5eRnLy8sJ9hEDSig8BzDJ8CObarmCrFdVbEREOgqOmXPgjIAmIA8w8IdTQbghkM7Pz7OPj5OA6j0JwIyNMgjAIeI+02PeZNgAIKUoiC/9SGT/a18MhAsgBSR5dvdUg4PFxcXY3d1N5Y/se82OnZycxNbWVlxdXUWr1UqiSPkIML69vZ3ASzCr9E1/MEGT7CUQY+wpyBYWFmJ0dDTJO7+nLKk9C6xfaxyhp3QAIAQc6+fVMiJBPXWHck2nqJF5CxrtH+8XRLVarSR2r66u8vQoCjwZvUqEVgLZfFlPQFYlLAQz1HGCakC7AlJZXEQVhZK1Y71brwICY2bc7BWKjpGRkVhcXEzicWxsLE9cWl5e/jplkTlCTBoXNsK4RPQHVPY+As7zIov1BhLA2PNIiL29vXyNNaR0ylqQMQVOrUXrybg5trpmidkkRJfAVYbWPblq1tt7avmIe7Q2ZmZmsl/P7e1d6R7Q32g0YnJyMoPURqORip+Ie4KWaoMCVHCv6XINYmT1lR4J6gVO1WZZJ3qr6DOoQfTY2Fhsb29n0gHxWRU1GpcfHh7G3NxcXF7e9cwbHx/Phr4jI/cNd1dWVr6u9Iw/rOU4lF8SDZU4YRftKYmJy8u74+hlyAcHB/NUOLaQkjPiLtFg/XsuRCQy4/T0NHq9Xj6b8WTv5+fnkxCp9hyhaG1dX18nQbq1tZW9E09OTnJP2mvsojU6NzeX5K51GRFZ4m1sawBrryKTzQPfLCATTCO7zcvu7m4SwQJACR/22f5HKiDGWq1WXyLMdwwODka3280kAMzBN8M2EZH96NhDttr3uYz16Oho2vfl5eVUmRpTNsgY+llNkNnDiC44AammbQHbyg9JAtpPSrJqr0Pfwy+MjIxkj6KpqansW8WvwYbspCQVUpKvlvCz5mFDZAHsUn0s7MLHSFQhN6hwkTdsBlvu/TXJiMyfmJiI1dXVVAEbZ70IzQH1rXtEDNekqvVgLGBDa+JVbGktUHFSuBgX39XpdPr2ObX0wcFBRNwTNw6KqUk04y5pBpMiOdyLBNb8/HwfmePwmqqq9TyURfBIxX3Gge+grqM6ZzetM7a0qvp9DkK9+raKs/nTmlAUN1hz1n9tFcEvVvtFgTwzM5ME2MTERBI/bDe8pyyVX65qNLgNyciH+cxKZEkWUJYhn3wfG1bxH+xkL/i3ff1Rvx5IqYfrw3Z99Du9/WO8BgfveoRwKNU4c8wRkQSEgBwgp0qqGWyBAmfzarmFa3h4OLMqNfDxHmqLRqORwdSrAFQWi/xY0Pv666/niUsVEFZCqII+JTpADyBZQXMtCTo6OkpZtoAYGeD18/PzCb6NqdNlZN+NYz19D1lXs09q/REpVCICVqV0AhjKGONoDjl7wblMLxVVr9eLnZ2dvpKLiEi1DxCAqImIWF1dzaz80NBQPH36NI921rdkdnY2JdSbm5uxv7+fmeGIe1XDixcv8pkjIgkpQN0fxFzNntX3ATTWNAAlOK/kFpBubVeV19nZWXS73TzCPCJyj9zc3CTpV0kJIJp6A0ip90zVgERCnlE/KEWppy1G3KuYBLTAUpWWIySsTXvLs3m+y8vLDPqrqkZwYC3u7+9Hp9NJArkqCjxvs9nsA08UTPUzPSvSoSrvlE/JmrIZ7NDs7GwCPsFNVWJq9ksZV5U7ggbzb58BzfYHwhfIFsRRADrMAaGt7KSW95oDWXRHzwOYEZEkAfXb2dn9iYIR9z1BlBMA9gIQ4yrIcG/WfbW/yJSquhKAIpQQUJ5VE+n9/f3sEafpufJGYzY/Px8rKyt970dK+D5BukDXGCPaZenHx8djeno6AykA/tVg2vxb9+ZjYGAger1ekiTvvfde9Hq97NvnPey79/u8Si6zj8oB3YeSRTaHD7XOZ2dnc8957leD306nk+SzYJoK1BiZS6QmIoYvabVaMTIyEpubm9nEHAlYiVDP7l4dEnJ6ehovX75MpRHFbH0+z2Qtsgu10TFbJ2BDmvi+qv6qJV2C56qmepWs5GOR6sbD8wlUa7kU+zwwMJCJDySmkn6Kuxr8uD823V7mo92XJuzWEVUzO4rkX1payj6QTqJlB5Vsu+qeqOvT3jVW1NvwARtMaVNLwart4D9rWV8lc46OjqLVauUhMlNTU32JmsvLyywjrX0z7Qv9vCoJMTMzk4q1Sh7AZ5Q+nrXX68Xk5GSSivaXOUKWso1wJCLM2rRnp6amUilHFY1M8vzGoCYZ6s/YFfZheno6Zmdncy263Bt8x99QViJnrbHh4bveUO+9916fYqwmvly1PURNTCKZrUH+zj6y72ofN7jVup6eno719fXsE+Y+YQ82x+fZK3ASm0XNtb29nfYMAU6Jidh2r5WYRKgam4q3a8IA7hoYuCvN5d/dI2yHhPK+29vbjDOsQz9/FVNXrCnxKd6RkOOPfIfX1/GxXpSuIgpXV1cT+8H8bCx7yyayg9XWVHL/4fpoXr/wC78QAwP3p2M+XL/9rwdS6gO8ZAKQUpQeFeDITgJd1AKM/tzcXAaIFBHABEcvc6eBMwfKWXNEZOcV9DDg8/Pz2QtDGYDMGEcIeC0vL2dTWyABoAWCazZHcCobMTAwkD1cOP+qFOGQOYrqvGttOAJqcnIy1tbWMniSgVPOVvtuCYpqM+NaplPBUw12OcuI+2N+K/h3f07Bc4/Hx8fR6XT6GpBXKfXExEQSgwL3g4ODXAfIAs8+MTERi4uL8bGPfSxWVlZiaWkpVlZWMgjr9Xrx8uXLaLfb0W6381QfTYX1E6oZ0FrmGBFJiFX5s7kXKJjnGjRqNg0s1x5KtUwLeAWqKiFqfOoatgbtG0o05Irg6vT0NPb29jL4QzbOz89nz56qTLMWfKe5t3cFJdZUROTzy14KeirAcflsa6aSTko4rTlKhvr9gJPnBIojok/VYPx8hquWAAH/ACmlkuDA3NZMKcLFfQGunsWaNy9+b68IQBDgVd1hLIeG7nutRdwFsNQxngFhL4Bm754/f54gugL7iPseIycnJ0nS1rEDeOter6SBsVf+gySoa8T9s43Iz4GBgeh2u7G8vJw2XdAroNrb20tViPG/vLzsa9o/ODgYc3NzfU3J2WJrwVjXINOet1atv5GRkSyxoMwYHr7vq1aJCeuq9g4zR/ya1yvtvLi4iGaz2XdoBZtQA3j3WfeKLLl1Vclowc3k5GSsr6/HN3/zN8fa2lomU5aXlzOA5i8o717tEyIL73fKdfgPCoPj4+Mk8c2hYJEvEUQZWwTC4eFhrverq6s+crXag3pPdU9TNCEvKHkoWygHlJLVPkDsSk2oIAT9nxoEqY+AYrNGRkbyZEJrDhYwtxRr29vbsbW1Fdvb23mCZG0Kbo7ZA/dTExzX1/cllJ4XeYjgeBXLXFxcRK/Xi263m/5ofn4+E1N1nO0T9qiSIwJ6z1bV2RJJ1ju7UNWb7Fm1XxGRiSh9ufhFxBRCxn5QDo2k1/MOqVwV8GxuLa02rvVAhmoP+AX7f3l5uW8fI6mNebWJfidp9SoJaq8vLy8ncVETpDVBBsNWlY8kofswJshTZI/xlmBlr82h33neqvqGC+rPrY/aT4t9hdlhTPdZfT7S0VqlsDVHSChVAxI8TrG2Jo0rfORn/IESa/3xKlarKnKqPzahkmp8qSQ31S2cxl+yM3wOghbhhKT1XjiOag4WkLCKiCSd4C1jCf9We2EcrUVrTfxirVRFJFxN0et3bCQye25uLsf8VXvC5n/UL3PzW/nzj+p677334o/8kT8Sr7/+ekxMTMSbb74Zf+pP/ancV64vfOEL8c/+s/9sjI+Px+PHj+PP/tk/+w1/N5LKn4mJifjkJz8Z//V//V9/w5/9cH0w1wNV/AFeHDkp6/X1dWaDAGjBMRb/8PAwGX7gGhAACL2nBqlVSfAquQPIcngcGUc0Pj6eWYcKHmVHvK7X6+XpUIJUQEKNPyfHOTH6wK6AUpB1eXmZhEqt6a7Zr1puA6ADI0oNBChVMbKwsJCOCEiqRFe9t+rskEFINoRazVAjIsyBZ+X0awYIKPD9gg/BSj0WWGmF919dXWVphz4stbQLoVGzeDJXxsXzapiOoDKvwOWrJKCA0zNfX1/H/Px8PvvR0VEfyK/O3s+sJ4GRwGlxcTF7KFAIjI6OpmqIMiwi+kAVOXjN0AE/gLn+QQClY6L39/f71h/wDLhbyxH3pAbwVINjwBpxJui+vLzMXlR6pwlGEa8VgA4NDWV5KRLG81XCzdg6EclJNFVyX0+iq/vIUfeetdlsZumD55VBrYGE76yB2ujo/WmKAAMSh9SePXo18ygLbU1UNU0tHxD8slHWkzWAxKMwUjZmPl8NnOqes1btcUC2loQpURRI1eC6jqt7Ehitra0lMUhRp+zq+Pg4Ax99YtjXevKnwIPyEdH77NmzaDabSZAiQF99VuNdS0r9zl6hDpyZmYlf+ZVfSaUl1WmdQ3tPTzqNhZW0UU3d3Nxk+RsCk0/QMFo5DDtnrQmwlbpRhXpGBIP3CTqqjeRHapIGGacHjrVsLLz/5uYmT6ZUOrK9vZ1zxk+Mj49nICnLyu5eXl5m+WM92ZM/QJSYL/7B3FXCo655zcPZIHaGorMSX1VNA3c4REKwbC/U0m/PYG1TBiIc2SWfbw/1er04Pj5OMgUmqeWcCKVKfnim2dnZPLTBGmu1WtlTR6Dpedl8pfPsxcLCQvaMgrPqIS3WvfJAZXWDg4N5QAu/MjU1FZubm6nkQ+wiI6vKEsFay5fsWfvm6uoqVldXM4Fh/mtjZvZI0qbRaMTc3Fz2K2Iz7f3b27sSZWWXlVTiu6s/HhgYyD5M1nxNRLE/cBZ/5v75O+t9aWkp9vb2cr2w+/AgQsGcu5eadOTX2TqvVyJnrSEp6nhSAM3NzeUBGRcXFzEzMxO7u7tJzFHy8/fG2bq+vb3NZuJObJMk2N/fT+xd7YoDYap/9mwVY1JaS/rOzc0liUU1ZC1XUozNZj8RLuzP8fFx9qurSUL+Bj6W/GE32XQ+rCqWqorR//mIqjCWxGGPJf3YaJirYnZzWsuUzcPR0VGsr6+nctf86lvm+SlVjWdVmXmWdrudJe2SEJU8pJC35t0jUnF8fDzX50f9+q0STN8oKfXpT386PvOZz8RnPvOZr/vdV77ylbi5uYn/6r/6r+JjH/tYfOlLX4of+ZEfiePj4/hzf+7PRcTdoSQ/8AM/EL/39/7e+It/8S/GF7/4xfjDf/gPx/z8fPzoj/7oN3RvERFf/epX89Ck//l//p/js5/9bLz55pvxe37P7/mGP/vh+sauB1LqA7wYgMnJydjb2+tzXFWlI4CTyakZLyBGsAYAkiQDHpwDx825AYKAMEACRFdZOzB8e3ubJRICDuTH4OBgOqCajalBEuDtZ+5ZMEi5IBiqmTfkRc3QG0vOU5YfsJNV93ukR6PRiIj7kp2aQanZr4jI/gyCX6SB+apBkvtyzC3wI3MjYHfKlTIHgKSCR1logRrAJjATXFxc3J301G63Y2Dg7oSaiMi1gESjvjEuGisj6oxBs9lM0CV7CkiaJ2AAAQREIyaQckAHcIbMQpwg+6gLlL3IylnjSLzT09O+07qsWUBDYEplpYeMsiTPXcub9MgCzABMnwec1FIapJ/5BLqrChABW0s1ZfutXfNas81IU4TUzc1NnpAHONlDVRVRgyEBse8zB8gRn0Emj+R4leC2/wQWgvPLy8uYn59PUB8RmcGPuC+tcl/1+xFHde7duyC7KmIq2Sg7C8jWfhs1K65vhwC19oOh2vId7ontrZlb/65qN3NXFTGvEl+IdGOGUDg6OsqGv3pJ+b2TBTWP9jOKjGpfBEv2UE061J4g/u3+aqmbMaHmWFlZSaLGs1CN2DuCR2oM69czIXiobNwr8sWeUBZKjcS32UeTk5O5RgRtfAzbUwl+JWeeNSKS1D46OkpbTB2IeKiBGrLK3NnPSk+R19fX11k6PTg4mOSxgAkxhsxsNBpxdHSUNgl5L7Cz95FQ1lZNKlH9sVHI9FoSw64jP6wL+46d4reMFXvAnlnfNRhV9kgJKgCtiSHEuOQLVWPdL1V9YK1SefHx4+PjfQ2LtQJYXFxMgoZ/55ci7su5KLadvKek/fDwMNff6OhoKjjYtoq9qvow4p5Id49sCEK9jhXbb/ytQ88tKYHgRk5WgoBK8vT0NLrdbp5gS51JZV9VvPy1cRfQ81f+ze8Yc/26VldXcx49M7xmDdYxgFX0Tbq9vY12u539RWvyyMUv2MdsDzsKEyEclDQfHR3l4TpwM5tjD5s79hj28p2jo3ctDTS89gz6DMJ3iDhq+qOjoyQ5HFhTcRt/xOZW/2ZNwCj8ie+mjlKyjSC0f6si1FpEtCqpV7prbIxhLeVDTmmPUQll+9NYw+T+9v0a38MDryo7zZvWIpXQRNCao6q+2t/fzwSFeR0YuFPQK4GWjDTf1ce6P2NlDfsbfhdD8VsU4ZKDtUrFuvQM4oWP8vVPipT6+10/9EM/FD/0Qz+U/3/jjTfiq1/9avzsz/5sklJ/5a/8lbi4uIj/5r/5b2J0dDQ++clPxt/7e38v/tP/9D/9+5JSf+Nv/I3443/8j8fz58/jn/6n/+n44R/+4V/3dUqsIyL+7X/7347/8r/8L+P/+X/+nwdS6rfB9UBKfYCXYItio54wg/x5NVhCYAFFiCin5FUjCmgK1hgcASgHRvlT+2nc3t6fJAIMyWQIhOuJMpeXl/HGG2/E6elp7OzsJKgSiAE5AsYawJEHczCcoXKjWpfPgVbjKVgCKgWPANXQ0FA2TOWoI+4BOSAElFSVkgayHJnsm2wQAM15A0CCAgBaIAfkCsoc42sOqgKqEgoRkf0zarB+enqa0uPz8/PY2tpKAMD5e56pqalYXFxMQOQe3LfvA+Bqds54WbcVCI2O3h3fbR0CbZQPSC3vrQSmoMIpS0CasstXg5naD+RVNZseDk7eqtlKgaNM5/j4eCppDg4OsiTRfgKIqywdEDMXEZFBNtIQIEY+2ntXV3c9jDY3N3PPUTkhxoyxUh8gyDMqBXhV1YeYkwms5Vn2LRVMVShRqJ2fn+eYs0X2CqAbcV/S+GppikbkiISFhYUkPwDxGkBG9Mvuza/5159ncnIyS/siIjP01r69bsxrzwqkfA02q6oKILXfaxLg1TUvO1z7Gb1qq6tqyvwiQoyH3zkIgB2nllCGIfgfGBiIg4OD6HQ6GXxWonNsbCx2d3dznyDtXiWiBEE1CWA/Ils1X15cXEwC9Y033sjyGHayEqE+S1banqfYFAiPjY3F+vp6LC4uZjCgT57EB/LZfFcSjfJHwsI6sYbNwenpabz//vvRaDQykFKyg5jns/jPycnJJI4EkbVBt++0PqgXkSiUiXqpuX8+DsGrWXodE+u4BvoIo7rPawDHRvFLyCnKVD+XILDuBV3eb1z8vtopfkuyy3PZBwiPilEE/xJWToBbWFhI0mNg4K7Xy+7ubpb5sHewhlIa+3hiYiLa7XaenuhgAPbV/cIGNzd3jeqXlpbi8ePHsbCwkGpy5T01MWJN2+eeHf5AdsA4EhyvEk18OIU221CTZ0iriEi7bJ4GBgZSycUus58DAwOpXEZq+u69vb1c68bZXEtEIZwi7oPuqn6BiezLq6v70+rsO60BvK9iKIG9hAF7YDw956vrhb1GKMAECAlExNzcXNpsCQ54yfxVVXNNoMBC/l/Vm5ubmzE2NvZ1Cs6rq6ssmV5cXEycQhmJcKskKlJbEhEhWNWJ1uni4mL+3HqxRg8PD3PsXyV9qpKN6hlGgFdePaXQpeSWramkUiXiam87a76q6qqdGBwczMSJ5zg8PIxer9enOmTffZf3W5MVD8I68/PzmVT3emXVEZF9xCoWru0NxCrmhQ12+EFV+ZmLV7HR9fWd8t+z+uyP8vWNklIOCnC92jLig7r29/f7SMK/83f+Tnz/939/n5/7wR/8wfiZn/mZPHXx1ev58+fx+3//74/Pfe5z8aM/+qPxf//f/3f8u//uv/v3/d7b29v43/63/y2ePXsWv+t3/a4P7oEert/y9UBKfYCXzENVPSlXq4EO1c3Z2Vk0m8089lkwL9g7OzvLjYrIqFk0YFm2R9a+BiqARM22uwQ4DDoQVrO7vV4vJdr6H3As1Vn6XABMcFxPgOKMONyajZGNVl4D3NWeBQIG2XoGF7ihEtDDQYPSmlUBDuuzA6y1NK2OA9l0DUwQJ0AyUOF+zb3AAqgVIBoTGUKE5osXL1KdsrCwELu7u6k+MM7IM87eSXpLS0sJSE9OTlI1oP8LkBsRqTCp/UvMWW0IWvsmIDeMZ81wA2KCWM9LmWK8kUEk75QO7unXIwIQEq6qJlhbW8uG0sqn/F4Zg3v1HAhTPZ8QNZ4ZKPIcEdEHkq3PiMiMoOfwOZXAnZubi/n5+RgeHu4LMmuQah8g85CKghD7rfaasz4rIY3YXFhYyO9ZWlrKwNU9CGwFBQIe9zM4eFcWNTc3l9lrc6+Hibk3/zUbyU5VuyD4q1lQ9yyYQWQbQwS4zzo6OkqbaJ3W8gmE+8TERF8TZfeI7KbkAsKvrq6ymbM9prSP3dSrhNoB8WO+lDsjlJEWjUYjyfj9/f2+5tfG3VzJXCudq6VEAhljZVwFBNPT06lEUK4wNjYWq6ursbW1lc9lzuo6YzfZONlrtqkSV2NjY6lEcI9ew95F3J/+xK4isPb392NtbS2z7xSLAiaKEifA7u/vp6KCL7u9vc3+gZ1OJwYH7/pxIRtrcGLfI87YY1n7RqMRo6Ojsbm5Gevr633riuoo4o5oXVhYiImJidjf308igj9CLvLNSKD6bGyMMUG+Inurb64KJ4E3Ik6w5burwo6qpBLrVRkIX9RkxKtEF7JNGabf2QvwDdzDPttnAwN3/XTYSUEnHOJkuhrAs5e+6+bmJubn56PRaMSjR49icXGxrwk9/+DnFNEIzbr3+X3fyS9MTk72nXRYMUFda8YIFqiKmYhIPKO/UaPRyB5eZ2dnsbu7m2OACL2+vo69vb148eJFvPnmm0lQtdvtDLokoCSwkEOwA/xFcefkxzquyAS+yr6VWKs29/j4OFZWVpIk2t/fTwLEQQdeW21wVdBYk+w7zDs3Nxe7u7v5e76cv7FGJcKsHRisJkYjIucdDpmamspDGOw182fPKP9m/xEaiOCZmZnY39+PiPuTQO1ftvLo6CiJev2YBOtILOtnePiuETufq4ecz6JSpAg2buyEObSHjKcxqT1AawKGPbA2fB97XXtT1YoMPfbg9OorqvqoKv/5RuTk4OBg394/ODhI/+bz+bqjo6N8lrp37S2EJmx9fX3dRw5ahzAz3/pqcstYIMqqwvDh+o2vx48f9/3/T/2pPxU/8RM/8YF+x9tvvx1/4S/8hVRJRURsbW3F66+/3ve65eXl/N2vR0r97M/+bLz55pvx5//8n4+IiE984hPxxS9+MX7mZ37m61776NGjiLjvf/eTP/mT8f3f//0f2DM9XL/164GU+oAvznBgYCDl6oLGV4NRJJCgo5YUAT+CdGCJ468S7urgKBKAI06D49LctQJtgc/5+Xm02+3Mbh0eHsbz589jYWEhiRTgGbAA5qoyqkqeZRYPDw8zUOToABGOo2bEIqIvEDIG19fXCcy91/PWnloAqOwgCXGn00nSgVOqwC3ivj5dJhjx53VAIeJDMC7YAcxl02tW3nwC4J4FMNjf38+AR8mCYLuSKLXxdx1rTv3g4CC63W5E3J2657s15QUwgBdrVL09OfnQ0F0vnwoAZmdn4/j4OE8WjLgnMmRLkYiAtud9/vx5zM3NpYJkcHCwr4+SNVAJHiQbAsCaEtitrKyk+gCJZo1XtZH5E9AZQ4E64ifivgQUwKk9Inx3RGTprF4ZSIfJyclUrNTTAQFchFNEZK8VijBBnlPwyNXrWhFYAve1hKaqMwSUtYRUQIOUQAjLgDt9ExFde0NF3Je+2hcV6FmLvq9mgwUVnsn7jQPSjA2t+/5VlRbyhK3wnRW4+xm74f7Z4ZOTk76jvJFMFBs12+r+I+6ISMG80ppOp5Og/vr6OjqdTpIYyAlZYcS+NWI9HB4eZjA5Ozvbty49YyUyzb/xkDk3nvZwq9WKq6ur2NzcjIhIVUlV23q9YJ1do6iSjR8aGsq1aD8Jpo6Pj5MAV7InKKe8QNQhsBBnNduOAJegsWYRLe12O66vr6PZbOZ6Z2sF3XWfIoH4y/n5+UwA2RtXV1fR7XaTaJI8qESuMTLurVYrxsbGstk3dRlffnt7m0Sc+alEE5/gvTVArMooAaP5r8QWEvj29r6cFTHtOyho7TVkTQ0q7TWfpZTI3ExOTsbp6WkSvbVcUADo/iiAlpeXkyB0b2y88ZCkmJ6eThvPbs7OzsbCwkL2noqIPoxh3/gMNgMuMHY1cVaJb+PD1vEtxq8qNewBgbJ9x6YMDt6VuV9dXcXi4mK0Wq0ko3d2dnJdW/vs/eXlfRP7evKfuVlYWEiyeWhoKIN45fzWijnwM3aklhxXVbz9hiSm0LZf2NmpqanY39+PhYWFTNLUXk0wx8HBQT4Xu17VpMfHx9kPjI/gQ9lESUT73xj7LL52cnIyFaXj4+NxcHAQQ0NDsbq6Gs1mM9ffq4QKNbTPs5bhaYpZpAjfpyy6nvpYyVyYux6aAO9qiwFXVDIHdrcP+F2lrch5GL3GDtWn1p8Zf+WJEhjskMQsv1bni02pJLkElPuGi/XhQnjxQfwHTC8R5N4QRNYXXwrruEf3rsSKX0Zaw4JsNEIazoRD3Xf1obCin32Ur29UKfX8+fNc1xHxG6qkfuqnfip+6qd+Kv9/enoaf/fv/t34sR/7sfzZr/zKr8STJ0/63vfy5cv4oR/6ofhX/pV/JX7kR37kN32f9fryl7/8dWqn7/me7/l1X/u3/tbfipmZmTg/P4/Pf/7z8WM/9mPRaDTis5/97Dd0Dw/XN349kFIf4FVl3ZzLq8bP/4FXmahaHibrKOsLqDK0vifi/phoAd/+/n72JOJQOIypqak8uUh5iKz61NRUtNvt2NnZifX19Tg6Ooput9t3OhWAxsHUoIajr4Hp9fV1NBqNfGYZH4CkPotyD89ey1c4R06tjgVJNielhK4aYyQLlYlytJubm8z+Ad/7+/sZ/ACo5lZGpzYTR1bI8CEiBaD7+/t9p0wBI4Cj55PNazabsbu7mySDI+KVhI2NjcXh4WHeZ6/Xi4GBgb5M8YsXL5Jg0vhRr41X1RDGH0gX0NbyJ+VEVeYvGPLeWioCHAN75r1mwWZmZpK4q03zq4LDewQqlDa1v5bxJpVHxAB4VDTmVrBtvQqgfV8FVtb+zc1NZueVCLnfWmJrDoHbVquVYFiWspaF1KC7AlWlmcooZYcrCQzYCeorcT0wMJBE5PLychLKFANsT+3dULPmnHUtrUQyCoKQTRH3x7BXObysJzLw9PQ0lpaWkgCw9hFegCS7hgyIuM/Gy7YrdalqRqQ8m1sJJYSJeRPYUZheXFxkmZtxAKzZNuAeIefn+hmdn5/HyspKjIzcNcbe3t6OpaWl7HumUbSAUkBnLVS1iUDB65AtEhaVJJ2eno6pqak89cleowI6ODiIycnJaDQa2e/Kvq6ZZJ9pTS8sLPSRrzLZThcz/ta/gFz5WSXbEHCSJwgIQSz7yr5bj9Sf7Do12u3tffNnJRwIjdr3hL1BcAsUKaoEXk6mFfBIDgwPD6eCgkLM/CJSPLsgS/CsLPHV8siqkqoNs6tSGLFKyWiPSRiwW/Yvm16VQYiWqp6yZhHknsvPvdZ+HxoaSiWh/l67u7tp/yseqL2Oal+hmoxRil33owMn9LyrfZ1qiY2g1H4zPtYFxR1fUIN/gbQxrmRqROT+438E8XVs7Ct2Sf9IPoqybWZmJk9b81oqEomsqtqenJyMlZWVnPODg4M8VMBzI5sRWz7XPb2qYlSuhdy5vLxMktf6M0dICJjMfoZfjQX1y8HBQd9hAmyh9W/8qjKvEi3uR7+2paWl3P8SlrBOJXCvr+8ODaplpzBWTdho3D80NJSEBSwQEUlgjo2N5fPUhIV1z04acwrDiiWpkCj/2RRzA1voY0WdZv1pvSBJU8uXEEZTU1PpF+wjSdVqD6wF36sxuc+gMpUYRuJa98jLWtqpD+3z589zDCmIvUfsUfc6bK9dQi03NQdsX8Xo+tYNDd0f0EEBBa8bP8Rap9NJPF5JZZ9Z/TT8bD87pOGjfH2jpNTs7GwfKfUbXX/sj/2x+Ff/1X81//+H/tAfij/wB/5A/P7f//vzZ2tra33v2djYiN/9u393fO/3fu/XnX63srIS29vbfT/z/5WVld/cw/w61+uvv56E5yc/+cn4v/6v/yv+zJ/5Mw+k1G+D64GU+kdwCbSRSsAYwFDVGTLGVYYqE+ePQLiy/jI3QEHN4HKGVZ4bca/+IMd2CsjNzU2WPQn4u91u7O/vx8DAQBIxHDMwwykzYJRPtUwD2Jyens7PEywKgtx7BX/uWwYNYI+4Vzq472azmQowpBvgU5n90dHRmJmZSVLq+vo6FhcXs9xH1odzE+wDw2NjY9FsNrOBo5O1dnd3+9QIrVYriYqaIaoqkog7MLuzs5NBd8RdY0oZZlLlmoUTKOjNgQjjoKk3PLuGvgIWIEfJiwCRGkfJDlVQLRsSoMp6C8L82z3XtW7OkCgUCq1WKy4uLrI0R0ZN0HB2dpYlmZRI1ob7ECzpzWTOBPOaTCPWBM2Ao0BUaYLT0jQQlW1FEFoLwJjyIxlNn0FtIWjyuRGR5QUaOANLACcC2ClD9lJVjNnLgDPCxh9gXf8XpGfEfaYLcPZee85zKgOh+KmlrexHLYWp5QpVtSWwplDwt7kUSFZC276xDgRQc3NzuUaA6U6nE61Wqw/sV7LNmCq3Q4QK2Ko6T+kz+4tYA7yRRUo2BJuIUUHTy5cv+8gbpIf9q8cOBaS9JWgWdNRTmowP4qXOGdDOplHmVLWIk0m73W7fnhWMeR113MXFRR5PzwYgBAcHB7NXihIagUftLWOPVpWwoPrg4CDXgvUlkIm4L1cHHPmd0dHRbGo+MjKSc8ZXRESqZ90DZcje3l76zFarlZl/CoiVlZUkJGswSylUScF6Ml9VPEsEUFPwXxr6VqXn4eFhrkv73TPU8lyBojGsKs6qeKhEkaDe4RwC26oqMC6v9tCxb/19c3MT77zzTqqpkZpVeXl+fp5+gf2vpBuFLjLu7OwsXn/99VSRahFQk3rwRa/Xy6TB2dlZBvjUFYgO2AYmYhthppOTk5w3wXLtJcaejYyMpPK19uCydo+OjvoOoZD8GBy873PIbrNH1nfFSOfn59FoNGJ+fj77+Am82FBlwNaTknT3zOd6/koCUqGwKQJ39qHiS2tbiSI7J0mqhycfZBx8Vy1dZUvgjpubm0wYOB2RvaTAM/96P9n/xquWqCGAql9ySh3fjQRBfNjnyF0kh3XpJMbaVgIGMc9UTzDB9PR0tNvtOD09TcJ/fHw8VlZWYmpqKhXgVcWHaOOb7F/+0MnLtURc/yTKuqoWtp8Ql2wEkg9uZHcGBweT2K/EoTE2NyMjI7G0tJRNzh12ghSrhKyYQ0KH0rSqm9kR38NPsXeITth8bm4usQkMUJV31srR0VEmdwYGBjJRINFFTSUhVJMPcPhH+fpGSal/2EsZvGtiYiJarVZ87GMf+3Vf//Lly/jdv/t3x3d/93fHX/pLf6kvoRlxp3D6D//D/zCJ8oiIn/u5n4tPfOITv27pXkTEt3zLt8T/9D/9T30/+7t/9+/+Q91/VRc/XP9kr4/+rvzHeAH5tU8P9cHo6GgGrMPDw9Fut/v6MiA+NO6zSThpGbcqJ68BKKBH4j05OdlXPsiQywouLCz0yWUFOvPz83F4eBg7OzsZzCC4ZLploRzHXJ0aib/gFRgXqOuVwimQ6XNqVXILHMzOzmbw72cAWcT90cXIIsSDPj43NzdJ2ExPT8fKykpmd+opLNUhy1QKtDhRWcClpaUE+4C+bPzy8nLO+9zcXGbcK/lUgwHPtLe3FxMTE7GyshIvX77MTD+nDgAiaYBRGXxA2OlEGofOzMzE3NxcgpZut5sKnIg7B0LFw6FPTk5mI0pAFXCg0HKqmoAdSSS4RvKtrKxkydi3fMu39PXaiLjvUVD7ZtVsHuIW2Wu8EE7mcGVlJUsEjo+PsyxB4LO+vp77CikxODgYe3t72atod3c3g1VBVSUX62l79heSxlqx1mVI9ZdBitrzW1tbSdgAzpeXl3FwcJBzpeE8kIVwMee1BNA67nQ6sbi4GENDd01ckav2JKWQfWudVAUZEPf8+fM8Fa7OkWwmcgVJJqg/Pz+P1dXVmJycjK2trVhcXEzliBOc6hxYP5716uoqVSuyn0NDQ3FwcBCtVisBBMKoZtaBdTZJoFKJtfPzu2bwALQ5iYgkyyPuyXEEAXJCb6LJycnodruxtLQUIyMj0W634+LiIp4+fZr9SdrtdqoYzBdCU+CitGR+fj56vV7fd9Y94V6tM6ofJWyen/p2dHQ0++4ow2WfjZ/Eg0CL7Z2fn4+xsbFMLszMzMTU1FT0er0M7qh0+B5Z/6GhobR9AlikXiUNut1un3qOPaS8UkaFsEGKLS4u5tHgVFLUXfYrnyuAqeotqgyk6tLSUt8JXI1GI3taUWpdX19nI2rqLP1nBgYGotlsxsjISLzzzjsZiFeS1p6OuA/alTdLJkgWHRwc9KkPqeK8335G3CLRrBt7++rqKjqdTiYj5ubm0mdUkkEAXMlrRJ51T6V0fX0dMzMzqTJGzNi7iC3qJva00WjExcVFdLvd3NvIOCRdPeCFvWXzvN5JlhSIKysrSSBTTFrb7KbkiwMx+H42mx9hHxAoPgNO8m++kl2qSuajo6MkmRBA/ICxOT4+jm63m+pNfphi0xzbqxJn+gMioNgSflefUr4L/qMYhrn4GocesE1IGeQLRdt7772Xtsl6gxEQI+w3YhLBLfg3hjANxa5ntZYqieeiNGZ/qaUQe9SJcCLlfcUBVZXn1GLzA++xUUgdY4b09lxnZ2fZiw45Couz9TA4vGHs2SC+l702Jt7vBETjXJMTxg0e5JMl5kZHR1M9eH5+Hnt7e7G6uprfwy7X8mW4jTo1IjJRTTl6dXUVBwcHGZdQnembxWdZF57NM7gv5L41Ds/ArbCu8ZK8QHjXBBOlr3UnfqoVAOwXe2DPfNSvf1yk1G/mevnyZXz605+Op0+fxp/7c38u1bcR9yqoP/gH/2D86T/9p+OP/JE/Ej/+4z8eX/rSl+K/+C/+i/jP/rP/7Df83D/2x/5Y/Pk//+fj3/v3/r34N//NfzN+6Zd+Kf7yX/7Lv+5rd3Z2Uh34+c9/Pv7b//a/jX/5X/6XP9DnfLh+a9eHmpT66Z/+6fhrf+2vxVe+8pWYmJiI7/3e742f+ZmfiU984hP5mk9/+tPxi7/4i33v+6N/9I/GX/yLfzH//+zZs/jsZz8b//v//r/H9PR0/PAP/3D89E//9G+aSa+SeUEaI4gsEcw5FjUislRElv7VcrcKjBjWWuteP9tnAC3AnWcBKF4lRA4ODlLJhKCYm5vLo68BBaoDz0rhIthEFBwcHMT4+Hh0u91UXymTQVz5DKV5nF5EJGBWjiXLIbgQrAwMDMTy8nICXuOGFBCUKStx78bi2bNn0Ww2Y3h4OBuByr5zbO4DaBYIIsbm5uZSMbayspKOUD8hwToiACizLgBPGflmsxmLi4uxu7ubc1JLbqh7BNWcsyzi06dP08nrU4YQM0ZAgqAB8RRxB5jJ641BJSR9pwDYfCEv9/f385QTCieB5ZtvvplKHBk2yrYKkCoxIUAT5FHpyJQhBefm5vJkH02lgcGhoaFoNpsxODgYGxsbCeAi7hVXCBIEEVUjEso9A0AUUgC8vWKe6kmIMsXUC4Cq9W4f2f8yek7Nkn0HoDnUWmIgs3twcBBzc3NxdHQUnU4nG9cKqpAXNfhjS8bHx3O/2EtKRa1j68b3U4QIkmsmVJCC9JCZZseUwVSlp+CogvCIiMPDwywHVrZYS6isR2PudYg0v69E58zMTAaxgmsZ3ArW7TsZX8+vd9ni4mKcnJzEixcvsp8MdQZQLgijnDo5OcmmxlWRSp2GxKik88DAQJJiSCDqJMqxpaWlfDalu2T4Kysrsbu7m6VDlLKIO4Hs4uJilkIroZCF5xuopA4PD/sUbUgWpAJ16tjYWBIus7Oz0e12MznCJgvchoaGkhCX1LGGT09Pc4wPDg76+lfZJ8YFOSNRQMF7cHCQyp+1tbVYWFhI9ejJyUksLS3leEpmsAlKMvX2Y5ME+7VUm42w76ryppKGtQFyVUghbs07NZwAsH6XILH6cARD7RXju/lk+8saqPs24l6tMj8/n8+CFL29vSul9B6JiFoGOTc3l351YOCuT9LOzk6WM7FBtZQRIVZVy41GI2ZmZrLsaXt7O/2Y/ot8oblBHtUSR7ZMIqGWN1W1uefk+9hqBBnSBAmoMbjnnJ2dTV/vPcPDw6nWsu/gFcmmqkSTsKkKYPdnv9QSXBiQcoitpQZ8FWMZDz+HIZC9p6enqZhU7kbppYwSqcX/qwxAXEn81HLSvb29VBzDc9bbxcVFHwZjk+3diEhcYH/AlENDQ3lgBUKolmLbL96LZOIbjcXg4P0JfdQ2bGNVvSnTr03le71eEvKUZogu4+6P9/HjEgjHx8epVJbIgBH4BvaI3VNirjwT4SYJ0+l0otlsplKLjWZvagsHvsc+ZtuVF0sK1eQNUhKG8vMaC5kvPcY0O1cSWft48e3WJbxwe3sba2tr8fbbb+fJh3ygtYcIt4eR3hSQSPyP+vXbkZT6uZ/7uXj77bfj7bffzobjr37v3Nxc/M2/+Tfjc5/7XHz3d393NJvN+I//4/84fvRHf/Q3/NwnT57Ef//f//fxJ/7En4i/8Bf+QvxT/9Q/FT/1Uz8Vf/gP/+Gvey2OYHh4OB4/fhx/9I/+0fiJD7iB+8P1W7s+1KTUL/7iL8bnPve5+J2/83fG1dVV/Af/wX8QP/ADPxC/8iu/0tcP5Ud+5EfiJ3/yJ/P/gpCIO6P6L/wL/0KsrKzE3/7bfzs2NzfjX//X//UYGRnpa9z2D3s5JYjqYGpqKjNyEfe9iRhHsuWZmZlotVr5e0BHdr+qEGToIiKzPlW2rQSi9g8ZGbnrpaSOWjZBxshYtNvtODo6yqDj4uIitre38144Chl1yhFOg7NVpgI47+3t5ZiQbHsmwF6gBSAgijhR4Ahw4wApojqdTpJWSACOEAknMJDd08gcaAZqjB8nGXF/FDcJ+tzcXDrrq6urvl5eNfOnJAxAdaqT0q46Lkqt9FrY3NxMgg5BxbEvLS1lPf3l5WWsrq7G6OhonuwjG+veAFegZWpqKqXNgkrk0c3NTczOziaYpPSyTiYmJmJhYSEJDOodgWqVpI+MjESv18vSA+WDMtezs7PZF8I6BSwELTLcyAi9cjThpw5DfHidHj7NZjMB5urqap5MODMzE8+fP4+1tbVUOdbsGqBagzdgHRATCN/e3sbc3FwCckQG0KsRtD5GlIGV6Lq5uetzpm9SbSgKYAmCZVXZiJOTkwzUjo6OsuRCk1rzotE8mb+16p7b7XZcXd01fl5cXIy9vb2+Xk32ks8nn2e7BJL6RBg/oLrRaOQYRESqHii4lGeZH6BWj65KXJmPZrOZZA+gTe0m2DHe5pE9QEbW0oDa48568KwIauOKmHrx4kUsLCzE2tpaHyh2kubAwEDs7u5Gp9NJG1rL0/y79v+6uLhI8CyAE2jUUhB2R+AUcZdoWF5eju3t7SwLbzab8ejRowzGKQwo8pTp6SeCWD89PY2dnZ2Ym5uLk5OTePz4cSwuLuaYy14jO5CMyIWZmZnY2NjI9/uO4eHhVEuxhXNzc9FqtfIzjo+Ps28gv4HAFXhpsG7/Ceq8j41GrPDTKysr2TdKSWGr1UqbJTg6O7s7Qe3m5ibW1tbSl/puAZGfWTsIJATMqyWLSjn5RGTqzMxMKoqoR/grvt569HqvNT7sjQM+JCZqz59KugoIEH960c3Pz6fqEe5AdlVyTgCETKB6QoJNTk7G8+fPU9lydXV/YiW1KZIY6dNsNmNhYSEePXqUSjRJL+T78+fP41Of+lT631r6WP2VeZRcQt4oiXbPlBpwYiW8I+5LK9loGOvi4iJevHiRPd5WV1dTeURVx48J/J89e5ZqFIT3xMRE7Ozs5D6STNObUCIH6cH3sJXwAXKWbZOEgX+or/zfe5DfJycnibm++7u/O23GwcFB4oK5ubmsCvDZfNLAwF0ja/fQaDTi7OwsdnZ2krTv9Xo5ThUPV4xrrKp6noLIffKf8JjWADc3N5mMksTY3t6O+fn5TOjCZ9oI+MOPw2ZVheNvyZaa9Nva2sr1h9yqCZuaDJD0gRWRZoitqqryvYhhJdPsgOQlv0B1aQ/Pzs4mVhNjVMUSm7C/v5/zad1F3Jfa27viCwS5xEctY6VkkkyD0ZFQqg+q4lm8Yv0oJVxYWIiDg4P0fwsLC5ncp9Dlg6gcJYWRVfv7+32qqofrH831C7/wC7/h7z7zmc/EZz7zmX/gZ3zbt31b/K2/9bd+U9/7+37f74vf9/t+X9/P/o1/49/If3/605/+R0q4PVzf+PWhJqX+1//1f+37/1/+y385Wq1W/NIv/VLf8Y6aSf5619/8m38zfuVXfiV+/ud/PpaXl+M7vuM74j/5T/6T+PEf//H4iZ/4iSQk/mGvg4ODWF1djXa7HYeHh3nCj4Cy9nEQpHFmVQ0hm8DZcACyewI42ffLy8tYWFhIp8IYczbX19cJ9IGvWpInEHRCU6PRiMHBwdje3o5erxdTU1PR7XYzmEL0XFxc9PUP4Rgd/yt7WwG67B5HTEbLIQN9lBK1REAAOTs7m42rjYFyGhJ/mRWliQCS01uMryxvzbjLtHP6tTRgYWEhg8Bv/dZv7Qu6qYMiIoNXhIayKFkiINupa+fnd6cf7u3txdraWiwvL6cEWb8D4ETDc/MuKAHEZQ5JYykjECACZuPNUANG7XY7n8O6lW0GUpCHsqEAI2KQ4kGplPUk0Pc5Y2Njmd2kDKHUotrymQIo+wR5Kkvb7XazVKHVasXk5GRMT0/H0tJSDA3dHfO+tLTUp3bRBFZJkmepzsu4ADRVOWGtdDqdePToUa7V/f39aDabuca73W5m0b1neHg4e1Ht7+/H9PR0LC8vx9bWVgbu9q91VklqxBhbgjiQUV5bW4tut5ulwACnnnTIW+AX4JucnIxnz57F4uJinJ2dZQNeSgRrShYeYWKPA50IJASUdWHcBX8UNa8q1RwDLPirwaH9UAE50q+qwShNzCuiMCKSKBKo1xJWtrOWXHlmdgTBgjB58803c/xriSIbL/C6urpKUntxcTFJEOQB8ssakdgApAWjbGUtg0EeImOQzwjg9fX1LK8wbu718PAw5ubm0gZSGtQSJ8ERApF9GBgY6GvK63kR58o+lpeXU4FhHNg1iYbZ2dmYmZmJdrudqhxlWC9evMh1igg+OTnJhvD1FMKRkZE+5Rk71mq1IiIymaH0Znh4OBUhVL7K7JQvKotFhurBR/2jBIVvtaYFpv44/ZFNODw8jPn5+VRWGBdzZ3zq6WDIBPZYQFdLIRFkiH4n6/LZXsOm8Lvz8/PRbrfj0aNHfQ37qdcQ3fpWCVSV9uzt7eXBHa1WK8eTkuri4iJ2dnZieXk5FhYW8hRD5ajK8pvNZh6ScHNzEzs7O7kfzs/P4xOf+ESsrq6mjTTvntvpbEgdiix7WOILoY4kYjdqSXCdm2rXBgYGYnt7O9Vs6+vrsb6+HoODdz3fnj9/niXvlF3K6l++fJnqEEE2O3R8fJyN0+0x5Lp7cs81GYBcR4o/fvw4E2IIGuMseTA1NZXl/vAq0nRqairef//9WFhYiI2NjWg2m2nL2TpYBllMOdPr9eLJkyd9Ssba89S+q0qrSqj5LNgMaeaEUpjAnPBREpvs0erqahJr1tLW1lbiO0rHOpZIFeQS4hThQu01Pz+fylm+sdvt5to1R55VI3L24/r6OtXBsAmyR9m6PqGUwQh564HfMg/u3bjPzMzEs2fP0iez1RF3rSOU456dnfW1SWg2m1lGS7Uu4cbvI8qoJ2HCgYGB7OeJAOWTKBj5YjbLukCOr6+v5z2zYebCuI6P3zVVpwhEuNZ+c3zdyMhI7OzsPCil/gHve7gern8S14ealHr1EojVhmsREX/lr/yV+O/+u/8uVlZW4l/8F//F+I/+o/8oA+K/83f+TnzqU5/K4Cci4gd/8Afjs5/9bPzyL/9yfOd3fufXfU9VU0TcEVERkdkzYEU2BUj23tozBmihjjg6OkoVEgesfwXDKjitRJXv1iMg4v4YVwEL6TsQ6TkGBwej2WymhFog5xQppW9KOQBuwBgRJmAR0ERE3ufc3FyfHN4fMmf3UTOxZ2dn6YgRJxxMPaHMmAgGZARPT09jb28vpdoIJioMwALYiYh0qtRnVF8AUm0Arr8N0sj3AELn5+dJhAE7smpzc3OxtLSU4FcgERGZeW40GrGyspL9BGTOBSrIvW63m0oopGctxVQ+o5cXoIAMrHLrWlJhTfl+Y2DNCuZfLfmYn5/PbBo1DyKgEptTU1Oxs7OTJX5AUM22CwL1s3CPQFBVQcjgKpGYnZ3NNUPmrmRnZWUlTk9PY2NjI6X59tPQ0FAGBYC1EiwgGFm6tLSUQEu5BnBIQVPLP5AogiylOzXYpNxgOzY2NpIcV9JRib2JiYnodrsZZCG8KA6sA4E+NaBgDeFA0Shz/ujRo+xLgaiQiQTEKSpkQo13zd47vrvb7cbJyUkCS+DZ2lSaRHnjdRGRChJKnhrMXFxcZG8mNpLaQQBsP1I96CtjDBDHgLSxlbG1P/RTY8+s7U6nExGRZOXm5maeolVJc71elJysr6+nDaGaMDaCa4Tu4eFhBqNIJPel9Dgi+ggPvZaePXvW19S3ljordxLItNvtePz4cVxeXsbW1lY8fvw47dHl5WUS3ZSf/BXbgdigshBgLCwsJBGKILu+vk5FZg0iI+4a9Tv0AWk0MDCQPeqsiZGRkWg0GtHr9fr8H0WU8lN+xvyzUdXH8UtsrQCdj2g0GrG/v5/kU23UTEmrpwrSCDE3MTERBwcHSU4IJiv5hmAU5CuHR1ogAymSkW0ajft5LeNRtqL81T6rpTf2mLVlbF577bX0a8qelGPZhzVZZpzHx8dTEcl+sN3U2rV/msv+hQUmJyfzeyg4f/VXfzUePXoUCwsLcXNzE+vr67m/jSuiTiLJvtOXKSIy0NbnBrawjwTf9iIVkMNDIiLJQsHv2NhYPHr0KNbW1tJ38Qn2/M7OTiq39GqTaKQC914kngMyBOMIZP9HeLBHCBVEZ/3uui+RcnpFGXfqIOTN2NhYrK6uZiKQ4pnSpfavGh8fTzUglWi1o+xZp9PJNUJhU1VHVHwwAV+KiGG3lJ45bKY2zacctxZgdfiS/6klkHo7wSx1TOEc65kPOTk5SezhPhCr/Ds/Y64kVqk74U12lY9eXl5O8hc5jEiWlDJO9jOf7m9+ZWVlJTY3N1OZxCYi6yhVKZJh+YWFhXj+/HliByq02j+X3bq4uMhedKotEGy1zI+68uDgINbX1xMjUaQhoapquSoG2WHVIi5ELOKPPzTv7KeffdSvB4Lp4fowXR8ZUurm5ib++B//4/F93/d98a3f+q358z/4B/9gPH36NNbW1uILX/hC/PiP/3h89atfjb/21/5aRNw1G66EVETk/7e2tn7d7/rpn/7p+NN/+k9/3c+rTFR5niBeoKuWWf+KqampdMjDw8N5lLtAmGKA7F/pmCxzPfY24g70NZvNzGC4KEAiIp2ozDPAy0hrCri1tZXZFECv9pYB2mpWWjNDoNpJH7VEoNfrZcbPn6qOkgVTjgWoVjJIcAUYIbMAxqOjoz7wj6jQX0ZPAkEylQ0VSe3pwUEKDClgIu6zO44JHx8fT+ULIKPUATghGa99YWSnVldX4+23386gRn8p/TIAjJ2dnVQACE729vYy4Hz77bfjrbfeir29vVhcXIzDw8NUFyE79HVBvlSy1dpBaMkeUvMokawZZs8CzFKEICSUSAKiAKRMrXk3rsCI4Gp5eTkuLi7iy1/+coyPj2d23RqiKFBaCIgLMq1V62VoaCgWFxfjjTfeiNnZ2Xj27FnWuCvdsXa87/T0NMcYaLMnBe0CNd8BPA8ODsbq6mqOH4JLSY7eVDc3N/H06dMEYsglYwuYAp1DQ0NZtvdN3/RNsbGxkT1BgE37g43yvcod2B+9doaGhjL4VyZhzKnokIyV7AXGK6gEaPUCU3qJaDZOgDXwau9QrY2Ojsbm5mZ+tmCeeo8i0r7SdNjaqie1mVtKMDZO4AHMst8R9+BOPzdjqEzq0aNHMTw8HLu7u0keIzXsLUGvsjF2+/LyMoNVANuYGAflFgg/GWdBv3G9ubmJt956K1UHy8vLORYII9l/97OwsBC7u7txfn7edwLr6upqzM/PJzkyMzOT5TZOBfOMx8fHaf8pJsxJJXiog9mN8fHxVCf5HgRPq9VK4uzy8jLnX9Cmb4xAeW9vL20Y1UctqReMKouk7hodHY3l5eXY29uL+fn5XP9jY2NZXli/Q0mwXi0COkqdxcXFtBf2KBtlbiMig1S/RyBJ8CjFU8Yi+cAX+j7k16vlecoOZ2Zmslzc50qUsYv2H/+g8TYiFtmMKKIkEkTbc8p5h4aGotvtxltvvZVEGEWVxABbeXR0lPbQelEaRK1n3hYWFuL4+DiD9aGhoQySKymO3KFYNvcIM3a+qtPtDf0D2SJ2mc08Pj5OFStSSl8rZbgwFsUS39vr9bKcnYIHWdput1PhjaSpPYqol3q9Xq4JttQhHRMTE6mEo+6MuMPIS0tLSUhXeyZJAidKKIyOjuYYwVVK3W5ubpLk8flVdYmQVLa1vr6e7zeudXz8gScRB3wfLDYwcNeTiuprfPyuj6Y9wccgRTS5R3zzp2xWJbyqKnFkZCQPs+F3PZ/7Oz8/j8XFxdjf34/9/f2YmJiIx48fJ17tdDqJOfkSylN/IiITpZJmbNzy8nISmO12O8vmYSXKP88zNDSUvVQr5mZ3YXilr8rm+SpJKDGIvxFxGviz9ZLO5hyOpOBH2EfcqbHq2CuhpK50sQ8RkSetUZQbP/GC/UAFSCEMgyp79j4qNWTaR/16UEo9XB+26yNDSn3uc5+LL33pS/F//p//Z9/Pa2O0T33qU7G6uhq/5/f8nnjnnXfizTff/C1917//7//78e/8O/9O/v/g4CAeP36cxlVAxWhzzBGR5Ry1hwDnfHV1FWtrawkYBU+O3gZqagBYQW9thLuxsZFgCsEg016PTeVcLy8v09EAxRyUDDiFDDXG4eFhHyEkGKllXfPz8ynbv76+P72oZuoREBy0EpeISFCCNEOEtNvtBASnp6extLQUi4uLqYCrpS0AZc0gC8pq+YkT9cxZxP2JMUAcpQmnub+/nyd5VOKIegfApQww/ggepIGMplOyvvKVr2S5iGyRy3ipkVfWQ912c3MTjx49ipubm/idv/N3xrNnz9J5b2xs9PUaEPRcXFwkgWguz87OYm1tLbOpso8azdZTWiIie6o4TVFmT1+jiIjXXnutr1xOv4eI+LqyJWPPsSoLk/1XWtBut5P0U16JLNL7gqJPAKQHjJ+PjIxEs9mMRqOR676qB5ErCA9Ze2CvAlaAUp8e3y9gE2xQIFCuGQflSycnJzkOwN7AwF2j4MXFxVQRGjtzLPtujVI5urdms5n7opZwIc1fJVzqe5ELjq5GQCGeraUa+J6dncXS0lJsbGykKs5zUjIJRpWVONxA3xElwzKggjz2dHz8/jh1ygg2iPoFIEbWSRQ0m81UnwoIZKY9FzutxEUC4fHjx7G7u5uB2snJSbz//vvx+PHjmJubS2JerxgBhtP6BFCy0YL1qtTUR2NmZia2t7fz9dWmCBrYN6WQX/jCF2J6ejoajUa88847ae+tL4SIQLSW3iJaKMZGR0fzUAjBu8QJQoZCE9FEueO0T+UhAhcKLaRYu93uK0kTSETckSePHz+O6+vr6Ha7OWcRkQoVpKDM/PT0dLRarVTnCLC73W6srKzk3PIJCCAnZ9aT7RysoE+dknYn0lHtDA0NxdbWVl8gZAz4MgRf7X8TcV+maj6ur69T2VJJE76/EiZ8mmBceena2lq8ePEiyRLvibjvO+m+Iu6bZyOw9e2j2BGUX11d5Um/SCQYh1L8yZMn2ctG8FvJJ0e/ww7UhALJk5OT6HQ6aUfZvEePHiUJi2QfHx9Ptaw+WwLT/f39tNUC19vb2+wTRkFW+0UhgRHUSqGUWjabzdxnZ2dnqXpEKsEsFxcXebqjvbu7uxvdbjeJv8HBwej1erGzsxPNZjOTM2wzJZxTVSWVzs/P03/NzMzEzs5OEtDUi+wt5THSjj+RfKt7utlsJi66vLyMZ8+exdTUVOItiTsld/Ba7SlorSjDhhWoYRw+IHFDJStR6+Ac+zYistxV+4U333yzb62zRfaMhGct60RSjY6OxurqakTcJSQ6nU6WrCIdHayBqJFoNJ76fbH/+nNWPIKIZQfECCoF7JlaBTA4OJh7D7mqHxLyV2JL82+fIYlUVWb1UBg43lzr7QfHuyf2p54eODo6Gvv7+zE6OtqniLu9vT+VkooaDtfbqdvtpsKUAtH3Si5XNTrbSJV8eHgYrVYryTnzqJqAHUQumndEHjUfotA8fpSvB1Lq4fqwXR8JUurHfuzH4q//9b8e/8f/8X98XTf/V6/f9bt+V0REvP322/Hmm2/GyspKfP7zn+97jeDmN+pDJbh89RoYuD8B5/b2tu/o2Vf7tpCoAggk8bLQSqYuLi7ytBbqGtLtWncfEX319Tc3Nwl0BRECHYEMhYCMl8zT0dFRZvlub2/jyZMnCaQQKre3t/Hs2bMkHAQtwChljSAMkaOsRDZPgMSpGV8Bzs3NTX4uFYeSONknJ5bUMhnB6sHBQdbfy6ZQHkxMTCTYiYgE/VQ2NYtGLSRTVx2wjN7IyN2R8IJ5P280GrG+vt7X50tA6N62trZSGr20tJQqNaQToCE4dgKg3icCbxJnWeS5ubk8fcmYWBtXV1cZsOozJWDyWYCNUwUFPgAacDE2dneEsXKDemqgfjBXV1fx+uuvZxAtC0nOb08oq0D6yO5ZI+YaSQm4Ij+UM+zu7majX4DLcwuIgTIERu1LIOiyv4Dn6enpVJ+R38sK23MjIyOxv7+fe6zRaGQ5bu0pUxURyucQ0cA8AkwwBeTNzs4mWakv0dHRUTx9+jQ2Nzdjdna2r6Sqlu7U3jFsl1Kq7e3tJCcuL++ODV9ZWUlQPTMzk8+AgEWa2Qf6tiB/kE/2syyn11CeCS6VAUTc9bTQ106D9E984hO5Nqzbubm5PC1tYmIijo6Ovu6o9NpTisJKYBYRSUgLzBGZAiZEfEQkEWmPI9CUEc/MzCRoRxYo2x0dHc2yxRo8USzYs/zC1dVVTE1NpToD+Wx/zc/PJ2F6dXXXu251dTV7itkXfAiCznpC/gpqxsbG4rXXXsv7OTw8zCQOFQYVimdA7FBJKqej3NE7SanK2dlZqo6omOx9ygFHkZ+cnKQKgA2rasqLi4vslyWjr++TMiikumBQ4+naww4Z5/XsGJ9RSSrrVvl1DR71YDs9PU3/qHx6YmIi1XQ1cJSoorjgZwR09lRN6iBlqjJbedPCwkIMDw/nQSXsqQDWvyVw2EGYwP7WbmB8fLwPEwkMDw8Pk0Cg8lNa5xoaGkrbpvRbj7FaXoeIsk7YA4T09fV1qocRc2wCghxxRfWD5JZwqokYBDSsVRuJ156Hfu5eELnGcX9/P/sW7u3tpf+lJNMvanJyMhNNGxsbadMpAvmTTqfTpxI/PT2NZrOZvYsQAcjCV9dF7UfEnlIn18CdOs9eYA8lf5A53W43x1MpKJtr/JEYr9oBiRIJIXOHeEay8LeVIEGUSrpR5c3NzaVq0vj4Q61bE7f8PX+yt7eX2AURfHBwEM1mM9cRUlsSybyzgZIUR0dHsba2ljYFbqz2wrhX7MRu+Xy9jiSc9vf3U90lwSS5wV8geWvlASzi2cyhBA0CMCIyKeEQmUqOwZSHh4dJ3M7OzsbXvva1xHTwBXV13S/aUMD3xqUePlL7LIpVrFt+rNVqJc5wwIXWHEtLS2kravkxZSUsJvkohrD/P+rXAyn1cH3Yrg81KXV7exv/1r/1b8X/8D/8D/ELv/AL8frrr/8D3/P3/t7fi4jIDMn3fM/3xJ/5M38mdnZ2svnpz/3cz8Xs7Gy89dZbv6n7EaAgHubn52N09P4EuIhIoAIYyfwAqxh9jkAWkrMFZGVUgCknQQmuZPBqKQxgHBFJQnCOZNiIGpnlVquVAZJG6jJznCtyCMnG4QheJiYm+rJApL61rE82BjCNiHT67gnI1shdUCcrIktVFVycI+BIkeR5BQ+1R0hE5P1W0rASFQI8gcEbb7yR/VuUFwwPD6diwrwjxwAnz00aT1a9uroa29vbsbOz09eTwxhNTU2lWmp6ejr29vZid3c311w9OYYq6fLyMtUc5iAi+kC7ksjZ2dkMRoEc2VXrlVMHtBBK3i8I8DkCZ8BIMLO0tJT9ZaqsXqDr/7JpiFUEklOhVlZWcq12Op3s82OcnWQUEanQqA1zlUHIECO8KqD0fuomBCklGLJAY2T3ijyx/wTfc3NzsbW1lQEXpdfQ0FDs7OzkXkJUK6dDRuv9ou/H+fndUd0rKytJmlJURNyfIFmVGGT6pPTmg2rAPqj9sQQogl37WQmI76qA2l4yJ+ZaVlR/lPHx8Qyy7Buk1dTUVB40YG40h7Y32CXA1h7zOQgAykD3RcljHdfPM//K69hiY2HPCypkitnxkZGRvsMNTk9PY39/P9rtdto1pwseHR3Fa6+9lvuUzaHSsJfZzeHh4STs7FNBR6vVis3NzSQdkDz8krKsiMgA33snJyezNIW/pBoQsOkpZo3pPWbcFhYW4sWLFzEzMxN7e3u5FxHHVASeg1LUdyEAkWiSCnqfDA0NxbvvvptjNTMzk+sBqcXHKDGjcnrx4kUmU66vr2N7ezsTQEgxBCdizM+Q6gg3JSTs4ZMnT+Lq6iparVYGaRRVl5eXSf4iciW6EKGSIcgpaj7rmlpReQrfxS4olYEJJDB8BoKOQqr2vYy4CxapYijQzIN9bywksZA2SqhrYoEiiHpW7zr7qqpMqXjZTv6L4hhxAhPVgFjiCKnAjgjIax8kNpyyif2pfWfqaXD8QvVRkgwOkJiamoqXL1/Go0ePkth8NQFIoTMxMRGdTiftExIbZkPUPnnyJFqtVu4LxMzh4WGfbdcjyRq7vb3va2hOKSXtdXZIzzSYwX3u7e0lNqIUR/aau7ruJdp8Vu1TanwoEmuvM71A9TqF3Xw+jOGzKdIQ2eyHcnTEBHuvUoGCWA8+SiNrwl7QcxBhouQYFtN/7vb2Ntectb+xsZFkE4K8lsFbM0NDQ0kMShCad/NjDCTQTk5O8md8l/hCXGA8FxYWsg2EcUIKw1f1vfbYwcFB/p/P4yMiIucA5rAPIiKxRMVpFMcwBaJSybHnQ3wjKV3u2z5tNBpxcXER8/Pzid3EQohIaxNhi1TWSsKafrgerofrt9f1oSalPve5z8Vf/at/Nf7H//F/jJmZmewBpXHgO++8E3/1r/7V+Of/+X8+FhcX4wtf+EL8iT/xJ+L7v//749u+7dsiIuIHfuAH4q233op/7V/71+LP/tk/G1tbW/En/+SfjM997nO/JXnn2NhYngLE4FdiiLNE4lAaAaovX77Mo31lBqgPBKC1p0gN5gTe+nIAmQCuWnyZO8GzUheZb70K5ubmEvgK2oC8iLtSLA6qKjBOT+9OVvrEJz4R29vbfaVhABrnDqwBy4CGUhdj6vjpy8vLWFxcTJAo6FVuCJgBPoBUp9NJ+f/FxUW88847sby8nJl2YwGwA1PAOxBbezjJttTTTZQ1Li0tJQkTcV8nbz5lq7zfOOzs7MTk5GQsLS1lnwIZHoqaqqiqpaFIDc9NbQNUAAS16SQHLvMLKNQmp0g7pIojjF91+kARNd3KykoGsFRigNbe3l6e9Aikef/k5N1pmYIdQCkisn+M53W6nabSVCTdbjeur6+zhMPaotKhotNM+9mzZ5l1i7hrQlpPnJS1A+z1obH+1tbWUglibSqrtMaMtVLYycnJLGEAnoGtw8PDPMUTGVpVZxHRRwo7WQixRA0zMHB3KlSV38s4U4d5ZnOE6LMujo+PY319PQPG2dnZPvUiBaiSEpnnkZG7Jt3Ly8vR6XT6yDBg2vqneiPtv7m56WuAD0ALyKkDlYcgxcjyX81IR9wrQm9u7o6CR9LoI1cJScGQdV3VgwJhe80zURtQpFV7tLCwkA2b9aAC/iUxKNVq6V5E5FqR9IiIXBNV2aI8gc/RL48iztoUVPtciREBSCVk7DmKCuWOdWzZQcSIe2SHlaM0m80sdaWcUpZOMYNor8RQ3Wd7e3tpXwSBzWYz7b9SsGrvjKfAW8CtlInK7ytf+Up80zd9U5ZjIcSU4SnDXF1d7Wvwj1BBViq50/NPsC74FMQqt/Ks1GOVBFP+jACPiEwG1DIdagF24VOf+lR+HtUFRVBVj1hn9r29K9hmL9hWJV+exV5VmijQGxgYiKWlpSRI+WEngSJxlQfrU8WuNpvNTCKcn5/H0tJSvl5DcyQhQkopfJ1T/ajs5YjIua2kgjmxr/j/St4rOx8YuDs4gsp1YGAgvvmbvzlPMHv8+HHMzMzEwsJCdLvdLBdFHlG7LC4upuJc0kYfSCTr0tJSLC8vZ9ksMs9YIJCtATYWTpCYoH7ibxGldd9U4gexYT0jAC8vL5NEpcpC6FgT19fXiRH4es9+fHycfa2Wl5eTlIDBrEXliu6Lohm+Gh0d7Ttowz6VHEKImnNzC1vzl5RYTpqFw0dHR2NnZyfvD2kMO8zOziYmQDRJRDn8xLplU42X1/Mpu7u7ie2tLb+jVEQGKz2ryTUEDOWV9UzdrqpCYllyR5+mukfgcqQzO25/3dzcxJMnT1JFX0ktdkN8Ym2yD4hvvoXNrOrZqsCX5PIdxtHYUrlKavGLbEi9Lz5G5YT9/FG/HpRSD9eH7fpQk1I/+7M/GxERn/70p/t+/pf+0l+Kz3zmMzE6Oho///M/H//5f/6fx/HxcTx+/Dj+wB/4A/En/+SfzNcODQ3FX//rfz0++9nPxvd8z/fE1NRU/PAP/3D85E/+5G/6fgBfEmty2iqFR3QAeYwvoNdqtfqUAzJnNXMjyObEOQvZVyoEJ7kIrAQ9HFCV8sqwU0fUzIZMmqyl4A8BITBEhlDZVMmtLEVE9DWireQMUMQ5yRghbThTZQ4k5jJfMteANKBgLqhRaqkA+XW9VwQQAELdxeEKFtW6T09PpwIiIlK+DhQCCmTyHLEsu8D0+vo63nnnnTwmGEh68eJF9i8AjE5OTqLdbifxhRB0bxcXF9kbwXoE0vS1ACCNv3Uo6JHlBZgqyDUOCIZ6OpZnQgIa19vbuxMEDw8PY3d3N++bagmxAMD6PKTF3NxcqrR8J3LO2B8fH8f29nY2KgfW3EPtoVLBu4MDkEdAjjE6ODiInZ2dPrUDAlZvrar8EzQLbIy/XiFKviioEBh69ABpCOvd3d0MEpFIxkYPkdvb2/jWb/3WBGR6wejDZu0gp6go3COykxphf38/lpeX46tf/Wr2dvAcnrGWRN3e3qYak81TRiC7bz/t7u4mALVfKFCqPbRuKAupJRYWFnK8kQf6eliXFEQaCVO9CEAjIu21wAMAps6wN5G1FdAqRxEwn52dxeLiYipKe71eTE5ORqPRyBIuashq1xH6VKHKE9hZZKr7QbIh7hFD+oZYv/W0PT03BKYRkc8suTE1NZX3xgYKLPgMPXoQw5QRFAbsNpsyOjqaQYpSs4jIBAeij52sa1KAJiBBfLEdVF8UJtvb20l+INgiItrtdh9JTRnKhlxe3jXsR2jJyFMgUbRUQo4/otjiD5HnyC/3rwxbYgIZ22w2Y3d3N+dYqY2AVFlLbXaPGELgOaHQJTiNiPxcil77bXp6uk8d5f2IDWXfdW7YQd/BTtu3fITkG/sk0XBxcXcYx8zMTKofnDpMfaJMEamjDJCdYeMR1LWcmf12SWZIWpkDbQMQV4hApIHn4y9qnyT+otVq5cli7IWDCtbW1rJ8r/ZRM39s5fT0dCwvL8f19XVsbGykKl7fI3bZXri4uOg7wdThBmxl9eGInP39/Vwv1jx7u7e3l8QaGx0ReSABUvTo6CiJzZOTkzxcpGJIe7+2pqin5Vq3teysJkBgXYp05AH7CBtQgu/t7aUd9vOatGPHEe+UWvApbMhWSaw6KRbJZiwRw3wBLOVwGYprSqRKEEZEjrG1DO9auwi8wcHBLOGUYGMT+NtaXqckuPZlrNUIte0FHMiHwngI6qpwdo/iAepINqKWDlbyCeGrzPX8/DwVtXxOo9HIsZmamsp1URObCC/JH89VVZWITyQ37Mm3SiQjlgcH7/r4SZZWnPlRvR5IqYfrw3Z9qEmpf9DGefz4cfziL/7iP/Bznj59Gn/jb/yNb/h+AOGbm5sMiicnJ/sC+IjILIeAGSCUNVRaFxF9xAbgX2W1DLiSMkDFMbgygQCP4BM5IeulPhxhpoQGicBhkjxzeACbXkYcec28RkQsLS319RqgkgAegNpKFsiYAIevAmGfo3RA7xSv1TdBoAUQKfUS/MhSCqCAMsCuZqM5S453dnY2QRiAr6cHwkW/rpo1vrq66puj119/PQ4PD+Pw8DBPGZEdk3EF2iIi+7EcHx/3yfpJsI+OjmJnZyemp6dja2srNjc3EygYP6RozXZGRPa3EOQDJsbcehUEGOta4iAIUMJmjn71V381Op1OnvroOYBxa8b3CEiBTWterwOlOMiyTqeTZBWyAYDU3+Hs7KxPSj88PNz3nII4IAkQNG4RkUGa0y5rmZ+9PTw8nERQxN0R6K1WK9ec9W8NXF1dZQ8p6hz3Pzo6GgsLCwkO2Q6BtIBKFlMZ4/X1dWY+a2YToWOv1ZIC80xx+Tt+x+9IMqvVasXu7m6fHJ4asBInTpWr5HgNuik/BSCVhEasHh4e5omYxoGCS6beVdeoufK8yHD2S3kBRaB/2wu1RC0i+oBtxB0ZjXiy93d3d2NpaSnLSjRCRg4qv2RPkWxIycHBwczeU24hyuuzVrtXVVIRkXMiUNEjqQacnscasJf8vN1u58mPAn8209y6dyU4yq0i7hUK+nb4fvsdoWMNmOfT09Podrt9Te2teUmGqogzx8pwqG3sQ4kPdkMSiL+QbaeIubq6ipWVlVw/l5eX0Wg0+o4Wj7g/mVYZDWUgxSBC2dzwQWyzfVLLcCpBbAxrWf/Ozk76wlpaZX/VHinGZnd3N54+fZrj5p78MRb8sKSWxIagbWVlJQnlm5ubeP78ee7pGrxb69YR/8J+C5y1SNjd3U1C5vT0NBWtbB7C1WfV5BKS7/LyMtbX17OMp5Z4e0bEI/KUjbM+qHHYJ3vHdyI2Bd7mbH5+PtW0PqvZbEar1YqVlZX0IfaCcn92zvfOzMzE4uJitNvtLM9GtFDXUAtbr/YlPKi8tyY+azk5oqqWLcJ5tSxS42qEqOe2p+FaiuC61+FA65K/8aeWxkoeUmxRMzrIpCpd+UX4a2RkJA8ROj+/O+hmbGwsD4mAA/gg6hrPURWFo6Oj0el04urqKsu/lJhWNQ/fyo5cX19n9YLE3dDQUBKs5puS1njyIXqFOn2VDbYfrTskvn3Eh8EUNbEhQSoxZK0oIaRkhjv4TH6Bj2WH2BFJEd/teykKI+77QPm/90sKmUN7Au7g/yQBatKMbZE8poKE7Zz6y97WWIIvd9/VbsLV9bk+ytcDKfVwfdiuDzUp9dvtGhy86/GiKaRAHSCkOomIzFxzBBGRGQ2ODtjk2IB6gXItU3B5H8MvW8lJ6MUkCwwUjI2NpTR4eXk5gfO7777b17QUGaUJpmeUKaLcIqkHtGsmFWlTVUecoLJBr0ciCCRrvw2OSKan1WrF7Oxsjqngo/ZgAMZ8Frk4sGaeODaAtSpDaklPVQXVn5mzZ8+e9WUHBWIaIVO1WAsTExP5nkajEaurq7G0tBQrKyvpsC8uLnKujo6O8tmAH2qsmvH0vDc3N30BFjAB9GlEX7PjAj8grNfrZQnY9fV1X78EDV0FdMA8MkOG33qiALB2BK1HR0cJ3Cs4BJyVT7Tb7QQiAtuJiYlsLG6NVMVTJR8QwcCutasspPaSsd7NGVKDiq3X6/UFntaNfkIAN/UNEFdBmhNlJicns6zCfNVG3wILwWVEJMlD0SSzjRgX/NVnqVJ5Ki2ZSf3H9BUaGxtLgDs+Pp7lfrLngLzAxHpiC+1bGW5BRyXXBZ3uibJFXz1zI3CxTmX8KzB1VXWR+aCEQRqwre6ZrbNnzM/CwkJMTk7mOArsLi7uevA4tY+qbX19PftqIF0EXAC2kgpzRH2ztbWVhFkNlCU1KlEuSDw9PY2dnZ148uRJEmCSDr1eL20a21uDCSo2RBKyTJBAuYMcrfsfsYJ80RvKGFrz7hPxhDSxfvgNxKoTBSupqrfZyMhIdDqd9Lvj4+N5gh97a84peCjdkHYClkePHuWeNa/ITE2NNco/PDzMU+cox6gC2DSkQn0mfs9rJYHMA8WF1y0uLvb1kqlqHutB7yZloXwUAocPth+sZ7aoklOwgkCQwmlsbCza7Xb2H6LgPT4+zuCRcg5ZUJVe1a7qWagkf2Li7kQ6674G75WkplR1kIY9guRC8m1sbKR9qoQK1ZIxR8ofHBxkmTDyAvHE39bSK+uO/bauh4eHY3l5OR49epTEpfJzyqpKSPs8e21hYSFevnyZPtTaGxoa6mt2TR3v/qsyrJJJFdtYA/pVujeHnFScVpUz/PLW1lbaFqoie8D9sEHskTm6ve0vLYc/qOXYPvbFejPW9jzbWveXJtgSkT6fok1i5vj4OJXIKiaQ5E7xtNb5GM9QqxSoSqlgV1dX48mTJ4kdET583sDAQJbwVpWm8kD2IuI+yWU9RURiYYTX1NRUvPbaa7mm4ZCqmDVuFIHGE5YwPxKu7GNVQlG2iiUuLi7yVMibm7vS906nkzbp1VYZ3W43k0n6ifL/tf8YQgqulISoBx+5Dyo3a0pC3AmFVWErIWafs3PiaHpTAAEAAElEQVTwD7upb+5H+XogpR6uD9v1QEp9wNfQ0FA6gPPz85idnc0TShhYRNPQ0FCWoslYKGGIiCS0ZOUFa8paOCEkFhl6RORx90rQ6kWeD3AByJpNara6u7sbEXfBj4x1VTup7xfgcCaADcBeAZ1MJRWCwKQqM5BCFF4C9Ff7vThhClEm0wuA7e3tpbO/uLiIjY2N7EeljISDEhSTSQtMBb++A9CUxaJCUJImsNHc9/LyMra3t7PnVERkc/KqvgDqlpeX4913343j4+OUlMsy17EB3vUxoRKanJxMybcsakTkKUlAr4y49WPtcvI1mBS4RUSWPgDEJOT+PzR0f0IWACLwIrOn3PE5gEIFVADkzs5OvPXWWwl4kTEAxXvvvRc7Ozt9QRTJf3028yezdnJyEru7u9mnQ2+dbrcbY2NjfY14BXjADVAYERkEmMtKwiJc7TnPC/Bby7e3t9kc2DhpyCkrT9FhfXk2AJKSEnEXEfHixYu+8j7kpHVQgxqZRGS1EgLBgh4UejN4D7BuD9UAvPa+ajab8eLFi4iIJGwErQJ4gJNtALyNr0BT+Z31GRFZ+lhLzgBbJJzx9z5KntrI1diyz/Z/JaY9G0XqxsZGHg9/c3OTtkoPGqUGAlTE3aNHj/rUfEph7DllvJoM2/vAu7GiABgeHo52ux1ra2tJeusPKJAQuFpzntE8rq2t5Xo1luzOyMhIBoDsLxsq262Uhy2NiDypkvKl9kzyfmMcEUmoCgJr9rs2vraH2u12NJvNiIhMuLBJXif44btq+ZBxti8plQYHB7McEvGmPNj6QlLx3VQTCAR2uipn7AlrMSLSBto/ShUpmX2X17+q9Iu4K1P0Ovdg7VuTlah4lQhmk91bVXebL75as2QEI59pX9kn1sPBwUF+fyW/NPlHnLFlSBCEG3UrImlwcDBPcj0/P8+f8cebm5tpP6py2R6TdKN8qcE6bFNLgDyP1xlTyRrrQ6B9fHwcm5ubic0cAEDl8eLFi9jb28s+fMYDbrLnzNPW1laMjo4mxkKoGzMYwjMj0th1BCLbhtRkI5XHm2ulysper66usm+Y9YcgVM6FDOIXEIf2G4XR+Ph4bG5uZtmaJIUkh71aiWMl5/BnRGSpuWff2dmJ2dnZmJmZyUSIpAU/w9awncPDw1nmTmHkJM6qsqQehHncZ/2dXlLIFPuT/dLLc3h4ONcVfGx/ILusMXOCBK/9+GArpJK14r4owJA3bDgilB+rCS4+u5JWw8PDSV5KViBUvadiQsSSPmRVWYv0MwawjrlX/lmxku+1/iQw4T32znO6H+Qm+2+srMudnZ14uB6uh+u31/VASn2AlwCPIQRUGHrOiVpH9p36JSISjEXcnz5X+yP5HECBcQdkgBBgw+dUgC5zzCFxsJQ6g4OD2Z+DPH1wcDB7EnAmsq0cDzCrAWx1BkCW16mB97uxsbEMsI0TRYTeGQJTY9zpdDKrTWUmWKqkksC0Ot35+fnY2dlJJU3NUrnHVzP89SQZ2eYvfvGLsbS0lGVqFBgRkceJK/NrNpuZoauZT2okTTEXFxeTdNF3CIEB1OibInCqgZ0sqKC41Wr1qcaAfeCiyuIFFQiMSngqaQEs9YoARo2bTPjZ2VmermNtUGEJvgWH3qfcUuAwMzOTQKaWoChvGhoaiq9+9avxxhtvJGgXFGt4rnyIIkbQE3FX3oAYsF6NkSaqu7u7qagCaAF/Y1TXq71kjgSbepsA2p5Hdhe4rI1nK/FDIWVvv5oFXlpaykbQ9pgTeFZWVvr6N1ijbAJAbm0fHBzE6upq3iuAWoMSn8OmCBwQH/V9lArmUsAlw+3/iDfZV+OG4GBjLy4u4sWLF7G4uJhBYQ3iKqkq6HLCY7fbTZDt+yjxjC/yEtj3LIgV63ZsbCyWl5ezT4YTJ52YpQ8W20bFVwMqAQElp6BQbxCK2UrcVAWn18vC8wUy5NPT01kqsr29HUNDQ6kOAex9hqA8IlI5YF0uLS31EeEXFxfRbDbz5FBzgxR48uRJ2mzlvFRjVTFknzuJrNPpJFlQFYzmwzPv7e1lcNLr9foCZD6JkpSPqwd+IFiUnyojrIrN3d3dVAcgNOxn5ZHKiA8PD6PRaMTt7W0GPPZTJZUEUIJXhLdnE/BZy7VXl7m3n9gdiQ7BNjUTgqj2vRIMC9itAQS0Eh0kSSX8lafqfcZvsiN8rv5o+snoYcTeGRNJjE6nk3uMXeOP4Am2d3V1Ndc51QpSRM+4RqORwbb+RP5URRSlVVVqVUUGm+ePZzw+Pu4jtPQSQs7CdFtbW9kvqypIr6+vY3NzM/szIYmd5iow5yOUOgnO7Us4AtY7OzvLZCSSlQovIvKgB77L2qv7Bq7QS9RYOMGRf4+I7F0HJ1kLIyMjWbZtvimnq2Jcz69ms5mqHJ9VFS/uwWfVJGQ9tMO9G+PDw8M84fPi4iLn6ODgIPd+VZois8wBfMwP8PVLS0u5ZxGWCB/9HevnwSzIVbgfcYOk8kzmzzivra3lPSK5YS7jAiewAdRaiCT+wnslhG9vb9M2v5ocQuRQ/1k34pWqsqy+aXBwME5OTrK9xNXVVZb+Gl+x0ejoaKpCrU021li4FySsuAJ24xO8bmpqKv0xtab1KfFWk4Yf1etBKfVwfdiuj/6u/Md4MZqMLWcvAxdxry54lWSQeQICK2ioJReaMwIknCcjjQwT+PvOi4u7Y8QF6RoDRkSCbcouIIDjcNJIDVgEWZyuY18j7sslataCA6w1+MC57wKmEHPAN0cq6IiIvtcjnQ4PD2N7ezsGBwf7Tg4U8CETBDuDg4OpKqrNqms/r6rQ8T2Iwk6nkw65KjZkzBFXT58+zVK92i/n7bffTuKm1+vF8fFxvP7667GwsBAHBwfZpNQcAOZARZW8I8AiIlZXV3NsEIjGLCJSbVIVQFW9JkBoNBqxvb2dZTjUV5Q7jruvii/BHELGPW9ubuYaqFnTg4ODJOOsHYBVQE71YF6RFda/JuUUD7e3dw3VlfZR5NifSCANnevJUubRHAEw9YQ2ZZFUHENDQ3nMsDFGWCgrsj4F3kgBJJnyx4GBgdjZ2Ym1tbXcx36uNAohJgCoGep33nknXn/99ZidnY3FxcU+dc3Q0FCqdSqxVYkN+wwZIJsfcV9ia486ybMe51wDubGxsWg0GgmunSxHOWptCBwXFhYSrNuz9hwyw++dSCTD7fna7XYqN61L9kR/C3tc4O9eKX/8n21kbwUelBtKajWbVrpBrae0rx5zjpxGTJ+dncXW1laMj4/nSaXr6+tZUmr/I89rECCwrvtXMkAAMTY2Fpubm/Hxj388ms1mli9VhZiANiLSzthbFE81kaCBOmLCWrLXqHuPjo6SLEO0Tk1NJYE0MTER29vbSaLWhsb6fvzyL/9ylhkpefHs5uj8/DzLtqqyqyqTIiLHRODi9CZ2m5Ksqm2p6ShjKAjZUQrE5eXlmJ+fT394fX2d/YkEZ3wNv4d4RUogg+AGNos6UkDOHlB1scu1FxH/ygYjAl4NKq2DqtKimFQ29MYbb8Tw8HAGctYZm9Pr9bLHU90ngsqaRINh+AlqjqrScc9K8qrPRuZamzs7O0meGJfaD64qvZzkJ8HAb/DtyJBaysZvep++WObHvvOs+/v72U9uc3MzG8MjDATcenM+f/48iX/7eHd3N8fDvFIauiiealkdspdqzb40B/ZOLTe1/9miqq6y9/lyc4D4qkQ5oof9tU4p6UdHRxOT9Hq9XONKzPgWyRJ2SJ/NxcXFOD+/O83OOoIT2G0nVfJz29vb2dxeFYHyRUm5mkzrdDpZlaBU23jCW77TSYCwcz1MpPal8jmzs7Oxt7cXe3t7sb29HQMDA/H06dOcH+tUn1FzLBbwf6QUjFGTVNbh6Oholtm6d3GD/WV9+z0MX4lD+1mZJdtAqWR+2Bt7vN5HjRngSRf8FHFfkWCtvupv6+ew1/YmArgqq6oCmE9AKos5qm/4qF4PpNTD9WG7HkipD/ACXBEFVCs1G8PpCwwpekiPOY5KEiCAquon4l6urecEQCuIAIhqMB4R+Z3K2ziUiEggqoGtMgbvE0RyaL7L91QVycjISHS73fydACAiMptEcSPzy+m5H8qRsbGx6Ha7GcAA9VXR5PQbRECtWR8ZGckTeoAwzk5GD7BD5ADdslkcm2fjEAW+VBGXl3enzj158iQl6u6VrJ7MvgYW+jRMT0/H0tJSvPvuu/nd7733Xs7b+vp69kWQGbu5uckjgCtJERH5LP54Ft8JhAkqr6+vU6EVEX29nDRXpeqoANEfa8pnKnUE4M7OzuIrX/lKNBqNVKhYWzJn1hxFwcnJSczPz+d8kIePjo5mLybg+fDwMHZ2dqLT6aTSrsrRBUYy10NDQ33HVgNlwOrMzEzs7e1lYOC5fR8Apl+VsUU6DQ8Px/b2dpydncXCwkIsLy/nugH82AOknKyr+1dGgTijDAIQBa7r6+vx8uXLVDHKCEdENp4XdBu/iEibRGFGpUMZKZiRBXd0NGBur1qvVKKCF2WoMphXV1dZ0ox08bmIFQC1qiSV8CFcbm9v80Qv9rIGrZoEDw8PZwmDNdJsNjMwcg917Qm62OLaLyvirsfX3t5evP7663mioBJopNKzZ8/SDjcajVhcXMwgzCEIiB7g2ppGeAHSyNmqWlOeiTjhZ3Z3d2NxcTHVo7LHzWYzOp1OrlmXz6pqnsvLyyQD2XAKFj6K77Hn2V+23yEEgjaBgV5J7IXPZAPYTbZ/YGAgS7Ltqaog5RsqoWA8EIXu0VpDeDjZspI5mmMb38PDw1RmDQ8Ppxq33gu72+v1Ynh4uE+hdXp6mnONBOdTK5HIV+zs7OSJjbe3t5lUYZ+shYj707Aqsf/+++/H8vJyEi61gTzCArHITlcVAp/A37Evlaz0DO12O37t136tT0kF2wi62+12ll0ODQ3lwSfPnz+Pj33sY5l8QNrV4BRZxCdRc/R6veh0OrkvjbN1TfmHrJqZmcm97jP4HWMJS1Ryxl5xX9SMbJp5N378arPZTGLfSZzstvePj4/H22+/HRMTE/Ho0aM+UoBvohxFeu3v76fdhPuMSyUGkZqIJP0Wa0IQQQsTKJGC12oJqsb79mgldCRArRMKPb2Fqo1FRFpXfLP1bT793kmR1isbVEtOBwYG+spIt7a2siG3+7J3d3d3MwliL7Ghe3t7OT61FJO/ga/tYYk5Cs/Hjx9nSSoFMF+PNEEQ2YNbW1uxtLSUfr0SYfabPoU+h/Ip4r6Pm/05MzOT5Xvm2Pqo+9ieqdUCcDn8Y34RjRGR/eD0mkLWwtVUeYjlqampvhP/rOuRkZFoNpsZI7Gh7pkt4xfEPeIEvu3q6ioajUYSxzCOvWPvVtXt6elpH0H2Ub0eSKmH68N2ffTPxPzHeFUpLedZZeo1G8WpCJqmpqay6WJEpFEVEMl0Tk5OZhNWgJ4s+OzsLIHn8PBwEmOAydHRURIf/nQ6nWxkqQ8Ph6TWW/BwcnISL1++TIet2TVp9vHxcXz1q1/N/invv/9+3NzcJNgUIAPh19d3DW6BOeCxZjeBImUYiDfZw1pyVE8JBJhqNm9kZCRevnyZEl79B/SFABoQIXpVyKoD/xw5osAcTU1NRaPRiPX19cyca24pqO/1erG1tZVjASjo+/POO+/E4OBgHondbrfj2bNn0ev10rEKAl6+fJlBrB4yVFxXV1fRbrdjc3Mznj9/Htvb27G1tRXdbjfef//9BO81my64EgzL3lLoVAl0nSNlL7V59fDwcPYzsM6Hh4fji1/8Yrx48SJLQ957773Y39/vK52sjbwBuLqXlIYoD5mZmck+EtRInU6nTx0HpANeACawL4Cyl66vr1PVpAE0MqGu45GRkQyMXs3qtdvtJGyqssRx60oslWrs7u5mQGK9sgFIpqr0EVxeXl6m+gTpg4hAxACQV1dXfQGugOT4+DjHzPhUUC9QZTeQqmwAO+YYcHvF2CvNoIaJuC8rtl8Bf3O1t7fXV3KJgNvZ2cleHtfX13kEt8Ca7UMimxegVvAu20pBocyz9heq6kZziKhkg/UFdB8OkGB73JP3CNbeeeedeP78eX6+52crIu57D52dnUW73c7SOaSIcRscHEyFoyauSJTR0dEkcyp5WxuTs3VIKaeBDQ4OxsuXL7O/DFVcRGQgomTRfmQH9BOqRDP1qKbrFDmCLnPn9CkqYsGUMrD9/f2+voHUiLVvEbt8dXUV3W43fu3Xfi329vYyYH358mXfiYgCu4uLi9jd3c2ebvbY+Ph49og5ODhItZ7xFBDrHSM4Q9Z5Lt9Ry4Q8j/kRPCGWqWYFqQhi5Kc5qIksrxfMGgv7mg/n+2r/LUq1ra2tLBE8PT2N999/P3Z2duLZs2fxzjvvpLrM+xGtEgkUWebDGkG+VJIHSUTRxjZKbFTbtrW1Ffv7+0m4SYzZQ8fHx4kt4BUkklK6Xq8Xp6enmfyRUPAccAlby1YZT0E2u/7+++9nUOx79N+z7t59991477330i5PTU2lLzg4OEhCm31GPpoPdoo/sq4iok8hhqRx2qhSfkSJ8ahKL7jP+peE4ithMX7aOmMrlfi7j93d3VTjnp2dxc7OTuKz999/PwkHNoUiHoFS/V7FE5IzlMyUz9YKBe/JyUns7e1lAgm+haOUybIXo6OjeS97e3tpSyPuKxyMK7zlewcGBtI+e5/DT6q/NN4IoYrnJXLEEr1eL7a3t1OxSZ3uUCH+ll906c9VTxytSYRXVbXIc8pcySKqrO3t7a8re1WCaO1Zd5KOMEPFvZXoYKftD7YdrqtrTJLo9PQ0dnd34/z8PH2vfn5iBDhMHMZ2sccI3urHPspXVVf/Zv88XA/XP4nrQSn1AV6yIpyVPhS1fIjTV1ojo0RdJasuc11l7oAaAgNocBra4uJiDA8Px+bmZmZJKzhuNBpxenoa8/Pzsb29HdfX15lNB/q73W7s7e3F+vp6lqBw0AiP/f39+MIXvhBvvfVWqn2q/Fj2qTblvLi4yOaCy8vLmamujrM2bUbsCXqomWpPGuVAslecTavVyn/v7e3lSXVq0IFyZY8aW1IGkFwDgbVMxn2fn5/HyspKBiQrKyvpUGVkZHRk7si2Z2dnIyJS9YCgq30fGo1GLC0tpaIAKIu4bwy8vb0d29vbsb6+nooVcyjYRcJ0Op1UlAgiRkfvTsqrpQDIT01sNXKuGajt7e1Ua8imUQU1Go1s+Fznd3FxMQmNqo5xpLPsMjAv+F5ZWUnweHp6GnNzc7GxsRFzc3Px7NmzeOONNxKsCkS2trYyM60nVc3wr6yspKRfY2eBEbBWe1s4Uc1zTk9Px9HRUTQajQSUh4eH8bWvfS1BUUTE0tJSqh0ajUaCMIGYdYh4UJqwtraWIO76+rqPRKmlOgJkpxBqKktZtbu7m2NzdXWVqkdqPmA1IhLYR0SStO+++27OdQ36Bd9Vfm/tAb0CmPPz8zwNbWNjI/sSKcvwHqRXDaAdrqAczxwhcxGb9T36RtXSh0pKClprKZHeR+5Fj5Qq/4+Ivj24vLyczVlnZ2ezdGVtbS1arVaWhsriavB/dXUV29vbsbm5GZubmzn3i4uL8Uu/9Evxfd/3fblWqVUkDJTEKQ1hZ63r58+fxzd/8zenAshplGw7koM6lUrS66n9VldXs1+RPXJ7extf/vKXY2FhId5777149uxZ/HP/3D+XQYVebspzkSFVoYksr+ttZmYmG3RfXl5mID84OJilgYjO/+V/+V/iX/qX/qUspaFCUVKnd5Hvl+DZ2tqK999/P8bGxqLX6/X1RaLE0r/m9vY2Op1O7O/vZ5kl9RkCgCrEvCK1r6/v+pUpg5mamoqNjY0kTKgGa18fKgZqNOO0vr4eh4eHSSbU0irJj0rKUsMItJwUyM4br83NzYiIDJSRUp5dMDc+Ph4XFxexvLyc/kOwfnBwkMqH0dHRbLrsooCl8mu327GwsJD79Pz8PBqNRrRarfjqV78aAwMD8ejRoz7FKDyEAPasBwcHsbGxkYcLwB2UG/Pz87keqxJYckRPRIHz3NxcdLvdLMGqCk6JLj6XHUS6wj3sy+zsbOzu7sa3f/u3J/ksgEbKUndsbW3leHn/F77whfi+7/u+LGtlV58/f573DTOwS3APAnlmZiZtlyTm0NBQPiO1LN9SEwTWA8K71WrFxcVFtgZYWlqK3d3daDabaduMCay5uLiYZLUyf8Qz+93tdmN1dTWJ+/n5+SRFjo6OshzUmmXnVldXkzTp9Xrpo77zO78zqwxqOawEA19xcnISm5ub2TC8nkKM2ETi2V/WJGzEBiCUYCfJwjfeeCP29vby9N+ZmZl4++234/b2NltmaKz+7rvvxpMnT5LIHx8fj16vF81mMz7/+c9nP7Z2ux2jo6OxtbWVBCj/XftWSoY5vMHevr29jV/4hV+I119/PSYnJ2N3dzeTzcrmbm5usjRWmaUm/MaOXVX+iti2t0dH705g3d7eztNf4SQ4mK2ifh4aGorl5eW+MnKJM6c08hcO8alJM7aRIhauFEuwgfoURkR0u90YGhqK1dXV+KhfD0qph+vDdj2QUh/gBbTJ/tSeRsCiIBa4UPIlk728vJwlb4IiNfgyzoJlpJesqMCtZk+ptGTmGo1Ggs0q45ZdVH6zuLiYZUuAjN+Nj4/H937v90ZEZEYRALq4uDuKttfrZYNeYzM6endEuqa4x8fH2XNGIAt4AaL6yAwODsby8nKeIgVIPH78OMem0WhkE1TZpZpBRRoCYADz9PR0vHz5MlZXV1NFIlONZPQeICTirvnkwsJCX0lSxP1pVDL5sjveT1VAuj0yMhLr6+sZDAmgNAUHNKqaC1E5Pz8fnU4nrq/vGqc2Go1ot9sZKNTs3Pj4eDZ+VLaojMsaGh2961/VbrezrwMgXcsINP9GkgISIyN3/TI8o1Mgt7a2MiO8u7sbh4eH8fTp08yC6ask04kAEiw4fWZ/fz/m5+dTLaaMDHl7cHAQQ0ND2VcJoTM4OJif66RJxMV7770Xjx8/jq997WsxNDSUPY8AesGEnyNJZV2Hhu76UTx58iRevHiRY6iPW0T0gVmKxXa7ncfAj4+Px1e+8pVYXV3NbLKyTac4vvPOOzEyMpJEl5I0ZYrWwdjYWLx8+TLBn3XsMAABy6slxZRm5vPnf/7n4wd/8Acz8Ly5uYkXL17k8dSUTACMIAUhIUj33aOjoxmgmve658nqj46OYmZmJk8zqnJ9TaUFgxERb7/9dh5XbU2znXqnDA8PZ0Nlzz41NZWgVmkRtQriLCJSrVOJWgGGMpSdnZ1U7N3e3ka73c5yt/n5+ZyHTqcT29vb8eLFi9jd3Y1PfvKTGUj/M//MP5Mn5iGStra28nRIgWjt0xIRqdr4ru/6rtjf30+yfWtrK1577bUYGBjIeUM8InmN98HBQd+R5gj30dHR2NjYiIuLi3j99dej1+vFd33Xd8Xv/b2/N0kCBJKSqtHR0Zifn4833ngjtra2MgCkGlNKNjh43w/uV3/1V9NGXV5epl1WAtVoNOIP/aE/FH/7b//teOONN+Lg4CBWVlYyaPvkJz8ZrVYrXr58mfZb6ZVnsSZHRkai1+vFl7/85RgYGIi33norpqamsj/a1772tfjYxz6WRJeeRQjenZ2dGBkZSSXsxcVFvP/++zE/P993OMDw8HD6JkGv01/b7XYSy/YW1drg4GAS33wjnEBhhQShjhoZGcm1x95MTU3lWun1evHaa6/l/qy9rfRAQ7ZQfM/Pz2dgzL5Sv1UFmZNL+dSI+xMUBYwC+//3//1/46233kqV39raWpY+1T2NaFUSy+9+6UtfijfffDNxzM3NTWIZhDusQ3GEKER6fPGLX8z12Gq14vHjx+kXJW74WyQ4whyJ/+6770ar1Yo333wzfefy8nKMjY2lfYKdah9QY7u/vx/Pnj2Lx48fx8rKSnQ6nfjmb/7mVKesrq5mgo7Sj82UBNEzsdPpRLfbjUePHiW+QDZtbW3Ft3/7t6eaxxrShJt/givZO6qxm5u7k/8QXu+99140m820h4h/qn1kFX99dnaWJ2Pq7+Q00evr6ySIa4sJ6hokyMDAQCaPKBQlaN96661sbm+cYGc2lI9CxCI4zs7O4p133om33norE5ibm5uxvr4eY2Nj8eLFi2g0Gvm+6enpTJRQ5bD5MzMzsbq6micGq1bo9XqJPff29jKp1Wq1YnFxMQ4ODrJn56tqrC996UvRarViaOju9NZ6kIFk1PDwcJ6SCxvae8ipiIhPf/rTMTh417x+bW0tk0WdTifXlHGXTEYMr6ysJGb65V/+5RgcHOw7zfFrX/tatvqoCldjdXFxdyCGUk4KfH4C8UpZ7GAgrRJOT0+zbUct2+bLEHkS/PAs3yz+ubm5ifn5+UxmI6kerofr4frtcz2QUh/gxZHXkiWkEIVKDSz8W9lNzfYjd2T+Ze5qo0NS7Pn5+TTet7e3sbS0FOfn59ksE4DUzwEBBAzI2lKn1CbLsoYCOUojwKeW20Xc92FZXFxMNRYAyLHJGPtMSpmqZomIJK70NdFI9vLyMk9PAsSnp6fTOQPWnpGzAqARZBQ8Svlq7xZjZV58BsIBAadECdAzn8ZbWQaJtLK02dnZWFlZiZWVlVQnTUxMpIoFudlqtWJ2djYzP+6l3W4nAKQ6oP6ZmZlJ5RMCa25uLiYmJrLRPaJPBtfa4exXV1djYmIilXuIBM9AkUDpE3Gn/Nrf30/SRECCANPLpdVqZQkFEEW5YB1XBQ9Coq6P4eHh+M7v/M5UFClRi7jLfgNE9pSxo3SoahINqTWrps4D3Gtfg9HR+5NiKIaurq5iaWkpdnZ28jQ441/3KCAve19L3yLu1A3Aq/4n+jFE3PUS84xInOHh4VTU3d7e5mdPT0/H/v5+3Nzc5MmOAgDzKNsvePd81IA/9EM/1KcYUy7UarWi2+1m+QyQjLzz/1qGibBkG5XhCnaVbLBvxtt9IcvcgzLaoaGhePLkSWaArXn22P+t1enp6bS9BwcHaZftQaS0LD3FH7JGg3afOT8/n4CXTVFqRZlUT+VyEtjg4GCsr6/39YFaXV3N/WlcnV5ZG/VHRIJv64ENtt8oHgSFCFVr0Br1Gs+vJM1c/n/svXmMrPlV3v/U2mt17VW9d9997ngHBjxYwQgsQIkUCJaiIEQAWYmCbCTi/BGRRAqBBJQoEgoR5K+I6CfFQkoUEgkSCKtZYmMw4LFn5s69c+/tvfa9t+rafn+UPqdPlXu8MY49N/1KrTvTXcv7fr/ne5bnPOcc+nIAyKyvryubzRqLBLCBM4k+ISmTTCZVr9dNFwOgsdcEz+vr65YdBzTlb4uLiwZ4vuc97zGwEOZgLpez+11ZWbHgF7AgEAjYfkrjTHk6ndY73/lOY11hbzudjt71rndZk2AAmZWVFQOKsHG5XG5iPbED3Hev17PEUSqVMrsCWI08o6ckGUuTs4Os8AOYyvlAF6ErWGNfOkgACeOBUjnOLCw5/3tkAuYa5ZWUrGWzWbORJMF8s3P2o1qtWjKBYJPEA/aNMi/vZ1Cm1u/3TY+FQiHdv3/fnikcvmy+jvxxTgGT8L0o77m4uNDdu3fV7XatNArwEeYjICu+CWxN7zvl83mTQZhvc3Nz2t7eNsAAEGJubk65XM7Ovi+RPD4+tuEhjUZjonUC4Co+Bb4HJfXYUNaVxCYAXigUssQPLEWAeYBTngldyvuY3ghAAlvHJ1u5J9bf9xQF5MX/BPw/OTlRNpu1ZEggELDm496PQI5DoZAxTzmn5+fnWl9f1/b2tg0ggSkmXSaAKF+nBPLi4sJ8N0olYSly/ukzxeeEw2Gtrq4agxswDYYpwznQI9hOfBiAdgBOzpf3nX3JGc93cXGhW7duWXI1mUyq0WjYuSS5REKLz8aXarVaNpWackPsML43SUB8L1hQXndQRQAABcucM55IJPTud7/b2nNgtyiHJYbwpbGcVXQm7G/P1qcPF7oIGwBQxvNiGweDgSW4sQv4Tcgk30WCEnl7lq9rptT19Va7rkGpN/nC+SeQwfBjuCRNBPU4PpRokKEj4IWC7J0TgB2CDIIaMnFQYXE2PKCFkST4xFkhU+jLLKhhJ3CFdUM2lwCJjBqgDk2occ5RcIB0vkcLDgDvJQsiXVJ2MdLeEYYFwGfwPDi3BD6wv3AQvLPr1xlHgWAG9pck66uAY8Pe+WbZ/X7fnEJ6X7GGGGucHDLoOPjsaywW09bWlqrVqmWIoVT7SWGU9czOXo4fRsaQBYCWtbU17e7uGvsMpwpAlH0DdPOlHD44oF8DgB5OMGtNDyVo9gRnOI042wCoAA5ktaCDS5dNMAmw+U4CcA860G8FBmIqlZqY1EUwwR6xdwT4vudFNDqeNETjY9go3DuyyhlghDJrhayQQU0mk8YYw+GjATvlLR5ooE8FDaJhE9BIlOCf/fH3xbMwYhx2yfn5uZrNpp0nACtkjt9xnrkXymIJRiXZ2Tg/P7fGz5xjf0/IKM4gwQgOMyAfpRI+Sw5w4MFy/u6ZNDi2lEJIl2WH7CnfCUMReSJggdl4eno60fvIn3GvD2CKMPUPnUs/HwKvVqtlz0UpE9Og6MGDXaAXGmcSXeTZBzAPBoOB6Wg/PACd4kEdAmEYBJTd0RuIzDqyg8zA2vKy5kssKY3mu4bDoU2igtkzzdaZn59XtVo1WSGLPT04AzsCAOETGtg2PpcyxnQ6bQwv+tnwWdgb5A79NT8/r9nZWa2urtp3810wINgzmp0DHAEEoj95DwERJcussy//9P1YKKlC56JHSNAg74CxMAcocabkHvtVq9UMdEZufb8d1hQAm70nWYOe9HqB8w/QCADM+7DX2BDP1uC8AbrUajVr5kzTbRjGW1tburi4sDYBXl8Hg8GJ84WOBRiCYYat4YxzHx4MRWcAInPO0VMAByQssBPsIYA+wTYyiR2EzXF6eqp6va7Dw0M7m9Fo1FjVBNGAErDPAF3QNcgNAD6+ky9P9vYSnYWO4+yznuwLZcuUepPowpcDpPB9GNHp6XTaerj56YMeMABwos8p/hPNqAH2OKcAFuhTAAv8JPYVH5QpogBA7XZbr7/++ueVgHqAAgAYHQIwk0gkJvpJwkrGd+V7AVCw7b4hPfYGAJ+SZMpUYYbhj/B6WN7oJRJM6JOjoyMD/QAPOcskLEjwAKhSjkq5LT4Itgtglu8DYMQ/wI5gp7ElsH+p+AD8RHeyDtg2GP6cPz7bs0FJKtMv1iej8TNYd3zv+fl5i2OQPc5SIpFQuVw2uQHkgs3v/Qp8xmf9ugalrq+32nUNSr3JF84OzgFgFMYew8v/ozBR7gQ8KFqyItI4UACMwHHkdZFIxBx9D3ZhEAAYuCeYMvzgsNBYEjYO94KBheHBM8J88IGid7SDwaAymYzRmKEcw/LAwGK8JJkTR88dFCuGPRwOW08u79D0ej2bTEPZBJkWnCWcLzL8ONs4dLCj2DPpsoE9Dh1OIVlZspcAKfQQAEykvIwMIiwe9oWeCbFYTKlUysqems2mGWUcS2SI8hcy1NDrAQjOz8919+5dM9Bk72AHeSq7dNlTglJN1p+eGH6PccgISHB86R2A48Wa4aAAeCAnyCjOOQ6NBzlwPMnoA/SRVaTEU5IBojxvo9GwkiXfl4SAhYCP/cRRAyBlj32g5Rl9yAgZQJ6BvfZgAwAvWf/RaFze6R0jguF79+5pOBxONLPlflk/9AjnAtljPShdIGDygCpBA3uE3AP4drtdHR8fKx6PG2COfAD2IG+wUtBnvhkz94ac+b5cnHXvXALI++/C4YW5MDs7ayUanM94PG4ZfgJ1QAvKb8nWIkP9fn+ibALAknvyZS1eHlm3arVqPcAqlcoEAxb2xdLSkoGJ7XZb+/v7arfbSqfT1tCa8fK8lyAQHQu4zflhrT1wTxBG0AOjZXZ2VrVazXpzEJAjDzAmKfFCF1NG6dkyMJJYG4CFRCJh5SwEM4DYvumzP88AAQQMlGd5oJU9bDQa1iDes4TZf+yZT6gQvMH08iASwZE/O+h1z/gDACQIDYfDxn6DgQzLcTAYWP8k+klSGon98cGoB5Y58+gL7hNACLvkk0mcF+49GAwac4c1hEGBLPE6zh6yxHlmsqhnSi0uLqpUKimVSk30DCO5g1z6fpnsD3aSCbHSJCiCDGInAbEAiLDV7Bc2bX5+Xul0Wqurq7q4uGyszvsAB5BR75N5IIkfmJ2sJ+wT/BBANP6fUj58H8AVQJSLi4uJgQTn5+fWowddh07K5XJW4oecUU4FEIeeHI1GdtZo0M7vfYKFtQJs8uAKcoi8oGcBj7zPhJ9B/zoP4sFy41k8kMzvfFKJyaIw/HgufF/PGvLJDGwVPhjgEj4Xthk2N3aeBJBnyHIWfDIY0IV1wRegzBN5xibhN9J3iXXzYBe9pGAhsaaceZ+AwbbjayBjPlHIuvAegHDkDVtNmR7MMvxIdBkMKM8494At+4v982vE6+hbu7u7a/sL2IXeRsbRD/jm6Ejvr/pJg5wXzuf5+blNe0SmSHBij/EJAeRIdPmzCuuU8nKehRLdZ/26BqWur7fadQ1KvYmXz6ROl5/44A8DjcHEsZZkRocMiQ/oCbL4LgwBDi2GBKfVB1wYe0plCC5QPsPh0MotCLqOj48t++ezvp61QkCEg+BLTzygwBWNRlWv1y2zwZoAknmHnc/HsHPvs7OzymazthaAEOVyWdIlOMFEk+XlZWMaADBEo9HPK3nw2SGyxhgunNBgMDgBbOGQEFycn59PUJHpDUVpoXde6TcxGIybFN+/f1/JZFLpdNrkqFwuW6Na9pzM/ezsrFKplAGZsJAw2oCSPihg73Dc2SuMP0E1Deu73a41LifzipxSXiLJJsrhqACmTvf1IkD3JQMEwjhLAAc4TjS2xBHkfBwfH1vmFpYUTlej0bBpc5TEUUKHM4kjzjrhPONY+dIazyiZBl44E/Pz8yoUCibHZLZHo3HzZMq5+LvvveB1hC/PAKAl8PL9QPzZ5bzPzs5aI1PYB5QdkOH2Dgc6CjBxcXFR9Xpd5+fnBkL7rDv6BfBWkpU/eCYP5bAAJdwbJT4EvgAUnDcCCMAVSn5hQaEbeAYASQBG1pSgifOM7kIWYV2gg9FdBB1+DDg6HIeZcx2NRicmrR0fH5vDjdONLNJricx5Nps1AAVd2mq1bE98uRGAhC/V82vAs9EUm6CAM1ssFrWwsKBcLmd6EBvFfgPKAAYxlAKmFwEOJakkMABsAAc8s5f3AfYCGHCu+RcbiF7BZnlGC/1BKpWK2Tquubk5lctlYxigy2BoeACPM0z5IuD1+fm50um0TZMiuQNLCKAOhlKn0zGg0+sy9DtrRUCJPsN++NJCSfa9BN/oCBr9AmqQzPDBJIEsYAn7zjNP61n0GuASfgA6CzYZss1zeTYL901AWSwW1e/3LSj3/WG4ZwCawWCgpaUlNRoNY2nAzEH+8YPQs7Ozs8pkMlZ2BGgFaAubgoDd+wwwlQGl6J/pkwbYHF+yyzPiU/Ad/X7f/AsPmo1GI5vaiF0BhIDtCqhFYg0WGaCBB5jx2VZXV41Z6/cL2QIQrtfrymazJi8+eYm8YYNYZ4J8f1aR3VDocgIaNmBpaUlHR0cTA2oA0n2SELviQSN0K+sDWOf7BmJj0PXYEPYE2QoEAsYmD4fDunPnzsRUUXxeD5YBdJHs9P4yvS/RsUwHRU/SJ8zbFZI+fAa6GnY758XLELoLuUFHMbWTMjVsgZ9MiA5Cb56cnEi6bOrvfWl8GpiZnG9ANnQ2/qckY+f5hBznj2RyOBw2hjSfiT0ATPS6HVmkRA9dIl32LuOcsq4wVEn6ck++ksTHCd534jPx25hGzl574NbHJc/qdQ1KXV9vtesalHoTLxQl9csEivQ/QJn6zDdOiiTLWmOsAA4IwDE8GGkMLIYNR5CsBmwmMu6AJicnJ8bYoKcKTcPpA4GzsrS0pEwmM+Gkk+HFYYdV4Gn3OHV++gqZTkk2qQ72jnSpCGH14NxQ8lGpVLS2tjZR5oejACCVyWTscylJwwmt1Wo6OzvT+vr6RAYMRx2HFMNGsO0nhUjjMiaCfpwRMnA+251Op7W0tGQZKvYUgKBQKEzsZa1WM2c3mUyqXC5bGRn9XqTxhMNsNms9JXzW32fX+X/+RtDh+57wL88GQIEM4dAB7hDUeQo264Wzw/ewFgAHs7OzOjo6snJKsugAEKHQuPcSYAcOZrlc1vr6uskUDgZTdJClxcVFBQIBlUolG/MNOIJccX/cA0AXDDvPzvFBGmAETCSmeOG45fN5Ayd5ZuQdJ40Ajd5EgCW+DxO9PigbwsHi7MPAIDAjgBkMBha4LywsqN8fN0mngbFnaOLU46TC5gHc8r1jjo6OlEwm1Wq1FA6Htb+/b8EGOgv9wln0WW/6lwDkcO5g53DF43ELJnFaCcC4f6/vKMstFApWAkcgQvAD6MB9+SAhEAhYvy8Cbxxm2IS8JxgM2nPRu4uzUa1WNRgMrOdHoVCwKUeRSMTAUUAjmB4EoN1uV+VyWfPz8zo4ODCAkwbbnE/WxJe5sX+w0LyTD0CGLgSQjMVievr0qQKBgE1oWlhYsHPigRh6YLEvrVbLEhW9Xs/OHvaDxrroOVgV6BTKTACsKb1hKiHnB7nnuZHxYHDcp6jRaNhrPTAGMMUkVHQO54d/6W+GDHF2ALWxZ6zlcDi03i75fN760NCraTQaaWlpycB4z+b0TFVs88nJiSqVioFulO7TwJmgEOATm4oewR6gJwH6saHYPIIvpmWhS+jxBVjCWfYTttgDDxhIl8E6IP3MzHioAmWPzWbTelJKmvBJ+Kxisah79+4Zi8azsLyd8kAMk1RZH5hQyPU0axpGHrqRMkBASso8aSAej8eNocbek4jzpZKABIAq2AcAU5hP2WzWpsqdnJxMlC/TxxCGx9nZmcrl8oTuSyaTZm/972FTAu6iV9DZABM8sy+P40xT9uVZTYDRrHu/3zdGEuAHQB72BcDGA5Q+UcL9zs7OqlAoKBwO2wRoAEFsKnuPj0zJP7YqHo+br7m3t2esmWQyacwzbDPygy2np5MH6EjOVSoVJRKJCb2Dv+6TQKenpwaiAQ4B0tDiAh9hdXXVZKZUKplvhW3xjEz8StaAKa70KfNgNcA2gBP2cXFxcULOsWXsB7aRWMP7MyQ+SIBxdgB5GLrBd7NHgIf4D778E1n3IDrnDQAUefEloDC/SB6z7r4NCkDSdL9N9tUn5Dnnvo8Ve+fjjuvr+rq+vn6uZx8q/r94kT3G6EsyBQvVv9lsqlwuGzCEY1qv181Jhq3k+6dAdcZo4kB4YKBWq6ndbqtWq9l7PSgWCATMOSVAwgmFJRWJRGzy0fz8vHK5nLLZrLLZ7ESzwEgkYtkjHyg1Gg3VajULCFutlo3spl8JLAKfyfaBH3/3AT5lZdC2FxYWLAgncOWzcVIwlhhHsq2wefzo56WlJSUSCcv0Atz48h1JE/0/AKswqLOzs0okEkokElpdXdXy8rJyuZxNJZHGAQRZdphJGEomqc3PzyuTySidTqtYLOr09NSyvTheh4eHOjw8VLvdNseZPQNcqNVqevDggb324OBAh4eHKpfLZsx9mQsZZzKHgUDAGFOnp6eKx+PmHDCNDscc54FyHNYWhxpggR4GvAYnJBaLWZNwykGQDUpKcbhgNzB2PZ1OK5VK2fS4z372s9rf35d0We6IrOJo0+CesiD23PefQT5xtPv9vkqlkoG5ZMFpjopjJsmypd45ZM0AHunlQoAoXfZtwpEmqCYYwHn0gBk6YTAYqFQqKZFIGEOKfhaAYYBS3uHu9/sWdHOW6P+RTqclXYKVBAfoG1hrBHPSZdkL91UoFFQqlUx2YIPhPEuyDCjBKaUeTGAjOAWYo4QUFhL6DGcZtgflLgDjHiyPRqPWgNkDygTPHnCnbDoejyuVSllgRuNfAqhMJqNYLGbNew8PDw1AWVxcVDabNR0D0M5UyHA4bBPPmFTUaDRUr9etvA8glbVinQDJeS2ALNPeKBGi7NlnzQGrOKs487FYTEdHR7Zmf/7nfz7B4EAfNJtNC/TQJQSbhULB9iiRSOji4kLJZNICcvQr6zkajcu5fNDupyACxMTjcZ2enqpSqSgUGpcOx2IxFQoF7e7u6ujoyErQOOPTDJjz83PlcjnlcjllMhljWcGk4D55n2dfedZQLBabKK3yNtiX52EnIpGIJTLoqeL7nxwfHxsDFbYgQFC73bZgGBAMPYI+kGR23jOBAFlhehWLRWMrUfriQR1073A4bihcLpe1s7OjV199VTs7O1baFQyOB1nEYjELCBcWFibOEwEmgXQ8Hlcul7P+S4CxBIokKEjAZDIZk/V2u62joyNj52EzYCziC/D/AN7YNP4FTMYWwAzzTHB8OJ4hHA6b3ffJqouLC33uc5/T8fGxcrmcZmdnlUwmrfSRhBfri31EdmZnZ3V4eChJZtMikYgNb8APwm+gubxnasFMxodioEMoFDIWswetsbv4qzwfeiiZTJocAdrw3egrzwTC78AXQp/Mz88rm81OlHaix30PRAASgAzYfp650+129ejRIysNDofDymQySiQSE8xckhGzs5eT3Pr9viXFsPeJRMKYouwjf0fX+bJ9qghKpZLtP4MhYPS89tpr6nQ6E8lGJg7jY3EGYbmR5CNBwcRWZANQiH/xCZADktwkr2HFYQOxP9hmwGX22PvByFU0Op6Ox1oDlFMaCNMZf5DYgLMEQMQEWnrI4U8D3uOnYWexbzxnOBy2NgHY8GAwaPtG4g0gCp2Cv8M6oU+r1aqBa8/65VnVX+7P9XV9fS2ua6bUm3h5Cv1oNDIghQCl3W4bwIRxwoEYjUaWVUkmkyoWi+YUAtoAPmFwYGkQcMXjcTNINCMmQCFgw3iQ6STownDX63U9fvxY73nPe3T79m0zQPRkWFpa0u7urjKZjNV5Q/uFMQGzymd5PbOGLJnvaUHpEBleQC6CCNgVgGYEJxhNnCA+l+awZIWYzHRxcaGnT59OjEbGmfEZdemy3M2XmeRyOUnjrPLq6qo5HvSIIbNOwA2jgbI4HBMCk8FgoGw2aw5xu92eAICGw6EePXpkNfmhUMgYFAQWa2trls0CsDw7O9Ph4aFRq3d2djQ3N6dWq2XTuJrN5gQjDdYY2VvKcRh3D0DDlEDpssk9fQVwAGBvwNypVqsGMrLOyWTSHDAARvYccAHHEfCWUi4aiZLlhmVUqVRsBDwAi2/q7Bk7N2/eNJCKrB3PT2bNM8hgnZCNPT09VbFYtOmQ3Dt7w6SaYHA8JQvHEUeXkgEYgK1WS+l0eqIEjPNbLBatQTPOKec3GAxatnR3d9d6e9HDgQmFGxsbtn8+ez4zM562COMFh5ipWNIYBKBBuzQOeldWVgx04XzMzMwYuODBYfYDOZ0uxfPZbc4OzDYyyQRne3t7unPnjvr9vgGSnr0B04ggwcskYMHFxYX13iAhQEkdTBLP+CK4IxhgLDvsIoLWtbU15fN5A4JIHqTTaa2trZkehlXVaDSUzWZNxxM8bm1taTAYaHl5We12W71eTysrKyoUCiabPDOsBIAkbMBgMNDa2pqGw6GxC6LRqO7evTvRvB6AHl0LSJJIJLSxsaFWq2UyQnCysrKiRCKhJ0+eqNlsamlpSclk0ia/ElzeuHFDr7zyijKZjAWCBH6SjJ2E7UR2Zmdnlc/nJ7L73Bc6GDtD0LS1taVIJKJisWilYuji6eBpZmbGpnfBqqEnVrfb1fLyslKplDEXut2ucrmcTcWE4TM7O6vl5WWzgQADrBPPg52TZGyrUqlk4DoAzvz8vJVsk/3vdDoGdgLQEdBxnjKZjJ0l/A+ABz+9FVuazWaNoSPJEl6cb3Q7wTX6EVYY+4HvALvFs8tg2xCgYmu2trY0HA5NT8HIo8THM57wMaQxU6fZbBrICbiFbfdlSCQl0EcLCwtaXV21ALlSqVjJLWw3X5pKM3r0N3oQkB/WEWeaBvTRaFT5fF6xWEzdbtfYiqlUysqSYNXAjKOsvN/vq9PpGBucv5XL5YnSNnoReTYUepI+PDDxmPBJwgEAJRaLWWkoTBQCd0nGCEIPUkqFTccXY108w5h7Gg7H00lp4F4oFCYYvsgmLDSGBHH++W5JBngCGIVCIRvkQBK3WCyafxmNRg1k5X5h++7t7RlYD9v1pZde0nd+53eaj314eGiAEPKIvw4ISn85JuFxPl977TUlk0nzzWHtch44H+Vy2SaZ4kP50kB+jx5g7yKRiCUq8SOJP4LBoPVuZGomPjX7iN2UZLrNg+UAcn4SH+A8SUwqEbClgUDAfB/ewzN41ityjl/Dvx7QQvdxngeDgXZ3d41Ry/X48WPdvn3bkp8+kQQ4hR2gBQKtINCH/y9c/6885/X1bFzXoNSbePl6cwyPbx6J80smT9KEkl5bWzMHHMYLjg7sBl/3jxMsyQJljASf6R0FPh+niEyWbyguSd/xHd+hTCaj5eVlY1qdnZ1ZI+0bN25Ybx4CJO4NwGlhYUFHR0eSLg0aBsXX/VN6hUHh7wS1ZKiGw6GNKQ6FQsYcWl5eNjCFoN2X3RCQkEGKx+N67rnnDLChvMA3PQRcIGDxJQ0w0CQZc8KX//jSAAIHGGM4CzgR8/PzFtjA/mCaE1kyWGk4/N55JeMICwKgAjYVTmU4PB5rXK1WDSSIRqNaW1vT7OyslfOQMcZZJhPmKeasCX2PCGQJHiktASxhLfyI6K2tLVtLnFw+DzAT4Muz4FgXgiuYAwRSvV7PgL5kMmlAKwEEDC0CVUp56MPA/eHU+nONjLPXPHs6nbYeDmT8OfesAQHxxcWFTS3zpTKAJ2TUvWOKY7u0tGT0c0m2H2Qs+S6AaQAI+rz4NQJ0I+vKPrM2iUTCnMzpTDjnkUCNM0qpARPouFf2CZmAacDf0HcEEJImMrU8H8w6Mu/cG4DX8fHxBFjH5+LYSppgOsDww/kl+89z+LIB9CKgpnTZS4eSa1gZjKhnj6Vx0A67CpmFoQJwAtC1uLioYrGoXC5nzBnPTIBRBJOQ9SfT3+v1FIvFlM1mradaOp02VhtBOkwbSosIlgAMCRjQx/wLo4XAg72IRqPGSCGQh02STqcnehihl+gL6IEowDFkDACEQQGpVMr6kgH2YF89Mwmg0LN5AGrZ/0ajYfdMmTTMFeSRPVpbW7N7GY1GWlhYMNsDQwq9AKjhp6zx3Zxt9Ko0LtUCkCFJASBPnxtsIkEqJf7Yb/bVy3oqlVKj0ZAk8xMob6XkOJ/P6/Dw0Fij6Lhebzw5cnV1VTMzM8bmQ1fzGl7vWRYEhv3+eJgAwIwk07P0A0wmk7ZXgKvoY5itnNF6vW5rGo/HrQl+Pp835ifrhHwiw4DxgLCwWPls1hPfyQNivA5bABiEPYEZ6Fk5XtbxS/guzikAEmy+hYUFG0zBc/IewBiGpODbYV/QTegsEi/4Y9O9t7CxgOnoW/QqCU/AJmzKcDhUoVBQNptVrVYzPeRL7rmXfr9v+hD/k9I9mGPcB7KNbfJlkdgt/GCSgehMfF/sKaAz64ZfwfPfv3/f9NPJyYnW1tYMHKJ0zTfP9noQucbXADz1bO47d+6o1+tZjyjKHD1zGqAWMAhwluSob5QfCASsFBRdR+k0oDzJKs44+hZ5x28B2EL/47MhZ6wfsjQ7O6v19XW7Z/aCKoBSqWRAIuxGrx8o2eSzkVn2BoAf/8gnJ3wyeHl5Wc1m03qx4hPCvB+Nxv2j8KMlmS6e9lmo2PC+zbN6faWsp2sg6/r6Wl3XoNSbePkAzfcPwqjjLBCweiAilUpJkmXm+SzPYsEhxSEhKCPgwxD7LAPgDoEhrBPADgIMMvij0Ujr6+s2eYux1QR4OPgoOwIHAmMCJd+HiADQlxxiLMiSeVYCChEHQbrMusBkIWt67949A7R8AOmZIDgrHkzypYKe+kyZF31TpsukeM/q6uqEgWWPodIDqFDaAluF3gnD4dD6RiwtLZlDTzkPwEg+n1cqlVKn0zFgMpFIqFqtmpNeq9UsOCFzx3fBXJiZmVG5XLaSO0CIWCxmgBGOOCU0viQNeSL48Vkwvg8nw5dt4HxKsgAZgIXPRq69A+Up6b6sh9dSXkbZmndqE4mEUbr5fN+vCLkkaEUWYAISoMA08gwuACrOOWcO+QOoJdACcJUuM/04S8gK38/vAPY8gwhdgizzw73SS+zGjRu2TzBSfD8OnGDAPx9wELhRGgVojHOLHPAe9It3aH2pkncGOdvQ8XGk5+fnjXGBTmPP2D8+G6fVrzlAHg6211HoGYA9MtEEy4BJvk8VAQQAM/raZ69hWKIv6vW6wuGwbt68aYFvs9nUcDjUxsaGNTcn8CiVSsaEpcSOgNNPQOO7+G9vDwDnWAufjfallJQ3bGxsGOMCW8SEIxhIlHGwhgRe6AQAFViylMpQ5uHLnrAXBBjoaJIEvocboJovUUdfcCY4/5Q3drtdA9kBBdCNMOWQf3QEQRbApD9THsQnePSgNToTtlAymbQ99XoLW8t5ggGEPmNNJE3YUX4IBgnSIpGIldWj09EX6CKex9s0dANldYA7rCdBMjqA9cJ+erabB4tZX3o8eWayL7NibUk+kJDDdnhGEvrQ21kSTdzX+fm5CoWClZNJ0q1bt5RKpawcDXkFfGaNaSTtfQ3smyR7TkkGTvI6GLw8/zT7g7MJ6xU2ByVSp6enmpubUyaTseeIxWKqVCqq1Wqmg/BLAB5gqOHT4Cv5BB/vA/yt1WpWzuUTfb40nx6KnjUHEERCjXNHcE+CAV8JGUL2Yal4Hen1BQADSSg+C/8C4IbfS7LzxD3iL7KeyPpoNDLmOMAL+8T5bbfbBiBi45AV9BXsHximfk0ADNFJkkx+8E8A42GcUTKOTvf6kLVHltE7rL/X5dg57Ce6ivWMRqNmP9Hdkmw6MzLH5/Hs3DvnBRuO30Jyb5oFPRqNbACKL8FHjyIjHmDmntgTgNLT01PVajVjPXo/nf/3ABWVJoeHh9rc3LT1Y2+IqXwsgAySfPby5ckBz+p1DUpdX2+16xqUehMvlDOGWtJEHfRoNLKgodcbN3kly08JkiRzisiUYMBxGlHWAFI4oLyfjBcKmAujDcOH4AtDwNQuMvbeCYCZhAHG+PugxQftfBd9IKZZXoxuxQDhMOLQ4UxNZwMxUL7EzxtIShk9eMfeYOx5ZhwUgl5PAYZZwt/8GpJBxaiTqfPMhlarZaUXODo4nTCVAIi4H7LirVZLpVLJelThhOEo4ORIY/YQDr4HX4LBoFKplJaXl3V4eDhRdgQLgP3HiCNfZP9pNors8fxk9Px+w7hpt9uWLUPmufeLiwtjhkmXU8a4dx9oTTujw+HQ6PGj0biEBAo54C4OCpMOvXwRmNK7wjtNBMUEjjiIrIskm/TEdDOCGL4/EolYkO6dKdaMskpKVnH0/D4AFjD90DPqYFjhBOLAe+CE0oVms2lZYBo/8/m+AfJ0kDwYXI60B1wk0829UeaEg+iZT9KlM+OBNO653+8bKMt34uiiPwBNCP45j+gAD3YhGx64Z08964GyFgAUAgOAN9YFBo7Xxcgj+4iDC+gUCIx7vbD20rg5PHpycXHRgM5ms2klWzjnnGXumX8pZYCZBeiM48+acXZ82QK6GduyvLyspaUlawTudTaBiGfzSrLeRjBkyc77s03fDsoj0BPIM8xA6bK0BL2KvPAdnANKYQC5A4GAMUmvkgX+bbfbEwEyupnzPxgMrM8aZWMebD06OtLp6akBbthe+iGS+Ol0OgoGg9ZgmRItAC/YpgBCw+FQOzs7ZncBT9nTxcVF07MwrXwPF1iSlLSw996WAZx4djBnBHDMA9p+DZEDdBdyjk7kXqPRqHK5nCUZPCiBb4Ct6Pf71vgccB8Z9yAxYDDlzzBVebbBYKDj42NjSPi/YQ+wETTUx956oM8zLmAtdbtda2sAoM/F/SF72AHWDeBlOBwaeHR6empluJxvmnsDLvr+mfiJDJUhuYOs8ay+FxWyDajEs2MXOEOsD2fNg08kMtlr9MW0b4S8ekaP96dIZODTeTYZgAlJH+8TAKIgOwwLwG7S94g14v5ZQ0rwvKzRM5W9RUe3Wi1Vq1VVq1VJsv1BTnzfI85vtVq1fcJ++HVFJiiJJfGYyWSspBEf0MsM6+rZ89gL9DxACs8HSAbzC93BGrBO3CsXSeZwOGwtI7gP/GwPyuFj87zYYYCgUChkjPPZ2VmtrKxof3/f1oI19ew9/+MTXIBBgGIkbbF3sPg82N9ut7WwsGDlivw9n8+bT4k9h4nnZZ6zBkuWc5fP5/WsX9eg1PX1VruuG52/iZfPdJCd8JlDgkcCWowQjqMky/oRIPjghOylpInMJL0qmAgCcwKHCnYBvabIBvtyB9g89EYi+PRB7HQmDKAI5wBn0DsqfIekiUwsfREIpgjkfUkATjnBKYEE909WnVKYYDBohhyne2ZmRvF43Hp78TeyU5QV8Hru34N6PKukCar/cDhUpVLR7u6u2u22MZdKpZJqtZpardYEyIahpVTLT+QD0GISDIaT5/flGjhFlD9QFkQgAcMnm83as8/NzVkPHZhE0MbZW5wUH/zBTqJn1HA4Lhcku83vANkoH2U9fXmkX2PKaghSkB3WA0eQ/4fp50sEYfzwmTg+ZM5OTk7U6XTUbDZVLBZ1fHysUChk0/OQs5OTE3tWfse6sP8evMGJgrHX74+bnwIG8R4fIDQaDR0fH9vewWDgHM7MzBi1nu9mHWn+jZxKlz08OE8AjuiY4XBoQTglKD4wwrnjfBJc+6lZ9PwiKOFZ/NqSScbZ9cA5rweE9aVMgLEExh7E8wwJssLBYNAa23M/wWDQ5MY/GwAdzrwHmsl+01uCfUf3oEe5l+mgjavZbBrwdXZ2ZgwS+tkEg0EDSHHGq9WqMYRgjPHs6ET2lWDf7xUyCABO2Z0HOgGZYFVwXhiEAIjKuWR9/Bli/aaZMoC9yDOTywBqOTs+8KPhOgEHOgpmKEwR5BZQSpI1Mvdnl2dGd6MTWF/0lE88+CCftarVaqrX69bgH/uKPWSNGIAxHA4twMOewogDPOO7SLhgf9FJnj3N/cPQACzg7A2Hwwl5gOGILPoziQx5pkIgEDBg2ZehemDEJzAAb0gM0N+x0WgYWMD+U6o0Oztr/w04AigJUMO+EcDCyj0+Pla9XrfSc4A1fx+cSdoHkMCApUXz6nq9rlqtZnoRvUMyyLNb5+fnra8RtpgS82lQDNYIPg5AFYApoJkk82Xo/1er1YxR1Gq1rP8c++zLr87OzvTo0SMrH8UewE7hWbFP2EyeCwAfn3AwGJhNw89hXekz5tleHnyRLqdHA/hiVwBPYbexdpwvr3/QUfV6XU+fPrXyTxiK+FKe9c7eoav9/QFa0ddwNBpNAOw0bIfpVa/XraSbMyXJBmSgYzlHPhHlzwXnyvu16CvAUIDQo6MjFQoFSbKJy/Sywo8DVMJX4Ofi4mIiaYX+QT/NzMyoWCyq3W6brcX34PwDJrKH6FJ6tpKwxdbicxNTEG/w/kgkYkOL0AO+9H06AeUTHawja085O/eMn89+U2IJqw2f8Pj42Njs3r9Bz3a73YkJfD7Jhc5EngDVWDMPRF9f19f19fVxXTOl3sTLM3coEcGpxLh7Zg79RKBJA9Aw6hZKNIYDYwgNGQcfMApWADXeKF0UM6BJIDCeuoGCptzgm77pm8xpw5BQTkIJAGV6gF409AQ0wJEDgMHocq+skc9c8rkYM9/Px1POcYpmZi6bmFNSwWvIUjEliwz5aDRSLpfT/v7+BKMMQ5pMJi3o8D0AYHFx3zw3maZyuWxlX7DfyOxjqBcXFy17D8uHbD1BVLvdtglQTGuZm5uzSYgEX2Qqo9GoMpmMGWqamMPIWllZUTab1Wg0MkdsbW3NAqFAIGCOM/dJBhUWHiVygBY4r2T3caboKUEw1mq1LOjEqTg9PTUZIkPmwafT09OJrL50me31FO5cLqdyuWyZ5VwuN1F6QIay1WpZ6SmOPay9mZkZewbOop+kGIvFbOw89+OzowQowWDQmBU4+/49nj0A+JFOp40thONFsEozV5iJUNyly0bryAABAcG0/7xMJqNqtaqlpSVtb29PMGvIaNOcGGCJNZ6bm7PGwzdu3LCyGB9MA7T4CYe8H5ANoAD58EABQBSlZ+wDABg6gPsDKAPw39zcNJCd4AC9yr/oCV/qR88vMsBM8PR9KtBV7IPXRdIlMH98fKytrS0DpyjPabVaxi5LpVLGeGs2mxbUohMZa835mp+f1+7urmq1mvXP8ywE9pCAzwcwMLMCgYCBUATv9XrdJnqdnp5arz9ADgAGSuICgXF/uUQiMbEegN+cZ84KZVycAXRlr9ezXi3lcnni3peXlycCb2yHL9lBLwQCAZu66vsbsia+Vxhn02ftYW0AZHvWIiXUt27dUjQaVTqdNiAvHA7rxo0bVmIKo4VMf6vVUrvdtpJvgkeACM75c889Z6AZ90dihfNFoOfLYjkDx8fHpsPRBZ7Nwbn0ZX25XM7WUbqceOYDbdYMWQHMJ8gHRMRPAQDh89Ct/jPRoYlEwhr9A54wIa3T6UzYEBIn2Heeh2AZAAQghwb4o9FIzWZTlUrFfAnuFdAZPYFdSqVSxngDMJM0oas8wwgfxjORse00NEenASCwB+iyer1uwCdnPxweT3dEh8RiMWMUkfDivKRSKQuskUNJtm+AH9hNkibD4dAGOHDPjUbD7g2AjWQUCRo+o9/vGyMwEAhoZ2fHSnWZ+gv47xmJAOrs/fLysk5OTqzUmp6FmUzG5AU/iHI4QByapGOjBoOBlfsxbCAUCk30XASI8wxUfJeZmRm1221rXSCNwTF6bmazWfNV8VPRMfQQZC+SyaQBv5zdxcVFO69Meuv3+1paWlI8HjffDTahL6cDLMGfX1tbU7vdNl0NI4xeo8gUvgC6+eJi3ICde2QiKCWsgHzYbfx8kifYr8FgMHGeSOCyL4ByyDWfjQzBQCamQGYAKGGuk6D0QBGxTiQSUS6Xs7/5ZD1nm7J774uQ2ECf+s8Nh8Pa3t62c/4sX9dMqevrrXZdg1Jv8uWDBxQrTj0AExRV/kYg6MEaAn7psvTMU4lxujGS3ohShiNdluwBbPF+7g8Di1NH2Z4vqSAb6APjYDBoWUgahvN5OCYwBwgSYVX4yW44rIw6JggkyGJ8uv/O6bHm2WzWaOE+qCEYBtAJhcYTCqH44gAR9LE3OEG8FyYTAMY0uJJOpy1zxf4ROJCtgloOO2U0GqlarVqfJ6abbWxsKJ/PW+aw0Wio1WpNlB35MhfYApSNQCHPZDLGCsLxIPOIofYACgEuzw0zh0BM0oQThPMOi4fMmJ9KFg6PGzOTDe92uyqXy7bGBP58BuUwng3EPsOcgZHl6fpQ4emjQMaNEpLFxUUDr5BRpijt7+/r1q1b9p3spQck2HfuxTdShSmDQ4Yz5MvCgsGgNXsmk+fp6gSpnBNJJsv1et1KDgHCCCbQAQDTgIDI2MbGhgUs/vzAyvMU92g0qpWVFUmyBq0wWXiefr9vwAYOKw4h68O9IVsEJtLlhC8CePQDpQvoKN+EmH5LsAdZo3Q6bQEe+0NQQP81QBqfvUffeFYJ8k6Z7Onp6USvF88s4DNx0AeDgW7evGllkwTtME7ZS/o3ISOA3TAnAELIagOE8p3oRy5KrFg/dDilDARLTHKFhUF5JowKz9ri3tHn2AKe15fjEQiiezudzgR7bzgcKpPJGBOI5IPvcTQ7O6tcLmff4XuJcG58U2rkn8y5D1QJOnCmsQ2+vxa91ab3gFJHWGN8PlPx2H8YxNiQfr9vv2MCHHoduSIA92Ade865p7QJO8s9A9byPp7fl0CiewCskI3RaKTNzU0L9LE5sGo8E5XJib4ciO8AEPagBkwyzqFfa84Me8bZvrgYT1E9PT1VMpnUysqK+Tw0WfegMKAkjdAzmcxEWRIACiyVXC5nTCx0FaCZJLOZXs4BDlg732eMRAfPg64BIAXkhfkJCykUCllT6q2tLdOn+AsExSRgAFexcdxPKBSyBGUqlTIAEwDe+2aUiyL/gBuwX/G9PMjA+sDonGa6A+4gN9FoVLdv39brr79u78WW8h7YLuw/viLAOEAjoBMAoR9c4RmfgIGcZ8Ad9AKfD1OTci98FFiKtFPg80maZDIZ9ft9lctlAxBZp36/P1EZgK3FXwIY595nZmbM5/J6iu/0PhFgHucfm08yOBgMWukve9Tv9/WOd7zDGt4jk55J7/eh2WxqMBgPBGB9SGb75IZPcvOc6FCSk5xPEoyU6/pkFOfWl3QDrqGD0HHIuC8hxN/D3uFL0ttWGoN5zWbTkkL45IlEwphg6PRwOPx5/4++xIZ7Nvyzel2DUtfXW+26BqXe5IssI2wlAgAcLoAhmFMAIDh5vA4nh+CEjIqnOBNQ4hQRoOFMYxTJZAEm+F4SPljDKPspYgQ7vo4fJwgDRmYOB46gk+xhu922Eh+MA06Nn3pF5k+6NFCeWUBQwTPj4CeTSUmyscw+U++BOhxywInRaKRaraZ4PG5GHOeE9/iSC4Iz1g/2CyVF6XTaWEiBQMDK2QCQcPaRA3rTMD6Y0kN6k0BrR45gxdCnBqaaL/2QLpuS01eh2WwaowMmBTKBg4j84TBLMvnhx/eRgraPk4kzSrkkTosk1Wo1Y22Vy2XLxnEOvBNOySglFjgefh/JmgEe4cRwz75pL2sOsEngDkMD4AwQlnMDo026nDqH0y6NA0Yyiziy7J2kCfAR5449ItiApdRut+2c+3ILMp98NvfP31ljn6Uul8smH2TcYdWwZpwn5ArnDKCNgME7k4BsBC/IEHR8zgivx+lEXnASYYQANvDdnmLPXlPmAjjMc3v9hzygk9AxyDryieMuXfbo4rMIZAAgkHeCMwIjLsBydDgBBPcQDoetPJa+crBB0SEwygAUkFv2e5o5xLpzVlg32JusN7LIOG/Ohmfx8MM6Eiix5gRBnDtAJRh0PBvj3n3vIa+v0UXD4dBYVnzn8fHxxFABAg2el3NLMEX/GsB/ypZhtlKe7UvV2EvWkymUlPUMBgMD7gCpKPOB+UmQCeOU8fME2YBOsAfRo5Q5YmNZE0oxSSJRDshr2C/kCcYp9sf/HZmh3wx76u0m7EFkBvkBdEcP+pJt75/AwCbI9lMuCdSnAVt/nilzPDk5saEu6G1JxuJA3/uEGUy/eDxudhhWDd8No5S9xi+B6YVMA4BiI2KxmPlesFmw3eggdAbyyWcBSvkkHX4Q/TopwwPIPzw8tGcn4Qa4lMlkFI1GdXBwYMA755izDJjGfmJnuF+AGM8OhFXok04+KYLNxSaw3rCOkQl8FWwPADuMJZ+089UC3Btnn+8DiJPGwCpMcr4HXUbJJcAIdhW/jPch/+hxmGsAxiTmsLmcTeyWX2vOK76jT/6gKynBw/cgAQH7j75w/jyTwGRv2MOLiwtju3MffC+yADsPf4JzgB5h77EtsDI9eAX4xD4gA+hWAEjOD348YF8sFlOz2bQ1hInoW0D0ej1r7QDIzOcA9PsLwMTHDpxjX6aMLpmfn1ez2bQkJ6xkKg24eK/3KbDlp6enxiJDpp7l61kHpQKBgH71V39V3/d93/e1vpXr6026rntKvYkXQZB3APm9ZyQBaOAMoAAAIHCOMLQeLCGLQyaB9/OdZMj95DCv2FHuBBs+K4+j1Wg0DKQBQIDVxDPi+JPtkC7BKC7um9+xHoAfGN6rAhEAN8+EIDvf7/et2TJrAS2cAOPi4kKNRkOVSmWi7w+ZcfbA91jwRtwHhDgqBMcY7n6/r42NDbvXzc1Nra+vK5FIKJvNTvR8wqHDQQdwpD8AwA6lNbAUcNQI+jqdjjXvLJVKKpfL1qAZpkmlUrFeSp1OR0dHR3r99ddVrVZ1eHionZ0dVatVAzJwKD2tm7UlEy9dlgXg0BLsdLtdKzn0GU4cJoAbnK16vW49D9hvMruUs0gykIozIMmcbO8MsZcAbDj/OEHIE8AowSvldIAunBf2A0eJs8z6+N/R44GgzDNocGi9o91oNHR4eKhCoWANkslmw3TjXKAXALJ9uSlArnTJeCNzSi+iUChk9Ho+EyadD0JhSnFu0EGVSsWcahxmAka/bx4o4l+CASj7gNFcAPEeYPTnnnPHvfmzCDvOr43/fl8GQEBBRp4g0/dBQuaQP+7f63CekWcn64vzXSqVjOWXSCTsHmnUjFNOjyJ6x/keI8Vi0TL6BD+DwUCVSkW93mWPO68POU+np6eWTGBNfCYcRonP0CPrrOvFxYXZDQ9m8rfd3V0LjDm/gUDAyi9wgD14cHJyYn20ACs56x4gmQZX+Rz6csHm8TLkmYwwFWBSAKwQqBJALSwsKJfLKZFIKJfLTUzprNVqBt4S8NIXp9PpTLBtJBk7k9JgZBoZZN3ob0OSx4M36EsPoAAiIgfIuWduYEfYa8+44KL3FiwGfBOAPfQ4Zw4ZhyXFe09OTiww9qwvfnwJJpe3E+glglaeH/+F5AnPwn0AlrHm+Bf01ul0OtZLinXhPHoGLs+HXHvGFYAH9gk97m0+F6wQXyYLsA7ISFIGIE26nHrG/5+cnFjPSYL7ZDJpMjcYjCf3se8k9thPvh+dQPsHZMqDnj64Z+8478gpoDhlT6ybP8cknZBH7I9ny5Ak8+ArJZQkFwAMAdq9bfd+Ma/lnmFv0p+O5C/J2lqtpmKxaAyqZDJpiRnkE18F+4CuBxDDhgAw+v5o6D18YHxnbwv5Xp8QJiGJPkcfAYh7sBrZ4Sx5W+sTNTDq0BUkjPgs/z0+fvCsV1i4nF98FQ/CIrv8UPrI3gDic2/eppCU5jP4fHQtaw3jlVL66UQa4CD3yNqyZ+h5fFUfI+E7eJCZZ6YFybN+eWbcl/vz1bzq9bp+8Ad/0PyhD33oQ8YU/qtcPokeDoe1ubmpj370o+a3X19f/9c1U+pNvDCmkiYy+xgKlDB/92VVBDrNZlNLS0vWk4JeBzS/BJwA3PIlCBhZejZgXDC8lPZ4ZoM0BkBWVlYs04MBGwzG/QxisZg5AjAcMEi8zmfU6FFSrVbNAGLwer2eksmkOQ+eueEzsAAEsAC8c9Fut3VwcGDZw263a4FePB43hxGj7J0AQLlwOKxGo6FgMGhZKAA0nCwM83RWmLWbn59XLpezZyYzR0bL9/OAZi9dBsr0xgKQAAiieezS0pKazaaVQIVCIetfwmcyBjqVShnYw+v5HtYSpc8ehsNha9DuDTvsNRx5AlMf/OBI4RTA/vEZe5wXX9I2Ozurzc1Nra6uWhYOp1S6pP1TQgrDBJYcmWpAgf39fevrBPOIs8XnASRynpDf4XBckhONRq3UioAP5xxnFEeJsjPKLzib3W7X9k26ZEPhkNLkkwA1FAopk8kYmAiAUalUJF32nWD9Tk9PLUhDhtA1HihmXDNgQKPRUDqdNtYODB0cD1gulKJwz6yRZ5rhnLO+nuHlAzhfOofcNRoN6yuBvsJZ9vIC8wOwg2fy7CwaBPPZ7B9TuiiPYL8InGDnwcbzZxxdhEPLs0yX9PiSV/TjaDSyIAHQs9/vq1arWVNn2DSwWM/OzizjjB4GKOas93o9Y4JIl+wTgjVAoXK5bAkNAJ9oNKpGo2Hfyfh5WCMEe5zR4+NjFYtFra6uGoBRr9cNXOd1lIr6M0cGPRQKWU83ZLTb7ardblswhy6nfxG6xIMsDCLgu32APxqNlM1mLUseDAbt7M7Pz08E7B5E9kwW5J/zhB2uVCpaWFiwhvqAyN1uV8lk0nQQrBp0PbqAnkLoCthU5XJ5ovQUIAQdGwwGJ5is+BFLS0vGMOLceYYJ+sszo5BLAOFYLGa6yDMXsA2A5sgG99hoNLSysmIJLJ6b9/J7nH8CT/Q2eomAliQF+pl7S6VSKhQK1ovRg8C8B+bK8fGxMePQefRhZE+xawcHB6Y7+P1gMJgod+RfmNKA8oBy2DfWHllptVoKBoO6efPmRA+qRCKh1dVVY2JQQj4zM6PV1VUrC5bGCUiSB4Cjq6urpu8rlYrpXvw6gLy5uTmTL5Irp6enKhaLBnSw9py7hYUFVatVK6H1CVP2EBAJHykUCpndOjw8VC6XM1CH0m3P/PZgBr4iPbf8PtLrE38FX5LzhN8UDAbNF8A/hFkFgNHtdvXkyRNLOmALfN83AD6fOAoEAnau5ufnjfnMflO+S3keNhkfBOBHGvcqk2TDaxioA+MMphSDHzxbbrqX3OLioiX/otGojo6OzCcCPKUKg5JjX6Ls/UdsNKA8Jdn8DfmCVUevLfZQuuxFBxhaLBat2bkHtrGZ+Ph+kAg2FGYWOgS2F20X8Cews/h4DIhB9lKplMkrZen4FtgdD+ghSwBr2KVroOKrd337t3+7fuRHfkQ/8iM/cuXff/AHf1CFQkG/9Vu/pV6vpx/90R/V3//7f18f+9jH/srf/cu//Mv6nu/5HvV6PX3mM5/Rj/7oj2phYUE/8zM/81f+7Ovrq39dg1Jv4oXipvG2dJm9x5nEAOFg0kCQ4LZarSoej+v4+FiJRMIca1+e4j9LugycUMIYTF/igbOLY0mgOTMzo3Q6rXw+r+FwPLFLkjKZjCRZaRmKHkWOI0vGhH/7/b45B9Jl8EwjX2lsvGEn4CgQIOK4SJdThciSYNjIIpNB8r2GMF6UTEFZhkaOsffZOAwY9yJdTk7yxts75mS0MIi+HIaAm2zxycmJBTc+m4zTwzMTtAEkwA4g2Or1egZKMdEFR6XZbKpcLmt5edno0pT8LS0tKZPJ2N6SJQJo8H0BPE290+loeXnZHGT2ib4U7DeUdBxl1g55A0SQpNXVVWv66Z8DIAG5xBlC1ra3tw3gIRiF/l6v1w3gApikqahn4bHvkqykgCAxlUpZZhTAiIzadDYXefOlJvwd58xnkXHuKVUhW4xDmsvl7H0AVjMzM+bAAhahN3zmEZAUsIL+CmTXmfTHftHYmbINgAxfGsDa+ZLhq0oaOAucMeSh0+kYkECjVYDFYrFogZdfNw8UArhzn4Ci9CeBDeSdZz7Pl934MgX0y2AwbrTsgRZfjkqvCmTPAzcwEQEjCYAA8jjTBA61Ws3YU2T10c+np6eq1Wo6OTlRPB63ciz2AbkETKPfFEClByEoq+JcRiKRiSlHCwsLBoYytZMpdjwfLA/WsNvtTgChMzMzyufz6na7SqVS9l0EWjwjE/6QVRrvosdZU0p4fCm4JJNjQAsCfJgMMHppGk6ZEX1MZmZmLOj1vWXYN+QC2SGR4svoAG8oxctkMlpZWdHCwoKVzAFq8Xntdtsmg/lmywTT6FmeE+CIe2JtAM0JrBmD7pkjBH0eHPcMAYAhZA25B6jHRkmyfaYfIq9jT31CgbWBbURfLc+a5l+SISQ7ANbxdQAkUqmU2THkxpfb8FkE2IHAZQPkcDhs/QABErBfrDHAN3KJfHFOms2mMpnMRJIMO8DaEgzDXibhFI/H7fsASlZWVux+6DGXTCatNxb/XygU1Gw27XexWEzLy8s2/AD/cW5uzvo6zs3NWckrzaQBWRhIw0XvTvQmvgvywYX+w5/xfiTn0AMNMNrYc+wpyVP2cDgc2npSTr+4uGi2gzNJb0e/zp5NiJ7zyZ5YLDbBrCbRkcvl7NywrgCDMGsAkelDBgMNH4WEDK/D76I31Wg0migZnJmZUa1WmwD35ufnlc/nzefxbCl0ImcW5pePC2A0A7Byftg7DwAje75iwifH8Nc5R+g4/h+/y4NM3E8gEDCWK74AbFDOCQAocsZ58/2b0IE8M0CkZ8riJyGrHuzku7Aj8Xhc9Xrd2O/ID/fo7Qh2emZmxnr0kViE1f4sX18p6+mryZR69dVX9Ru/8Rv60z/9U33TN32TJOnf//t/r7/+1/+6/u2//bdaXV298n2PHj3Shz70IX3qU5/SzZs39e/+3b+78nWJRELLy8uSpI2NDX3v936v/vzP//yr8zDX15t+XYNSb+JF9gNjgaFibP3CwoI5/TisUJYJgPlXGjuP1HsTKKDUcbykS7o9jl8qlTIHzjsPfkIVI2tjsZhN+vMON05KIBCwDCVgBqUIlL7heHKfnmHkywa4b4w3BpPeJ9yvdOmcwz44OTmxII0sEYEbxtuXTJB181ltSpcI/MiQ+TJBn8GaDgAJcnG4PBvEGzufMcbZ9wEBa8TzSDLa+8nJicrlsgUcABYYfUAsgm+cUYJ5skftdltra2u2V6wtIAP7gnFmvPv03kmyDChUdh9Ye7YLzgZOK89KQA3rDkCH+4K5QbABiMBe0QiYLJd3nBOJhLGZcNBhUuHo+jIS3zeJnhi+BC0UuiwRJdDh/JAt92eWz8PZxokiaIUBwnlHPpaWlqyPChPKcNZx/NhvSdaPxQfa0iXYDQiMXLE3NIWfproji6wrmWX65rTbbcs+U9Y0Go1supCkib4myB8yTCmYp+fzd/adoJHPYA9YA7K2OKy8H9CIgApwGpliPzirsFQApDwTyvezICBAVyHLvs8X9wf7ApbL2dmZleRx7gnU6EEDWw12omdBsb4kHQBcPBuWEjwAHvQOTCf6IgEQE2AA1tdqtQmWFCU7yDY9l/w64rgDJsBMIQBgbeLxuJLJpDECTk5ObEoUkzVZc8ovAHN4DgBXZBv9S2klQTNgp2fh+HIazhiN3Sl/vLi4UK1WmwDM2ftQKKTl5eUJxiwBMM+L/MCyYf/Pz8+NmQgADBsMHYvMc4b5QY/QHwtZJ6AHcEavc2/YOC7WzYPF7KMvi+Kc0bQYefLBJfd/enpqE/MAopAHQA7PdEM3IRuwZWiU3Gw2FY/H1Wg0TO+Fw2Eb7MHEU8AlSrFhW8BuCQQC1jA/FovZ3rM20jiZ5p8Ne4C88BxnZ2dmM7BB+BqsPc9EoJvJZKyPJUxlPgMdUi6XdXR0ZEEzgAQ/lNSSqIDxgZ4A9AXshSFMIgbWMeyeacYpz4oMAmbw3MgC4B7nD/sOcNHtXk7yxLfCn/W+iAeN0LfJZFK1Ws2YLvhdvqQWJlckErHS5YWFBdMBgICS7B75jNFoZD2ifF8nSXYeOSecIRie+CcMiKEsju8H9MDmwxxj7ZBDmEb9ft+acNMjzJfLAwR7IIQ9wsf0PQVpeJ5Op21PPXsX34bkK74p1QP8jvMEMxPfyttASiEDgYAlFbHJ+Hm0PFhYWDB9ip1FH3g5I4mAv8Zz+tJyn4iAKYd/wOvRbf6eqaCQpGw2a3EEPq5PNOP7kYDls/GXnvXr6xGU+sQnPqFEImGAlCR94AMfUDAY1J/8yZ/ob/2tv/V57xkOh/r+7/9+5fN5/cmf/IlarZZ+4id+4ot+18OHD/W7v/u7b8jYur6+/q7rnlJv4uXBBh8E+oyfJFOqtVrNWDawi3AIpLGyxvHyJWU++0p5E1l2HEoMNvfg2VU048Sx842tAVzogXB8fKyjoyMdHBzo4ODA+gbxjPSsgZrO/cOYwLkB4PBsCF/SiMPHhWODkSUgwKBhdGjOyTp//OMf1+uvv27BV6PRsICNz6Nsje/gHngOn9ny+3p+fq5CoWABCww2+sY0Gg1Vq1W1Wi3VajXV63VrfIk8AAJ4ujzNdmma22g0rOcEwCRgAcyXhYUF20fWi3ulVweOIEEtgZUHP7xzKslkBzkBXCNA9mVl0Mh5Dr9u7AcNP2HK+UCOvl8+0AaYApBaWFiwEcU4FsFgUKVSyTL3OBkEc965xxn0jAmewf/dB+MEQAQlnBvWip4kBAw4Oz4gxOEMBAIT/UZ8eRBBHoAQpRh8N1nQ4XBotHucSjKRnDNYAPyLrMEOJGCMRCKqVCoGKLPn03vkGz6T3YUtwFqhJ1hXAgCARc6gZ3expugJnht9x3N5sJfzFwwGDVQAZPFsAMqG0IOcd88k8ewwD6Z7EBU5ly7ZFsidLwdA70gytkG/39f+/r5KpZIFX5wPWJCFQsH6vHFGYFYAwntQwU9mBZjybBLPwvGAHWdUkjGOzs7OTAfzvYARgL2+7AE2CUF1Mpm0oIjn4yzxe8AuD4ggC9zvzMyM2T7uGTnxzD90KoE4gR9BMcGon+pKcgfGEbaq3+8bs4ISV4LohYUFZbNZYx0QGEYiEWNm+MbiAN/n5+d69OiRKpWK+v2+Hjx4YEGsB2AB9QFzsDnIKN9JIki67OHHOiK7rA/JD8/+BVRCBwQCAdVqNZN9psDxOs9E5EzgQ2BzW62WgfULCwtWNuRLk7Cl+D/Ym0AgoEqlYnsfDAa1v79vvkCv1zPGMfqdz4EhWqlUTNZarZbteTab1czMzMR0Ucr7+H7uBR1FU2n0HHppNBoZmI7dp5zIsxwBn0iGUCYIaDQYDFQoFGyKJpMvWW/0MpMrYVA9fPjQEmVeNtD9yDIAAzoLlifPj63a3d01Jk6r1TK2DXaeNQYkgaXkexE1Gg3T6cVi0WwySQZ0P2Ah/gKfzR43Gg17dg+MUsaMvoGlip7lXpFJbAzfgX/pGeuwLz3AgyzAPEfm6JWGTaMk0D+Xt8U8E+AY5X8wt3u9cTNzmN/0Emy328YIp/TRM59gYuOXcg6QK0AZ1pBkrU+moh/Ozs5UrVZt/yQZmws/AZvPmfQgO3pFukyyExt45poHPvFzfNzCvXs5i8VixgTnnEsygJHzhdwAmPrkZiQSsXgH+w2YiZ5E12NLPBuaWIs9etYvdNtX8iPJGPf8vBklj8Vi0YZOcFGWWSwWr3zPb//2b+vBgwf6//6//0/vete79G3f9m362Z/92Stf+wM/8AOmj+7du6e3ve1t+smf/Mm/8n1fX/93rmum1Jt4ERzg0KN0AZx8dqLf71sGVhofSrJ1NO8kUMcZ8MEHzi3ZYb43n8+bIQEIQmFXKhUbE4+DglGjUW6tVlMmk7FSlnK5bH1DRqORZbG4XzIRnjpL1ocSJJwpnOFSqWQBLk4tARjGCaABdgEOO0EDgAvNZkOhcRPLeDyuTCZjpR9LS0uqVqva2dlRKpUy9gvgCMYRBgz9lFqtlq29L2uhzl2S9W1hMhW9HaCOSzLng+cYjUbG/Jmfnzdnke+itt+DNQASBA0zMzPK5XJaWloyZgf/0iwzl8tZ9hJAwTt5OOSAnUwjIgDFaWw2m8aswwnGccLoI09k8ylJouyAIAGglLKYQCCgQqGg9fV1A7VY14WFBQP86vW6PXs2m5U0Li8lo4czTiaU3mgwfFKplIEukqxnVL1et8bIlAD0ej0tLi5aEDfN2mBNCV48M4ceCpIsq0xZAE4fsoSDzg9gKIEX4EEoFDIgAqfWA0A48LwWADadTptDVy6XrRxUkrEgkUtA77OzM6M90w8H+fc0fsomwuGw9XECWCKrTnDYbDa1v7+vpaUllcvlCQeecyhpAsyGvUTgi/NIQMNz+WEOkqwcEplgD9AXrB8Ag2fgeKea7K7/bhxeHzzPzs7aiGtYEpVKxUDxRCJh8tjr9VQoFPT06VOTB9aJgHdlZcXkhbMpyYAlz64lQOC+CZ4Ar9AtNJamXJYhCwRTgOCAYzAxYAIQHHe7XbMLNP0+OjrSaDQyBiRyjQ6FvQIjlTOdTqdVLpd18+ZNGwvPM/IMnAu+2ycImC4FKIVtLJVKZssAbOm354Fy2B+RSESNRkPJZFLpdNpsG2DA/Py86WqaamMn3/3ud1vTbXSml1nAeOwyeoKAGZtNKValUjHbNhwOVavVTLYrlYo9g89gc2axk5Ts43dUKhWl02kLzGiQLF0CXuibRqNhLC96b41GI7300ku6c+eOBeLIJLYpEAio0+moXC4bOwY7A7uu1WoZCy0cDltyhSRWPp+3XjokvUaj8aTWg4MDbW9vmw1aWlrS+vq6+Q7NZtP8KsAOQEaeG1Dds87Q5bFYzMqvSBb63laAregTX94VCAS0vLw8wcRqt9s2+cz3G0N/4t8ATGG7GXKAncBOU65EImRvb8/KyfBXfAIFmQqHw3rttdd0584d+xzuwyeYYAJ6IJNzmMvlDLR4/vnnJUnr6+tmbwDC0KWegegTkzDdFxYW7CzDymLd+/2+yQX9N5PJpLGMKb3Dz/M+DIAHLF3KUbmGw6ExpLADgF/Hx8dmc2ZnZ415lc/nzTdCjtAbvJ5SysFgoN3dXW1tbeni4sJ60yF39XrdykNJmAEAkmDGJrI+TPO8uLhQMpnU2dmZlXnDRGq322o2m5boki4HwZRKJQOQvQ1Ef/oEhk8ae0Zwu9023wlAFz+LXokAxgDk6ATWptvt2ns9UMT3NhoN018MecEnA3hlrdPptKrVqobDofL5vBKJhCqVirHYkH2AXRJOAFy+9J9S02f9+qsypTY2NiZ+/8//+T/XT/3UT33e63/2Z392AiQ6OzvTJz/5SX3kIx+x373yyiva3Nz8su9FGpf8bWxsTJT2vfjii1e+9ud//uf1gQ98QIPBQK+//ro++tGP6od+6If0K7/yK1/Rd19f/3eva1DqTb4o34ANQpAG+AKgFIlELEjEKOB4SLKAnjK22dlZ68+BIcR5BsTxLA+UCv8yuhxwAeOBM318fGyZQk89hgJNxoOMtCTLfJBZJfuEY+KD/FBo3FeHun0Cf0mWteAHp5bn9L07MIgEEQSLGNy7d+8qkUgolUqZs0XD6kajYdkjHDroyDiKHhzzDhbGFTYK5X2+JADDi7EDxCKgAmjLZrNmSAkqceoIDDDoOLOeXu/7vAwGAxuXjtFH3gAO6KFAME/wQwkAFP+lpSVzmpEz1hzHDGeToNo777C3fD8rMoH0IEGu+GycRcAVnxHkd0y0ITDudrvKZrMaDAbWh4PvBwDAMWV9cTBZV/YHGfUZWi7kgHsCdAJcxDn1PWYAXqG9z8/Pa2VlxZwr5Jl7BLglECPQhG2CYwaQ5tltBBAESAQmBP444DigBFvpdNrKwQAD6R3igUV62sHIJOClN4MHkaTLkh4o9L4hK8/APZDplC5LD/26A7oh45Im1gK5hFnGZ/veEwBlgFXoMMrdaGKLswpYQLkVwaYHH33wC/ACWN/tdg3ggQkH8HNycmJlfuhk+tywdpQEAS4AhAKmwZwFWOGsAqR4YI9ggu+dn59XJpMx1gyBw3A4VL1eN7lDFwGADIdDa1ZMQMi6ojNgMsIg5XkoMUGnA1B5JhdsFtaI78euodeQ9XQ6bQ2i6emyuLioRCJhwSwsLtYvEokol8vZ92CHQqFxr6FsNmsBH2yDeDyufD5vPRVhJM/OziqTyRjTzA8PCQTGpTuewURAyNrxA0PHg/YE+x5k5L18jk/a8DrpcsIv6xWNRq0HzszMeDjI2dmZrYsvL2VP2RPOj2e1oAfYT0Bz/Bz0AMAmZzoSiSidThvAPxqNtLGxYbb5+PjY+gCRjGANYrGY7t27p4WFBWUyGbP5AE6A45FIxKaCoR+RcZJhyBrsOPQ+r/X+igdBPOiLfLBW3AcAPzLC2uGH8DfPtgX05MwD/PMMrB+9wQC9kAsYPdhF9BpJQGz56empVlZWJpixvuxqbm5OiUTCWEWwnpi43Ol07DM6nY4CgYD1afJsLWTBg9jILqA/LF5A+NPTU9O9noXrSxEB9bATALX4XQAv+IXIGX5qOBy2Z2GNAHWGw6GxJn2yOBC4LOFjzTzThnMgjRM8nU5HqVRK6XRavd54EiB+JzYR3cqaMM364uJiAtDP5XLWjJ51ArBFD7DuNPHnvMJIgjmIncTPw9/0Uzl5Hnx63+sJVuxwOLSktPdRkDsAas47+t4zlkia0e/PM63Qfay/7+nnSygBcvF5OSOsJZUUnvHLWWMfsUmUXD/r118VlCKhyEVSdvr6B//gH+hv/+2/bf//gz/4g/rgBz+o7//+77ffASgtLy+rXC5PvL/f76ter1tS9K9yLS8v6/bt25Kke/fuqdPp6Ad+4Af0L//lv7TfX19fv9c1KPUmXj6zjPIjkPVldN5Bw/EnkAkEAlYSRNDje0h5+izOj3QZ2OHUTGfTcVJRKr4PD0EajpYkY0fR/8GzRjqdjmX5MDg8nzfi0mU9OIYKhgEAlnTJKsHZwvHya8i64hRtbGxYaR8ZapxNPw4YA8ZUPs9OgR0Fm8Cvnc+0dLtdyzIT5BN4ECzy/AQWyAKgkM+kx+NxY04Nh0Ob3sL0PsCHwWBgewBgiWFOJBKfxxRBPvz94FADysDC8JTpaDRqfRUIrmFceMDAZ9F4Pi7kA8fRBzM4/51OR4eHh8ZwgMHBnnMRHI1Go4n18yN8cbYA4HBcgsGgTTbygQYBKgGrL4EhwGc9eEacVf6fv/nzy35LMnYBZ5o+WrBUisWisWRg/8GOI1PIs7MOOKM4cOwrOoV7IPtKUMcF44Ln5WziCCKXsKAkWWDFvRFw0t8FUJ3JcdO0foB3Phfw2rPIABrQDdNOJMG7lwvv/AKIAsQQ3PrX+tIQziQ6CnYk+8p+odM4Ax78AyT2mVymdsFoq1arxuKCzXB+fm69VVgXgl/2kDPV7/dVqVQs6+5BAvaN5AEgj19HD6AC6FUqFSvNJLBk7wnO2BefvYcRxvN1u11rxMzZRDfTa4Y+RaybL9fDTgHKAHxjnwiMfMDiS0+ly8bPfB7N29H7PomCDMAsYT8AYnlGdBZTEtFL6CYAYgD9dDpt5ZbIIAGyZ9yhc7098/qB80EAi74EQPZnjclYPAPgng/AAFNJapA4QS4Anyh34R5hzEwDzXwntq5Wq6nRaJh9gV2CbCKrABHoMcrG2VsGfMBQxaay9qwpU+kASmAjYhtPT09VrVYNfBuNRgZMA1hy/tD5PrGHvvXsKewMAKT3wQBM6RlHCSB28NVXX1U2m7XzDIubABi56PXGTcPp9caERN+egDUGNOBMAIDCNkKfIUcMCIDJ3ul0tLm5OeHzoOsACnzZJnvg7Tg/MHeQS0AffCBvY7h/zoUH9mFNA0rhPw4GA/tvzjc2FZ2Cb8aa+3sHwENP8j2wqABTeJ5ut6tarWZ2AxvBPvFaSebb8IzcL2sBs4kkky9JRi/4ZAbrgNzzzCQdAMFgg2EfYDpJMnYUvg46AB1BfMCaIkOAWzwXuh9djRyg56f9SeSG7+P3njHI+cTfHwwG5vdz/yS5+T7OK3vlE9LYTBKs3q7wd56D/UP+8Ne8T4FPeH194Yt2IV/sggTANTc3p1wudyUI9OKLL6rZbOrTn/60vvEbv1GS9Lu/+7saDof6lm/5lis///79+9rf31ehUNDKyook6ZOf/OSX9AzoJPyL6+vr+7ruKfUmXhhKjApOPeBGu922wIff4TDhtGHofVNygiqcR0mW6UR5h8NhYzudnp5a3wWcF4wV9ezc1/n5uer1ujmbTJQpFAo6PDw0w93vX05d436g31OLTw34aDSyUrZoNKp6vW6jZMlqkF3zteO+H4FnAvhAXrrsGYPz6NcrGo3aBDZJBraQcYNZgTGEyeZ7GWGYfdbVA1itVkunp6fa3d01xD8WixkbiYCNxqRLS0tKpVKW7eX3fDZO7oMHDxQIBCaypzgXOzs7KpVKKhaLOjo6sjHw0Mt9TyeC+k6no0KhYH21cHox0sgA5aE4FTDX6vW6gX2eAeeBJhw/gj/W2u+pdwIBTHjd4uKiBR7si3d4CWD42/HxsZVbcJYIIOfm5ib6SVDCQ++Pvb09O3Pdbtd6PRCc0FOs1+upXC6r0WjYMxE0t9ttK/OhPAgmCcEC2WAYh6yvD9wIoILBoOr1un0njZ99I33ej1OOswqYgjNLVpgAE9CXfidkG3EOkWkYB0wkbLVadg4PDw8NjPJlUzAyfY8K5HU0Glm/Op4bWcdJ9meFgB/GAkwO+rLgPCLrBMTsY6lUmnA+KSX22X+ce3QP688+ERxxjvz9egYaTV5Ho3GpTqfTMXZesVi0IB8QudfrqV6vq1KpqF6vm0w2m03rNwNrZzgcmh5uNpsG+gG2opvI9MK28E1ci8WiOeAwQelPh34joPBZVMqGRqORMRYWFxdVKpWsDMnrAW+nzs/P1Wq1bHw3gbsvVZNkZbjsI/YKsI71Zg/oFzg/P28gJPp0aWlJi4uL9r2RSGQCAPZsVw8co3dSqZSy2ayV0Pf7fT18+NAAKdgVo9HIem9RvhkOj8tWj46OTF4pLwHU52xwfn1ix7MtKH+RLhnT2HNAH84I9toHwQDbMGTZT9jaADivv/66nTkSVJ55C5jNDyxv9o69r1arevDggfXuotcIFyVFnBefXOv3+ybfMFzm5+d1cHBgPgbPiB1Mp9PK5XLG2sA2/Nmf/ZklhdB/kmxCIkASsuqTJugT7OHMzMzERFdAAs4KyRyYb6+//rqVL9FbDF8ERgm6b2FhwcBNn2TxDF1KTJFzH/AziRmwD1sP0NFsNq1nFLoMX9SDmuhYvheglP31QAQ+AfuJvaIk7ZVXXjEA2peZI6ecUdhJnCd8S2wPtpE+gqVSyZiH02z5R48eGVhHqSs2kB6c2CnAer6T72IKLHqe78eO8PmUz08zVgGfaWyPHyRdglZ8L+ASfT9TqZTZwrOzM9VqNfPHSUrjN8zOzqpQKEyUjbZaLbvHWq2mZrOpYDBo5YA+MZxIJJROp23QhG+rgQ67uLiYmKaIviGmIKHggX3iG57J+yPsGfcMYI8e8rYX/YYcs/98NqARCVr/Xu6p3W7rf/2v/2U2ZjAYTFQAcFGREggEVC6XrZSQ5PuzfvlEyJf789W67t+/r+/5nu/R3/t7f0+f+tSn9Md//Mf6yEc+or/zd/7OG07e+8AHPqC7d+/qh3/4h/WZz3xGf/iHf6h/+k//6ZWvxbc6OjrSxz/+cf30T/+07t69q/v373/Vnun6evOua6bUm3zRgJkgGoo8yhujc3Z2pnK5rFQqpUqlMlE2Q7aFwInyCthJOOtkp8lSEHxhMBOJhKTLUoqNjQ1zonC0aFDe7Xa1tbVlRu8P/uAPtLW1ZXX20WjUnKNisahkMmkOonfgCH5x/GEBQQUfjcb17mtra5ZNwSGEwQDdu91uK5lMKpfLKRweT+mBuvzaa69pYWFBy8vLlsm/deuW0ahDoZCq1aqq1ardE2NvCRgajYY2NjbM2cCZZnIhDgPGF6YK06XYVzJ+1P8zEYTMrs+IEzDifBPY8vmlUunz2GwAerBScOAovyIj65kRvV5Pu7u7ajabevDgwQT7hHK6WCymcrms3d3dCQcAxoTvaRQKhYwd0Gw2zUlBJglGAUDOz8+1u7trjtFgMO43Uq1WFYvFtLq6asywSCSiarVqU49YHxzBfr+vQqFg2X96eQGm+ExItVo1meRZM5mMsQw4S/V6Xaurq9aHhr43lDQNBgPt7e2p3+9bXxnuVRpngiqViqrVqjY2NszpIZArFAoGluFMEQzi7GazWQPVkJFmsynpMkAtFAp29nyPJV+CwT1Vq1Xr7/Pw4UOtrq4aSIszSGDj+xqhc+bn51Wv17W3t2cTPMnw0+eO3mzoCTKcvlcEDmSn09H6+rpOTk5ULBaNLUewT4bz5OTEgCKCCh9QM6EK6j4lw91u1wIA2H5kygFGYH0AbAYCAZNP1sL3nKD3CZlnH5TQ04a+LLVazcpkSqWSNbNdWVkxkOvo6MjWEfBhbm7OSlIHg8ux69Vq1YJa3tdoNOy8oYs9G4VSB+wMZWq1Ws36zq2trVnPKNaBZAhnExmSLnsCRiIRJRIJCzoajYZmZ2dVKpW0urqqra0thcNhG+pAY3ACTYJ+nq3dbts475WVFQ0GAz1+/NiajJfLZeuDRCKFsrrhcGileyRKNjY2jOFEwoNy4Lm5OZMT1t+zEAGXQqGQ9vb2dHJyMtFQmox8q9XSycmJ5ubmrLdPu93W3t6eTRWj3CkajVrweHBwoFarZQAbYDjsCs730tKSAdEwPz2QhTyw14DanDFKRn3j5H6/b+B9PB5Xr9dTJpOxaY/YNIB4zyCFEQzgzv10u11rOE+572AwLgXmswD0YNX55AbPhD4/OzuzfmsXFxeqVqvGTJqZmVEymTRAgX3C9hSLRZu6R2ICNthgMDCmObIMIwVAz7NNSDaw1iQBAYI7nY69DjCFRBv2gvXms2iTgMwB4pPQwQ/Y2dnR/Py87ty5o4WFBW1sbGh3d1exWMzWyYM23vb4YRQAIvTxpGzfl+GGw2GVy2Urqz84ONDW1pbS6bSVvcKa4bk5U8gn8osM0XOK0kkYYNJlj1TPRARsABihrB2gmvJ7kj8AjaPReBp0u922kkfAI+SX9ZVkYBVyBtiJT43eJ3lFXznWGJDvwYMHWl1dnZArykdJkJGURBYHg4GB436aJMAefhIJRPyB4+Nj7e3tKR6Pm14GWKcNwN7e3gSYzLPgg3nglUQCeoMyQYBsfGzODkngdDqtfD4vaZwU3dnZMUYiQKv3JS8uLqyfHOeOUlXsPL4Wjd8BqQH4SGZgd3wJM/IqyaoKWP8XXnjBzjZ+PbYZQEySxWHsOYAtietn+fpKAaavJiglSf/5P/9nfeQjH9F3fud3KhgM6oMf/KB+4Rd+4Q1fHwwG9au/+qv60Ic+pG/+5m/W9va2fuEXfkHf8z3f83mv/dEf/VFJY92/vLxsTdF9Zcf19fV7Xe/Sm3ihiDE8PqiByuupuDgBGFCyezgv/B1HwFPNybaSBcNR4CIbwe9mZmZsVC2ZfjJbvv6dLKOnVd+4cUOSrAyEnhuebg8dmHsjyCYbFQ6HrUyJzJAkc1R9Xw4YTTgvZDUAdhKJhKrVqq1XKBRSNptVOp3W4uKiZcaY0gHIQ9YSowxrAzBlmrbMOvosIADIYDDQ2tqaYrGY0um0ATw+gw3QRkYN1oZni/DDd/uyAIJHMnvsVSAQMHCOffegHmANTBPAQDK9BLjIBTKBA+wzqtLlOGKCHujf7Ad76gFKAileSwnGN3/zNysWi1lQDjWf3hg+SPK0ftgkZH99s1KCGUBWHH9klP/354HMN5lBz+pCLj1bz5cq8RreA6sG5xfAKZ/PW5DGGnL/nqWWzWat0TlOE1N7+Fz2i/1AFtEnfHevN+7htrKyYkAL4E6v17P74Zmly0lyBKb0pCKYPDs708LCgvU8QYbYe/98nmVIzxVPle92uwYsepAAIBBWmP8s5JQm4ARfnjmAruFeyOb6EjifyaenHfqJUgeCK+Sf88V9wACRxkBQKpUyttP5+bkWFxetrAJghnMI8AtLU9IE84gz65+T70KGfdkCAbQvL/SgEywMgDRKmuh7ROkUyY/pUex8Hnvky2YAYjg/yI2Xb1+ug+0DIORvsBt8mTrnnyCLe4pGo8rn80qn0zo9PbUmv+gQzidAGj28sFGwVXgtsiKNywA9W4b9JZDFDqFfA4GA3QvBlw+2MpmMrSM6xAdayCpnl/tDJ3j7TfDobbtnu3CO+BxkGbvS6/WUTqfNJtKXBttHeai3VVzoD8q9sA2cbewv+gCmjg8sfRk1zwswn0wmJ5hU3u/x60dwDhMc/+Ts7MyGCgBQYg/Qk+yNt718NvvCunEf02sJ0xIbzv0TRKMzPNPa62MSI4B+zWbTwHhKtNHbvrcbawtDhNJ/7+/hq5C04iwhZzyfP5Nra2s2eAA7B2jkP9vbKj7rxo0bZj94P2CTZ5lyZvGFAFKxG3wf303ylOeGATQajZTJZMyP430kYfv9vpXoeb/OyzvrCfMUG9HpdEzXAbqxp9gD36cQW8TaMdQAmeCczs/PW3k3n0NSijiBxAvJToBGfD50JXsAyAdIgy7gvd5mcg59aaAv1cPmen1NqaHX+QCwrBl7xDkYDoe2Fpw5z9pHD6FX/J4hY14u2TeAVNafhJJP8sLc88AzQCafxX6wn/79Xqc+q9fXCpT6/d///S/491QqpY997GNf1mfevXtXf/iHfzjxu+n7/GqDadfXV/+6Lt97Ey8Ubjgctuw+CtzTYnktCpJs89HRkTnOvlSFfzGKgDwYNFgQHEhv6HFcCfZ8MIjD6EEPMvSzs7N65ZVXdHFxYXRlAnwcPJ/lwpHy91MsFi1rFwgELIOCU+VpvWQguSg3xBn0YBe/9wwtX4pDIA3TAJYHayDJ2B04LtJlHwT6sWB0uWAbAIpAAwZEIkDGKOOw9/t969FVLBb1+PFj7e3tmUOEE0zWkaAb9gdrVyqVLIgDhMHZKhQK2t3dtfHd1WrVMkeDwUAPHz6c6KHBD+sO0w5HGQfbB6KSbP98/wHuhyDXs/Y8XRvmA0wE9pH7kDQBShHo810w9WAIHh0daXd3V0dHRzo8PNQrr7yiYrFoLCpkhmDfl4riLPX7fT169Ei7u7smk8iVl3GAKdYKeSKo4Wx6liSN33F+yG4ix+gEziU//D9nB0calojvkQIASFawUqlYBhI6vXQJWgFieXDTAzPoLMCXUCikg4MDAw1hLMCCYQ2YMkTJnDSZsWZ/CfYAKPhMAiHWGDYD6+/ZWL4pO/tCIFIqlVStVicCSf7ms6ewCn3QRvN1nFmvJ/kZDMajyGEGcdZeeuklY6zw2ZTNVSoVPXr0yMphOVvIRTAYVK1W08OHDw2UpPcTmXimUBK0w6xENgOB8RS9o6MjK72o1WoTIDHlnJR/oicpcebeAYYajYbpd0kWVHp5BXSuVqsGWnr74BMDns0BKNbr9SyDjk7CdnlgCjlgYAeTRzmPrVbLGBvYDr5T0gSQSdkZpdjRaHSC4QzYXCwWbdoT74U1QLkcDEzAKkrkFhYWrLcL+4U8eX3C2eWMkKzxTD5+2Afsz7QO8DqG4BF2otcvgDkEvgCg+A7IPHvNmnm5A8Tk/wuFgvb39+17GWrhSxgJFD2Y4xlIfD89eSi7rtfrVqbJfVLy7EtcsTe+TIjP8xNcOfO+P2SpVFIgMB74QmLOgz6clcPDQ11cXGh3d9dY43wG9+D1im85MN1nDlYR4ClgH2cO4JJkgW/kjN9AgsSfk52dHfOhsN3oNHwa7ALJGT7HJ1R9cpF1JGkHwO71mWdEIXvoAPxG7CVAtC+x9vIBWPfkyRMDkADhYQdiF6ZL0imjLJfLOjw8VKlUUrPZnOjjyPpg7ylTxP+q1+uSLvs4cb48a57v51y89tprEwmfSCRiZwvfF9+QZ+E843eSWKNsnrMG8ER8gH71MQH/D5uWs+JLv9kXbJ7/fmwqeon7BcRHzvCF2UvWAvDJn0X2BAY45x0/AHvqzxprwBlFJ/n17vf7Ojw8tGQH9z3tbwFqUQ3iz8T/Cxf7+JX8XF/X19fi+n/ndP5fuHBMFhcXzTmmtxJKn8w0PVwo3cPYFwoFbW1tWb8M+u4QaEuX4MloNLLGr/SRwZmRNAEYkOEk2D04ODCHltJAAorHjx9raWlJ73vf+5TL5azPEJTl1dVVRSIRK2Eg+MYZHY3GPWU2NjZULBbNgFHONxiMS8xGo5GV5GGkCDzIShNgN5tNK41j+tLy8rJlSQhkCbKq1ao5I5QoEXATuPlsWq1Wm2Di0EvF1/WTUZI0ESDRB4KJcFxQw+klQ7neaDQyhgU9cVZXV+1e+v3x9KxEIqH5+XnLTFIagJHFUcABpq8E0+igk9Mzg6CLvcR5xyHEmJPVAsAEpMCgN5tNJRIJy5aHQuOmtL4/A6DGcDge1b65ual4PG4ZTx+kcG5wtAiqAUuguxPMsbaRSMQcMCjsgKf00wEoA6CjRGtlZcXA4I2NDeu5g0xQVodDTCkL2VH62ACm0AfM91/yTdxZI+6TgBAHnjItZE6S9eUANEin05bF9ExD+mWsra2Zg8dodoCNTqejF154QbFYzEr3KFnl/NdqNT169Eibm5sG0NXrdd28edMCIgJGZH9mZsbOIzoExs2TJ0/0jne8Q/1+3yaW9Xo9VSoVra6uTmQsYT7SS4s+STAhCDYop8QBpWnz2dmZjo6OrFzSs0k5G+wVDDtKAkkcAETjtFLGR0BOHw5ACPbhM5/5jI1WZw0ODg7U6XSsL9nGxsbEFKjT01OVy2Xt7e2ZDolExpNbKVEIhUJWXsO5p0SO4AeQOBwOa29vT9/wDd9gTiW97+LxuAqFgvb29iYAYIKYi4sLc/aRf9gAnGMYQJ1OR1tbWxMsNABfWGIEYZlMxgKKv/zLv9S73vUua8rLGSM7DzhFCS8gtC+HqlQq2t7etr29c+eOBoOBnjx5osPDQ6XTaZMPgCmCIFit7XZbkUhEtVpNKysr9roXXnhBqVTK5K5arZpO9A16q9Wqer2estmsksmkTVx99OiRlWvTj4lG1pQRwqKuVCoaDoeW4CCgo/TKJ0eWl5d1dHRkgTtBKbLKeff93PARaDy7trZmuhV95INMbALJGfwKAAJKYtbW1uz7CegBcDY3N41xI8kAtnq9buV+sVhMrVZLxWJRy8vL2t/f1/b2ttLptBqNhk2ajcViFgx3Oh3t7OwYc/PmzZu2brVaTbdu3TLWlAeiAAlbrZb5AQTR6+vr9kwAyZQu00MRO4jvhB1YXl5WOBw2ZiN6PxaLaXFxUfV63fwHfAFaGWBDmI5XqVTU6XS0v7+ver2u7e1tzc3NWfkYJVj5fF7tdlurq6taWFgwefJgG37i+fm59WUhKUFJJLonGAwaaIO+oZQUZhw+HWXX6HlAEHqDeSYZ/m6/P+6Zh7zB/D04ONCtW7dsXer1uuLxuCqVik0LJXmCvVtZWbEeQjzD/v6+gSwM0aBkDhCiUCjY8B7PtEI+d3Z2NBhc9qiDYVer1Ux20au0OkA/np6eKpvN2uTf0WikSqWimzdvamZmRsVi0Xp+tdtt1Wo1A3H5TEnWD2x2dnKy9vHxsd75zncaGIXNSiQSGgwG2trasvYT+EGwPDudjvkmnGPOPgxV9Jhnj7Jv6BTAolgspjt37phuIJFHuR3Jk0QiYQkzQDDs7ezsrMrlsk5PT7W6umr+NGXpJDaQxWAwaGzhXm88YGF7e1ulUsnKfUOhkG7fvq1yuWwJAmIQaQyuYrNgDOMnwBbf39//suK7t+L1tWJKXV/X11d6XYNSb+JFlkKSOQOeEYUjQWCNY0NfhtPTU6VSKcuAUj6Ak+SzvmRb+FsoFDLD4kuSMAw4+IBTBJ4+08ZraLqJM0vmQpIxaSiLoLcUAedgMLApTwQnsA/IavD8ZFbIYOFc86x8bzKZtGeJRqPa2trS1taWpMsMEWAfWcXBYNz4kHXwZTIYZt8bA8API0aQBlvFU6O5p9PTU2NjsF848qw5GTqycL1ezwA3AnAy7jhNnU5nol/U/Py87REB29LSkskGzB1YUr7XWDgctpLF0Whc34+T42ULQIYgEKeD4J8sLM9PQ08MPn0e6OkUiUSsBxC9k3xfCgIx2DLsAX20yKr6Me+8Z35+3th8OMmcu5mZ8XRDwBvWnv4KnFECERo142D7iZBkqTHQZD9pbE1vLsA/QBXuFacwEhmPRYehMhiM+wjBDqGvG3tE+SXOIvfEvgEYUe4zGo2ssalna1DKEYlE9Pzzz1tTUdYDCj09L5BnAhD0BQyj4XBowB+fwzmepsYPh0Otra3ZeWDPJU0MTCCzyjr5khAPVvoSWIAP1g7AyGfs+R3fyzn3gTt9JVhrvhtGDzpLkgVS3HO321UulzNZOjk5MfCYHkYArl73IfM02OcZkbVOp6PZ2Vnl83kLAJA7z+ryJbE4/vl83mwK90liIx6Pq1qtmqOP/PF6wCXWyeszZArgEdYcZYmhUEjr6+sTDf8XFhaM9XVxcaE7d+5YUIc+9v2bTk5OrMEwZ8onXwDyWW/kJxgM2rABgldAF+6dPkiwKlh3dAm2gd6DsGz7/b7pEtYMdiv2l3MDaDo7O2u9s/gsWDGj0ch0IX0C6blI6Q66jR43BFvBYNBAcZ6dJAOMDO4TFg12jPWjFMcH1z4AlzRxrrFZrI2fcgfrAltKUM1387kMhkAf9/t9mybrk3MA8ejQXq9nDeYB8QE50THob2Q6GAyaTKKf2XvPgOQZAck8IA1oC1BNSRr6CTY0fS6xVz4phi2CgU7Cw5dLM0wAll6j0TBQdTQa6fbt2yZfNAqnNxAyxX3jpyAb9JdEhwI4whRZXFy0aaCAA4Bvs7Oz5geQaIOB+OTJEzsHkmwfWDtYXDMzM0qn0wb++8QNSUvsRTQaVSaTMQAQ+0OyFFmgPxvDBNDFx8fHWl5eNn8R1mEikVAoFDLAjcQVbHeSVMhgLBZTrVYznU1/JM+0PT09NQAQsB9Ajh6M/D9gMclE77+jx+md59lsyCi6l33A3nPvgIeVSkXHx8cG5lE6jj+xvLwsaQzSbGxsSJKVcePvcF68ry5pYtoz8kJSivfgs2Bv+QwSxbQlAJCFgcgUW2Ic5Jjy1OkKkXA4bPLDd5AQRf95H8IDZPhy6Flv366v6+v6+vq6rsv33sRrOByq2Wyas4jjRqYCR4egyPcIgrJN2QhgEa9BSUsyI+97L0x/B44izB4/RQVH1lPdcV7IGMEQkmSfJcmMCkERlHBehwNDgIFjxHPCRPIgh6/Z5355Fhzk6bJHggxv0BnJzkQjspI8G+sJMygQCBhjC1AN0IU98tRtnCkcF5w9grlGo6G9vT2Vy2UdHR3p6OhIBwcHFtB7cM9n4envQP8A1pI1Zr0w0gSp3qEZDodW5gADwtOyfU8MSZaZnl5v5IPnRc74Hd8FGEQZCiwmAEp/35SwsE84DDs7O1bm6tleOOaSjMqOI8z9HR0d2T1LMscameT7YLogQ+wfcokzhSzibPlz65/dyy9rgzPpgSwvr9yTXyOvH2CO8D0ABHy+lz9ACe7PlwTSy8a/3gNYyD3vRY8A+gDASrLg268Zz+OBKs4M3+lBKQ8AednyYN9V+g1WE+vNcyIXAIj8joayvJZ1BBzme9gX/u730q8Jz+vlwN9/r9dTtVo1pgg6G5kg0PVrwg+lJ6VSSQcHB7ae/N2Dfzz3tByyvtP6EgBomoHH+nomFI3HAdgIKGACIYesIfrSBwq1Ws0AHeTPlyxxxnzZKBd2hPsClOI9gF6UhaK/q9WqBUdenpCpdrutUqmkWq1mgTvryRkEpEMeCIS5F/pV0TsKIAPWJXqPdWB6IDJCqYo/C7wXsJg9IhEzLUPoSuSUfz3jz5eWIm++LMfvH3IEEOH7SvnP8fplOBxPg2SPp2WQq9cbTw4tl8tWZuqn0SHjvKdQKBjgiq3lDPC9nJNGo2HPzxoBOnNGAGTQ9YD6+D/eLk3rRf/ZfJ63tdP+Chfyjqxz75QUwmYGpGId0ZecV34ABfzEVG9LCdSxT5x9ryewf9zrtBx4AIHfn56eqtVqqdlsmu/Ga/FH/XdQuu11m18bZMTrftad0jtYpt6vQRa9/8H9np2d6aWXXrJyZHwKgBXOFL6kP+8A0awjnwcoRVsEEhxeNrx/CQPP9w/0dp3ECvcHuM/6eL1NEuoq+eI+0Y/eXvvPYY2REXQPn0UMwPsAcpAhLsBKktnsu7ePrCXf5W2bT7jD5AXUl2R2F9+H5B36GVAM2eG7AJu8beb78ZX857LvfA4JqWmfgPdxz8/6hVx8JT/X1/X1tbje0kypn/u5n9N/+2//TQ8ePNDc3Jy+9Vu/Vf/6X/9r3bt3z15zfn6uf/SP/pF+5Vd+Rd1uV9/93d+tX/qlX7IJE5K0t7enH/uxH9Pv/d7vaXFxUT/8wz+sn/u5n/uya49xUmjkiyNer9eNVeQNTqfT0cbGhmV+qtXqxPQUDGgwGLSxprAgyCSNRmOWBBfU71AopEwmY8YklUpZFgknh/vr9/uqVquq1WpWIkcG/uDgQM1mU/V6XbOzs0qn0zo8PFSxWLTJdWRqKHkiK4LxwDmjBOv4+Fi5XM6CEDJPvpeB7/8xHA5tUsbe3p7e//732/hrnFHo5FB/A4GAlV3t7u7qM5/5jPL5vLGPut2uyuWyFhYWjILc7/e1vr5uhgyjvrCwMNHThgxpsVjUyy+/rLe//e3GeKJEA6eEcilJSiQSdl8wPsgQ42ARCD1+/FitVkvb29uKx+MTtfR+lHC73dbu7q663a42NjaswbPPULIOZFJxamHzEaTwHbCB6F9DZpVeAclk0pyAfD4/Qb3HITw/P9fTp091+/ZtNRoNxeNxdbtdm+wmjZ3VQqFgpQOws2AEcL+BQMDKrKSxY7GxsWGsglQqZcEmmdSzs/F0S0riJFmDXMpFHjx4oNu3b5vzU61Wtba2pkqlYgwO7gH5JoAl45pMJg2Q9HIbCoVULpe1tLSkXq9nzfA9e8MHtSsrKzo6OprIwv7FX/yFMQQlGVOBsy/Jyj/e/e53Kx6PK5/P23rTg8hP5PROIEAwJb39fl/pdHoCdEwmk2o2m/qDP/gD3bt3T4FAQLVazZxR32MOZgNngXKDwWCgcrlsZzudTms0GqlQKBhThRIE36gWZ5nggoldyWTS9CyMmJmZGTWbTdMHHoDFKYUNGIlErPSG3luS7B5xiFlzynOlSzAll8tpNBrZNML19XUFAgEDe9Bdo9HIzi/gdbPZVKlUslKyUqlkJdv0xEBm5+bmrCwR/eYdcF/6zDRLMuqhUEi7u7uWgY7FYgb6wkYCPIRRh+6gVAYwJplMWma/1+tpZ2fH9CNsSbL0ZLsJNB8/fqzNzU0LvlOplGX1W62W5ubmlE6nValULFih3IWyGd7barW0v79vQysSiYRNsIMd8PjxY0myUqvV1VUrw0F/AYxns1k7T5QdoTMzmYzJ6tHRkfb39zU/P6+VlRVjyr766qvGAqG0Mp/Pm12Zn59XtVq1wDkYDGphYUGJREL1el35fF7D4VCVSsWmv+FL0Jfl4uLC2ESBQGCi1IdSWc66D7zPzs6MkQO7hgbsvszYn18PUMF04B4ZIR+NjicxkhwCSCHIh8V8dnamQqFgZyMajZrPg85hsiuTLWu1mvXAwkb4kuZYLGZT37BbgJusFbZqaWnJfjccjieIptNpm5JKiSNAST6fN91GOSp6kCB/OBxamS4l64HAmLH48OFD0x2FQkGZTEbxeFydTkdPnz61Mvp4PK7l5WXNzc2ZjxaNRo092ev1tLKyokePHunWrVsmC6enpwZ4obfn5+etN9rZ2ZkSiYSVRZ6dnVlJL2tPsi6dTptOOT8/N/nBh/31X/91fdd3fZe1SJiZmdHW1pbZrEqlYoAFIDL7CcOIKa3ozMXFRR0dHRmjxes0X85I3zPKKRcWFrSysmKvl8YlqZTHUvZMb65isWj7kEqlrH8eMler1XR2dqZcLqf9/X2tr6/bvpJQGAwGdvYBOAGF6vW6FhcXjUVJwge9trOzYyV0vpLA91lC55ycnNj7eNaDgwPzVQGeYBktLCyoWCzq7OxM2WzWmL7YJnxDdNzc3JyGw6G1b6CED18WkIez4NnG9XrdygLT6bTFJLRvYC8ePHhg7DL8cvxM/F8PAMEk5fv39va0urqqZDJpZdKUb56enpqdxz+k/HBra0u5XM6S4SRpR6OR3R9+cq1W09OnT81XDQQCE3HTs3xdA0zX11vpekuDUh//+Mf14Q9/WC+88IL6/b7+yT/5J/qu7/ouvfLKKwb0/MN/+A/167/+6/ov/+W/KB6P6yMf+Yi+//u/X3/8x38saexs/I2/8Te0vLys//N//o8KhYL+7t/9u4pEIvrZn/3ZL+t+gsGgVldXJ+qZG42Glct0u12jR7daLQumyTxAAacxtzQOSgjuKIcg4+R7OJAtwbnyE1w8KwhWBn03+FzYRQQDw+FQh4eH1nsKg06ZSLvdtn4BGCef6aCmnowFmUPKScjYUpo1NzdnlGmapHp2Ao4zRgu2BBlG+hNggDHqjHjf2tqyvlxHR0fWg8s734lEwnoU8WywFyizQGYAvzKZjAFrgUBAxWLRGlbifNB0HJlkvykDJHiem5vTzZs39dprr2lra0unp6eq1Wr6wz/8Q926dcsmCxKYU/5y48YNc1ZZ+9FopFqtZo2vybCSIfJldIAdJycn5ij5CTOeFh+NRpVIJKx5ONkugAgA2adPn+rGjRuq1WoqlUoKh8PWtBRHHuYYPSfoq4OM4igvLS2ZY4vscM/f/M3fPEH7H43G/R1KpZJKpZIkKZ/PazAYmCOGk7+5ual6vW4AarlcVi6Xs3JHSh0BPsg2kuGnfGI0GpflVCoVC4JarZbW1tZ0eHiotbU1u69arWZnZ5qls7m5aeyI8/NzbW5u6smTJxPlggRnsNyYABYMBnV0dKTnn39e6+vr1kMFxxhgmDIcpsIhG5TRDAYD6+2ztLRkQcK3f/u3W58kSk89CAWQRNAvyf4GqAwYR4AMQEywzRnH8YQNA+A4HA51dHSkRCJhTI9gMKhyuazV1VXrz0GATbAI8BKNRq2HSSaTMRAQvRqLxSbKNnyfJYAvyos96FcsFpXNZvXyyy8baDgzM2OyBTCPvI9G4x4nlAvevXvXWBIERgAMnEVACA/gA/o0Gg2NRiPduHHDWAGrq6u2/jj98/Pz+uxnP2trjY1gvWEAAIpWKhUDWx8/fmzlYYVCQbFYTIeHh1ZWQYkkDCNAwkQiYeDQ48ePDayj9x2lrJTTAsxj42DLvO997zN5LZVKBgg8fPhQ29vbZl9rtZqtAQEy55ZgPpvN2j77tXj55Zetj9bt27etRLrT6Vi58NramlKplI2DPzg4MB0ASAQQD1CyvLysYDBojJlqtWo6azQal1TTJ4h+ScViUfl83pICAMoAlr58BtvCGsBOo3wau1+v1xWLxYxd1G63TXdIMjAAtlO329Xt27cVCIx74+zv71vSBIBja2vL9CDl/vgD9N46ODhQMpmcKIFDH9RqNb388suWHPBMCfrWdbtdZTIZC5axv9jl3d1dra+vW2nozMyM2XdfAgmwQ8nf3t6egsGggfixWMz0yunpqbFw0Fm+XA45RX+0Wi0VCgW779u3bysWi2l5edkCa3RrvV5XpVLR+vq6fW8wGNTTp0+N1dJut7WysqKZmRkVCgXTt61Wy+QMu0RvOvyKZDJpYC969uLiwhIo+CMADSQosXGzs7P6pm/6JmN9vvTSSxM+ID4Cfhd6CQbm48ePdXFxofe///2SZHaoWCxqZ2dH9+/f1/7+vu1PLBYz/w89Qu+fer0+0Vux1WppY2NDsVjMfOmdnR3zVylzJLGGTMN+PDw8VK1WM98S5s/+/r61IMBmeTYifi5geKPR0OHhoflh3l6gH3q9nvXexNfl/KCXSIbt7u5a8gVgZTQa6aWXXjL9QeIB2a/Vapqbm9PGxoaV/TWbTZu8S0wC47lUKimfz2t5eVnlcnkCWKScFYB2NBpPt2M4T6fT0fPPP29riQ+JfwUoSrXFzMyMsa6WlpZ0dHRk4CU2APtFbz/Wc3V11UpVKSEdDocql8saDAbmq+zv71v/tAcPHphPC1BILEUianFx0Xr4VioVK218lq+vlPV0DWRdX1+r6y0NSv3Gb/zGxP//p//0n5TL5fTpT39a3/Zt36ZWq6X/+B//oz72sY/pO77jOyRJv/zLv6z79+/rk5/8pN773vfqf//v/61XXnlFv/3bv618Pq93v/vd+pmf+Rn943/8j/VTP/VTlrH7Ui7vkEmXjcbJXvITiURsdCmG0Ze5cPkmhVcpl+nPhQ0AVZXP9fR9T+f3Rpm/E3T530+XEEmyrLm/D/6VLstupkt4+JfPvmoNvxCFFIcBw+lBOQAEsqD+7/4ZAB1wyHxpkv/Xrynf6+/JM3f4/6t+qOX3DvdVVFlkI5vNmsEPBoMWwHqa9vS9+HIG/7nT+z39w+89BX96X/z98fms5/Tn0oMDxyAajeobvuEbJspbfNmOL9v6QhRinmH6dTDXPI18WqanP8ufF+QzFAoZG/GN7oX75j4AY5CNaXq9JHNUp/eCe+PZvJx6WQVQ8e/3JQw4xDz79Dnk+6fPG6/zz+vX2n/O9Dm+Sv6RCXTCtFz79WK9uabX3N/DtG7zz8G/MFDpveO/a/qc8H18nv8+/yxX3f+0boMVSHb4qj329+BlmO/yJZ1ebvi8aDRqgCy/J8PsSxOuum9Adb6boArGx1XyHQgErC+a/yw/chygDb2IPpte6+ln9XJz1VrBCGAqp2cZ+DM2LTt+XX0JFvfgbR/yc9Va8/k8E3/D1hB4+u/0Np/+fehq3h8MBq1vGIC4B59hIhQKhSvlYHrdrtKRV+nQ6XME4PZGtmD6DNLLkM/xpZAkf0gS+TIir3c5L7yH/ZEu2cH0x/G2CP1GSRTrftW9wirkQi7Zx+kSHt7r9Zs///41Xh6Gw6ElEwAip2UhEAgYQ4qSLl8GfZX8s0a+5xJrxeu9zHpbfdVZ4jkCgYABGvzO225/hryNmpYnv5/Tewz4J8n6X87PzyuTydg9oocikYgl5rx+47vZc+QFPeDXzdtNPsPbeuSKz/HyzTnmbzDYvX6Ylq/ps8JeTa+5Xzt0KBevx355HQRo5G2a31MqBKb32d8b6xUMBi2u8DLsdYFfJ2Rk2r+YllNAwek1mbZn07ZkWs9etZbcv7+4L/98/qzBbKf322g00vr6+ud9preV02cHpvOzfvm1/nLfd31dX1+L6y0NSk1fsFkoD/r0pz+tXq+nD3zgA/aa5557Tpubm/rEJz6h9773vfrEJz6hd7zjHRPlfN/93d+tH/uxH9PLL7+s97znPV/y98NcoXcEWTlv9OjPEI/H1Wq1jPpeqVQsm8cP0598dhDjA1WVXhU48xhEmBzUccNUIjvvDXO5XFar1bKJQrB7/uzP/kyNRkPvfve7VS6XLbt8fn5uTSMBsWiiSbYH52RpaUmNRsNKxaTLptpk/2E3YBx7vfEkptFoNDH9jnUrFAqW5YXySyPMVCplWVnYPHwHpQrpdFp7e3s2Qeri4sLKdGBODYdDm7RFSSI9GBYXFxUMBq1BsHeeeE7KFKGmQ90GlCLjRJnF8fGx8vm8ksmkNUsmw0MAQxaYXl2UgZCpxOGh/wGMil6vZz2YJBlbgzJEGnaTJadECAey0WhIugRMYKC0Wi3V63UDdACjIpGIMUMkKZPJaGFhwSYvIRt8Po1Bz87OjK1FjyCy4zQlpfdaMDju28Bnw4SgDNU3kcYJrFarSiQSajQali3d2Niwsj5KGXygIF0adnomsL6c4WQyaRPSCGAIAGmeXK1WVSgUTNYAGtLptGUw2+228vm8ZVmhrK+srGgwGJh+YxoZ/yJXTHn0jimBY6VSsXIHsu8AOZRtoKPo0bS4uKhyuWzyhTxyRofDoTUBpiRwaWlJ0mW5CyzPfn88URLWAaWMOJf8N43oyfBLMobYaDQy9gvMu+3tbSWTSR0cHEw0mYdRhBMLKwvHnbInSRZYsx71et30BueJM9tsNrWxsaFgMGgTQWGURSIRKw06OjoyNh+9WshCwwYMBAK2h+jiubk569UVCoWUSCSszxP6FdkKBAJ2lkKhkF566SW9733v087Ojr7hG77BziMMoZmZGSWTSdP3viF0t9tVtVrV3NyclpaWrESH8k8CZpoId7tdO/OwJtjbVCplYDGlgZS0cU6Z/LW6umoOcDQatfWMxWLKZDIGdoRCIf3mb/6m3ve+91mZCDoEthQlWwQhTBhrtVoql8u6f//+xHTScHjccJ2+dsVi0Rhl7B3spsFgoGQyaSXYjJvHbmDrUqmUAoGAfu/3fk+bm5vGLo7H49YnEBCVUiNsPcy/RqNhk1d9b0DAP9Yav8I3IUcukJ9gMKjDw0MtLy8rkUhoNBpZA2psQbVaNRtAEHd+fm5yzv8HAuM+PAAd2EX2Gr3q+yN2u11rB8CUYKaQwQCFUY7dpSxtfn7egEn0OKU67XbbdJJ/TTQaVSwWUzwet3WQZFMd/frBjJqbm9PTp0+1ublppfVMp6XlADYAZjF+Hj4X9xOJRKw0zk+888MUYLMVCgU1m03dvHnTGGytVku1Wk3NZlPr6+sKhUJWKumZpUwApaSS84vuJ1lBOfvJyYnJvh8kQEIHfUlTdvyli4sLlUqlicbhsNv9xL/RaDQxZIQ9gS0+GAyUSCSsOgB95puW8728L5VK2QRdZBaZh3F0dHSk3d1dA8hgvLLXsIBrtZr1pKKss1qtmq1aWFhQt9u1Cb3IM3sG0Ix/DROoXC7b+lAKnMvlrJxXkvm9yApl0/iplAw3m03FYjEVCgWbpJtMJvX06VNjP52dnenBgweKRqO6ceOG+WKwQynRRqfWajUrCy+XyxYbkUyBRUmrgpOTE2N8Y5OpnBgOh1YOzpmlaiEQCFjvP++zY9OIg1hvdBpJDipLWFv8tcFgoPe85z1m03d2dmwiOHuDvsS2sNbYjW63a8MHFhcX1W63bX2vr+vr+vr6up4ZUGo4HOonfuIn9L73vU9vf/vbJUnFYtHKjfyVz+dVLBbtNR6Q4u/87aqL0jkumvoNh8OJ3kk0nSZz4Ps5eWpxs9nU5uampLGxWF5eNoU8Go1pvzRjDAaDBir53gf0oSKYIiAnkMapHI1GNka3UqlYCQBlMJlMxkqustmsTk5ODGDAWJCFBKSh+ShGwTcVjkQiVg7CfzNhCsaSdzZwPD0jilIjylNwcP7oj/5I3/u936v5+XndvXvXghXAusPDQx0dHZlDxgQf37CWQNQHuwA5rA3gSj6ftz5jrNH5+bmef/55PX36VKHQeIQ7JQe5XM6o6Z4dBahBzwcCC8o2Y7GYNjc3DSBgbx8+fKj19XXl83kLbBmPDFBGA3MmgAGytNtt1et1m+44HF72OAgEAuaQAGICHHiHiwCG7DYBH8E7QCFB0nA4NKdVGoORL7zwgqrVqjnNlE5GIhHrqUGpAPLNNDECYAL9QCBg49UvLi7UaDSsfAiHqtfrqVgsKh6P27S0TqejVCqlWCymP/uzP9O9e/d0dnZmk5AAZPb3982php7OGTs5OVE+n9fu7q6BAsjY2dmZAXnb29vq9Xo6PDy0aV6Uh0L9Z+w74CxgzsOHD7WysmIBti/X6fV6BlzSH2x1dVU7OzvmwJEZPDo6UiQSMRCPHnf0VoJuHwqFdHh4qCdPnujGjRsGmNJDA0BwNBrZRCHP2gHwPjk5sRLTXq9n68PENQJt3zcKYIzAmtITAmXf3LdcLhsTAVnb3t7WycmJ6vW6lfISvAA2Aj6il3Gs6bdH/xPKrCUZeD4cDi3IJHjxrJHf+I3f0Lve9S7NzMzo4OBAGxsb9nn0rPNTBmHL8v8XFxcTQSg9iQ4ODpRIJKzU7uzszAI3moFHo1HlcjktLy9bCeD+/r62traUTqe1v7+vBw8eWNna0dGRgZ6np6cGkGazWbMXjx8/1tbWlt17Op1Wu93Wpz71Kb3vfe+zzDNnmJIbGuZns1ml02n1ej3lcjkDZyiVobcOWe+nT59aaQyTw2AeBQLjcrEXXnjBEjWU93IuDg8P7VwDTNFjzCczuF555RVtbm5qZ2dH6+vrarfbCgaDVkZ0cnKicrlsJTL0tLm4uDAdQ1mZJJt+KY1B1Hv37unk5ETNZlPxeHxiwIMvT6cnCme+1WppcXHReuGVSiUDaObm5lSv161MlnNFiTzlsQDonIP19XUVCgUDzSmL4czih1AiS5k3pVp+fdhfyukANdFBvmfLzMzMRDuDaDSqvb09ZTIZ7ezs6G1ve5uWlpa0v79vYA2ADeA9/WUAo0qlkvb395XNZo3tHIvFzAdbWVkxnULpzmAw0JMnT4z1Pjc3Z8APa7G6umr90xqNhoFos7OzE6A57C6SS61Wy6bH3bp1S+l02sBEztLc3Jy2t7etST97AwA+Go2Uz+dtMuPJyYnp4MFgYGX4fD7n1n9erzee6ru3t6fbt28buAIoB2DMuQdQ9gNmlpaWrFcaemZnZ8eAeT+khe+ElTQcjgetSNLt27etTxU2gkTm6uqqSqWSgVH0VMQXQacCulHK7BOB9M76zd/8Tf21v/bXrNUCIDz+GWWQlUrFekXl83krgaMsjEQZ5wo/Ct0ijRNTa2tr9h58TPywUqlkwCFJUPqDMQEQfR+Px00+0Cf4oYFAQG9729vUbDatTyrnIpFI6PT0VPfv31etVtP+/r7pWPp+oo/xM/n7cDjU7du3JY2B6KdPnxr4REKVJAjlgB4oRl8ApH384x9XOp2emIaXyWQsuUhyG3BsdnbWfCJpsodqv9/X4eGhsckSiYRqtZoODw/1zne+087l8fGxtra2FI1GDcCjRykJrf39faVSKSvxJxHr+5NmMhnzwZ/165opdX291a5nBpT68Ic/rM997nP6oz/6o6/6d/3cz/2c/sW/+Bef9/urKLBk/sjMSpeBnHRZCgKIM02V9hTZadqr/9f3qPH34Om2OJ1cMCMILqZpvMPhcMLpli6nafjXQPUmI8TvuRdq6v06XUXz9RRb7s+X/ExTnG/fvj1B9ec+/L3hSLLWfl/8v19ofX2Wms8Nh8NaW1uzxui3b9+2nid+MuA028bfG6CbLwGA1UNARsPMYDCo7e1ty7z68gj/HB74AtSclgX23Jc0TNO2vez65/drRFb2Ksr3tDEcjUaW+YSV48smpu9tWkaQJZ4JMNPT4adlkh8/xZC15Z5v3Lgx8Qz+7E2X8fh/AS18OQr36V/r1wYZJEMMxd/f27SsAMjQZJ59IJj0oK6X0enypdFoZLIzveY8N//NM/FeSrf4PALO6fdNf+b0WZsuufWvn34vzzetH9h7SQaS+5/RaFxuQK8XygklmY7wZTtXnUv/nP7Z/D5N63h0Oplfv358FueIvkCUZvBZXueiiwELee7pczF91qbXw8so78lkMhZwXaUfRqOR9TL0+zYcDrWxsWHyPl0yNr0u/rywBpwBr3elS/t11Wf5/fKZe9/w/So9DpMM5q+XV/6FoRKJRKwh9FVryHnypTcEob5kdVqGvE3yOm9afvxeYROu2muSQf7zp0urRqORBaZ8L8H6tJ72/+1/x+diu/nuO3fuTJQ8s3aSLPj1fgzMPvaKvfOfSUNj5PEqOZ626exHKBTS4uKiVlZWTFfyOZzJSCRiDFSfTMQOcR8kf3zzan+up+/L7xH6fNpP8OsAg4peW+Vy2ZJh/tmWlpaUzWYn9iaVSpk9mtYtsF7Ozs4+L/n1RvZ42tZgl6b123A4NOCU1/l7veq8Tp8Df798J/fJ39/oHr0d4/t5na9i8CXQfNd0Wwqm7k2X6vn3kSzza4S+9iVs/h79ek/vJZ87/Td/NjkjfJ73w0ejkSUr+O5AIGDMU39mkOer/L7pe8Tfv0pG2A/vJ/l7CwQCunHjhp1pv074d9yv16fT1/Q58rp0cXFxYpIwcsIavFGslEqlzDeZtn9e77Mnz/o1faa+nPddX9fX1+J6JkCpj3zkI/q1X/s1/cEf/IHW19ft98vLy5aJ8GypUqlkTe6Wl5f1qU99auLzaJD8Ro3wfvInf1If/ehH7f/b7bY2NjZM0ZN5ItuzsLBgTAMUIvRxScagmp+fV7PZtGbRlHsQkKKMAYZQHJSkkTGCbcR3SrJpFmTeyJh6h4oGlj7rSkaSspJWq6VQKDQxQhZaMo1rMQKwadLptGWDYG8BJAHkYEAI6MjgzM7OGhsApgF09kwmY+UmiURCsVhMo9HIGmKSycIpJgjE0Sbjxz556j7sHQwxDTSZxCJJW1tbNgEF2jpNSKXJHmNkyGnOTtN3miVTHvj06VO97W1vM3mF7eSDWsp4yI7Crmk0GsrlcuZ4U17CfQCkDIdDKzuBFUXzSPYB5wxKOpR2nMmZmRnLwuHIkFGG7QTtnVLGra0tc8pHo5FlC4fDy9Imyk7IXMI8YuJSIBBQo9FQp9OxPiywNB49eqRMJmOOCQE9EywXFxethG9nZ0fpdNrk+4//+I/13ve+10qpkAMyj5SknJ6eqtFoWLPVRCIxwQDMZDL2erLulLTSPJ7yJHrLkD0tlUo2CSgYDOrk5ESJRMKm/LH+6BnKadvtti4uLrS5uWllSNvb2wqHw2o2mxbkplIpC2KQBSb0kDUnCw3NfX9/X88995w+/elPW4mDn8QDW4cSEBo4o6+YjBaJRLS7u6t0Oq3j42PTaTDhYEXAJoOpwERSHMhoNKpCoaBcLqe5uTnt7e2Z3AaDQWOV0NyYTGyr1VI6nbYSPwJkSohhr0jj8m/YnHyu75NWq9VMPzEBksER+/v72tzc1OLioorFoulZghqc9rm5OSvVpUykWCxqcXFR2WzWSm3Yd/QuQQfMG89WAKR7/fXX9dxzz9nwgHg8PjF5lemZ7Xbbzi6fW6/XFQyOexyhX1kL1hDbBdhPSQ/9cJBRdBPlfcgy9zMcDu1c+Cmg6Eh0AzYMPYsNpcExJTAwQ7CZTE+jtAkGXLVatbLyTCZj65fL5YypVqlU9NnPflYLCwt6z3veYyU/jUbDnjOdTpvdxRZ6RiMNrpmGCKO1VquZXEejUT169Eij0WWShfJqAB/0GDaVclnOsW/GjWwBYnAu0YPobr6bfynvHI1GNlmMSaXYA+QfH4drdnbWGBMEvKenp0qn08Y8oXF6JpOx4SMXFxemL1955RWTM/pHwebmjCGD2HrOeDabnZhOjE8E6A8IhD6EYQlb0zedh7HCfcOE8b4X/iP9Kxl4wnmhXB6m1dbWlpV1UsoMwwkmULlcViKRsHJ8yhrxJ/B9AFFLpZLK5bKVu6bTaXU6HSvVOj8/V61Wsyln2C7KKgFoYOBFIhH7LErjZ2dn9fDhQ73zne/Uf//v/10vvPCClpaWVCgUzM+MRqPa3d1Vs9nU/Py88vm8yT8N1rExsN4oQcTPDIVCxrYBXMIPwUcul8s2AbDdbiscDhuTnwEW+FAM6qA0F8ZQu91WLBbT4uKi+ZD4NsPhmCHIuTk9PbWScJqVM8kPHwxfFt1L2Tnfhw+AnkUnUN5GBQGfDxOSiY0AQ+g8fHDfFH5vb0+1Wk3veMc7zJ7AXpQ0AdB4UBBdeX5+bn4Wfj3lj0zepVk5OjwUClnFweHhofkWlBDzWZQqw/RinTgXnFP2HvYs8ogMoZ/9cB7sTjqdtu/CBkQiEbP7XOFwWKVSydiAzWZTr7766pXx3bN0XYNS19db7XpLg1Kj0Ug//uM/rl/91V/V7//+7xvrgesbv/EbFYlE9Du/8zv64Ac/KEl67bXXtLe3pxdffFGS9OKLL+pf/at/ZZO3JOm3fuu3tLS0pOeff/7K7/VTmPxFWR29OChbwJnkNdI4q4GDRMBBYLKysmIGmkyaJDOA0mVWks8l8InFYnry5Ikk2Xjt6dpwSn+gcAOcHRwcaHd3V7FYTGdnZ9Ybanl5Wd1uVy+//LLVnmOUocVShjgcDg2EosacaT44R0y3OT09Nco6fWxwSlib7e1tRSIRPXjwQIeHh/q+7/s+G1v/5MkT3b9/35xRgk96pJB1lmQlNwRK9PCi9wu9lDxziamJgFgYdgIrxqADpMGCAJTE6NPrqFQqmQEmWPB18A8fPlQymdTh4aEFpltbW8rn8waE4fQ+efLESjIInjudjmWRmRp1fHxsZSHIX6/Xs1I9JlwRmOL04zBTToFMMpGFHhkArvRtYF0o9QBowYElW8V+SJqgqj958kTdblfvf//7J7JblJASMEUiEetn8Prrr2ttbU23bt0yp5eyLt+j6PDw0MpG1tbWVCgUlE6nVavVdPfuXcvKMsWH70ee6BXGuQYoA9jDIT4/P9fe3p7u3LljGXj6+eBM+r5hf/qnf6q7d+/a9L2joyMbg82Y+kAgYP0hZmZm7L0bGxsTJXSLi4sGHjOhh+/GqeMHQAlAmnKXhYUFHR8f69VXX9Xq6qrC4bDu3r2rhw8fKpVK6eTkxMoYAA4A/jhDjUbDwGI/cQ6gpdlsmlPpSwR8kDwajayPz3A4VKlUUjwet/fDIOt0OlbGCmBGeQlyl0qlVK1Wtbq6aqAJAYtvkO77pgGckFUFJCO5gIycnZ1peXlZ/X7fygsCgYABH+FwWOl0WrFYzPoOsWd+IiGBTaVS0XPPPafz83ML1NkjgD/KJzkHlUpFq6urGgwGNnnvk5/8pO7du2dTper1uq1rvV5XrVazAL1YLBpwg57h7LH+BOaxWMxKQAFqms2msUwk2fh6SpkpUfNT/rA9BEmFQkG1Wk0bGxs6OTnRZz/7WeXzecXjcZNt7hldBCiLzmq32zZBLBwOW1+qlZUVC3ar1ara7bbZ3GAwqI2NDbPFlUpFg8FA29vbBnIT9PCcCwsLWlhY0NHRkdbX19XpdFQoFLS4uGiTFCmLpEwHgB2wn34329vbeu2116zHSSQSmVg3+iO2Wi37PRM8KafDpmB3Go2Gbt68+Xml9CQJKD0PBAIGavuG/eho2DeA6B7A5FzUajVjIVH6x2tJsqEX+Pfp06cWQDIdt1QqWVKMJEu1WrUeU5RDJRIJm/xHGTY+EeXDJH0ouSZZRQ9PfBImbuK7+Z6MgAie9bG6uqpUKqV6va47d+4YsIUtr9frNpUOIJHyc/QM/biYEvj06VNJ0qNHj3Tv3j1LuB0fH5v9DIXG/Qk5u77XKI3FDw4ObA9effVVWxuAf1owMDWQErNmsylJJruUBp+fn+tbv/VbFQgE9G3f9m1WOodMoKfRbYAovqUEwEC73dbrr7+uW7duGeASDAb153/+57pz544+97nP6fbt2xP9i5ig2u12VS6XbfpbLBazEmCAEoDfdruto6Mjez9lsdFoVGtra9ZPiz5UlEYOBgMtLy9PyDV63idasfOAkZQpS+Nk3/HxsZrNps7OzrS4uKh6va69vT1LgtDzDNvR7/ftfNCTS5Lu3r1rZwm91e/3bdozpe35fF7NZtP6ieEfIKNHR0daXV01ewvznjNMeTbl/STW8FlJPgSDQXs/vS5PT09148YNDYdDK2mmNJJJrHNzczo8PLSeejMzM1pZWVG5XLZy2lqtZr03OfvYaM/iw67QnxR9R9k2sgubC9+EBCj+19nZmenxZ/26BqWur7fa9ZY+lR/+8If1sY99TP/jf/wPxWIx6wEF2h6Px/WhD31IH/3oR63XxI//+I/rxRdf1Hvf+15J0nd913fp+eef1w/90A/p3/ybf6Nisah/9s/+mT784Q9fCTx9sctTlv2/XG9EmffKw9OKuXyp1ZeqaPx3e2fTf95Vn+ufwX+Gp1lf9Sxf6sXnTP+3/8zp1xMo+tf5Mj8PGnnasjRZXuY/c3pv+Nyrnvmq102v1xvt6VV77C9o3leVYfj7mF4PX/p51V7wjP6z/WuuWhf+DsgBMHPVa6a/b/r3XNPP4/dq+v69LPr3Tn++37/p10zL9PT9XPUc05/9xV571fN6OXgjuXmje7rqu6fX5qrPmT5H/j1X7e8XkuXp/3+jPX6j9flizzf9bNMyedX9Test/1lvdIavup9peZj+/Dd6tun3fSnP/ka65ip9e5Xs+u/z+sx/x/R11fm+6vVfbG+/2LNc9Xlf7Ppi33HVa696ntHosiRp+r1fim2clqMv9V69vvLfPW2fvZ58ozPl7/sL6b3pc/2F9vOqc8B7fLnTVd/3Rp85/fovtFZv9Po3Wsvpszz9/F+KjF613x5Ann6/37ur3jt931eVHF31jNMlUled1S9l/X1J1xut2RvtyVV+3hud2+k1nZadN9ItVz0LYJ2/x6v0py955Vm9H+r//6r7lCaHjnyxe/tCl3/dG52b6Xv4Qp/B/0/fn9/LL6bjvpCO/ULnwfvp/nf4bdM29o383en/npZ7nmP6877QmvnX+HX+QjHJG+m5L7RGJLOmv8d/1/TzX+XPPqvXl3Im3uh919f19bW43tKg1H/4D/9BkvTt3/7tE7//5V/+Zf3Ij/yIJOnnf/7nFQwG9cEPflDdblff/d3frV/6pV+y14ZCIf3ar/2afuzHfkwvvviiFhYW9MM//MP66Z/+6S/7fgKB8TQQmAnQUGkcubS0ZKUow+G4MeTa2prR60ejkbLZrGUZtra21Gq1dHp6amOGJVmZHNlg2AAwg3K5nDG/fC+rQGBcW7+2tmbNhkejywkljAunuWkikbCmsefn57p9+7aVm5G554dMHs0iKdM6OjrSYDCw3lS1Wk1ra2tGU6ZMiUxbMBi05qL0UoLin8vlVKvVdO/ePWNRQZOuVCra2dmxppp+eiGZvWw2a03Ut7a2jPEkyRpzY+QwYDCaPEAJGwBGEvRkMkM+G0vWZzQaWV8DSqTI4PnGo3/5l39ppTYrKytaXFw0yjTZo+FwqOXlZdXrdVUqlYkmm+zh7Oys3v/+91tWaGFhwb6bCSowtChhI/vGRL61tTVjzzSbTfuOdDqtVqtle0VjfzJ6MLZOTk60urqqw8ND3b9/X8PhUIVCQaPRaKKh7Gc/+1mlUillMhm9613vMvm/uLjQ4eGhZSLJRp+fnysWiymXy6ler6vT6RhTkDIKzplnEcRisQnWFueCSZI4ljSYJdtN5o0fGImUYJHdp/l6KBTSysqKNV/lbFCyQqniYDBQKpXS/fv3rRGwJCtxSyaTxq5bXFxULpebCIR5JiZQBgLj0ixKVz/zmc+o3+/rr/21v2asuJOTEytTgsnBmpLJHI1Gxoa7efOmMSmh0MPW46zwA4NlNBoZEwv9UywWrRQUOaK8mnWljxSfQWmJNGYp5PN5DYfjqUU0WUWHcE+UfdKsniDVZ19nZmaMgTEajaxUhkau6DdKyZCBeDyulZUVtVotK2eiXILSDiZ+MqGLzO3Kyory+byVD3IuS6WS2u224vG4lQTB/Lh165Y+/vGP271TvgmjJRAIWONjmubTZJbmwTQ8XllZsTI6WG0wTsvlsvr9vvL5vDEsY7GYZZ6ROaadstfHx8caDsdjy2Gmrq2tmSOcyWQmegox7QwGnaSJIRiUY0rS888/b/Ll9/Oll17SzZs3rWSj1+vZc8BKG41GNoABJinNcJmOBXtP0kQzdZjMMECz2awxqGB2Mj0P1iaTX8vlsrHjSqWSDTOBrQTrdGZmxljETALc3NzU6empvRZ2LraHfpB+cicyQQnxaDQyOaZsFOYk6zsYDMym4J/4UhrsEfqhXC5rZWXFziUlgJybQCBgQzTo3RSJRIyhRFNxpu5Rdk25c7fb1Y0bN6yZPywjbOns7Kz29vYUjUa1vLystbU1LS8vK5lMKpVK2TPV63UdHx+r3W7rpZdeMl+n3+8bm4tSUEqxaOJNeSxNqZnMSjlwPB63knxKqkOhcTPuhw8fam1tzfYddh8+DWzInZ0dY3xRGgULZTgc6nOf+5zJHGWqlGsx2XE0GllDf8AH7PFwOO4V9/LLL2t1ddV6XcKS9+X+vsyW/lWw5igLv3HjhqLRqDW7Xl9f1/7+vunZg4MD3blzx1oWIAvsC/bp7OxMf/mXf6m5uTnzG5goe3FxoW/5lm/RK6+8onv37lnzfOwHftjMzIze+c53ajQamf1aW1uzcliYujwXbB7YZpwRz4DtdDrK5XKanZ3V/fv3jc0GoEn5GP/NM3JvVAVwz5y7xcVF259yuWxljTDk2f9gMKhEImH+KSyjeDxu5YlUSvR6PZuSTTUHZ5XpuaVSycrj1tbWFIvFlM/ndX5+bsMWEomETdsbjUYTLHJfDg6LiftjiADs/UKhYGsDi1SSNdKn7BafmQEbzWbThoWgF/1Ag16vZ2Xx7L2PjWCu0UagUqmoUCjoW77lW6xCg7gGP4Ypjb5dQrFYtPPnh19cX9fX9fW1v97SoNSXgubOzs7qF3/xF/WLv/iLb/iara0t/c//+T//yveD402QR08nHCeUNpNspHFddLVaNdAG9B/jH4/HjRpLxgLQBhqvJHOscMgJuqGhVyoVc/Kg+Eqy3lAnJyfmlD3//PNaXFy0AK1cLms0GlnpBRNjoDITmOEU+MAVYACnigae5+fn9vmSzGmmnIVx0ZTDESjRFyiZTGp+ft5oxEwdJCjBeaBXBOVfGF6m2kFlZhw6TgvOOcFOPB63YAEgkH2hrBK6M70rCCooK4lEIlbmQ6AqyfrVVKtVmw5XLpfNyQP4IYimFJPgMBKJqFarWekSNPZ8Pm/9MQDIAGmY/uN7mNBngiAmEAjYxCZfxw9de2lpyYIPel4Mh0PrLbKwsGCBLc4OpQLHx8c2Unh1ddV6UVEigLzfvn3bZCsYDKparWo4HNpY4JmZGWv6SakNa3B8fGz7zj0SIBPQMuXq+PhYvV5P1WrVGsxXq1UtLi5qaWnJsnEEOT5AY0oQz0t5DTKRz+ctcPLPxrpSOnpycmLlgMViUYPBQKVSyXojSbKGwJx5P11pNLpsUF2v1xUOh/Xcc89ZwE1ZI89LKRQ9ebivWq2mi4sLm/LUbDZNl6HfWFee35cP0g8ol8vZviUSCbXbbc3MzBjw7Xs/oI/Qcb7Xi29gvLi4aGsEjZ8yWsoAkXX2iVKdQCBgJSyUJHQ6HSsBJFj2e8z3IzOU5qJnAX+kMUhNP0ICIKZyUbJHr5NOp2P9RnwDXaaukmTY2NiwUmNKkwHw6f/BeWXkOc/c7/etrxUlNoHAuHQZAIfAgJ4vyJEv+RmNxiVDGxsbVi7npy6FQuOJsQRy9CEBdL+4uNDy8rJCoZDi8biOjo6s1w3yAEh79+5dra6uGlgCwE4j5/X1dSvdQGdQQpTL5RQIBKynTCAwLv2ZmZmxc7KwsGD6lH3kzFarVes/SUKGffZlgQRI7XZb5XLZynlmZ2fVbrdVq9WUyWQMpCJRQrIB3cKFfQXcprchQD9l0YBPgNGUbQM2+x5p2JBgMGh635c9kkjBxlHOiH4isO90OkokElbKdnx8bLJKOR5yQpCMvQaYpg8O69/pdMxfAezFZwLkJJmHbiDRgF8CqMleA/LR8wuGDrqGvnF+cAdBe7Va1fn5uflk+AHIBbqRASbn5+c2xv4973mPgUeVSsXsHXaZEimfFAiHx5MGU6mU9UO6efOmPve5zxnwz4RWJrlyJimVpNSLRBf6mDJj9nx2dtZK/zkv+Gj4b5w/1pDkBL4UdhqfiJ6DJEIkGeDqS52ZRLi2tqZkMmnTsJeXlxUMBm3K6NramskgMgBIw3qXSiUDFemxCGCC7WaSYi6XM9A2l8vZevv16XQ62tjY0Orqqp1t+ueRKMnn85YECAQCEzYpGAyqWCwaKIVPPhwODWDGJ0CP0EsuFosZqIl/GA6HbVohfjy+AT4b+0x5KckykoPoOHx6/GESK9jpRqOhk5MT67vmZZxm/L7FBmXdsVjM5AVZj0Qi5rNy3pkQGovFVKlUDEijPyJ+TTKZNOCXsk36TaG3kGPWBbvE5/shSvSSDYfD9l34gNI4qYnfG41GdXh4+EUiurf+dc2Uur7ealfwi7/k+vpSL5xIsuMwCHyZma8PJ9DH2PJenCZ+eJ8v2eLzCQq4YD/5zyMYAkCBHeHprFBaMXZkfnDsUVJ+agqfPV3GwO+4z+lnmn4ejKtnKE2/n79jZGEKwOKidxTfg0FmEohfK09B9p//RmvPc/nG3exdp9PRq6++ao22cW4BFdgnvz/T9+d/+P3FxYUajYaxavzl7xOwhYbc/pn9+np59N/vf8dnwixiTfxrWAv+xvpMf6anSPM7gh2C1qvo5twzAOn0dxMIcV/eIfQZS+SCvkB8vl8Xv56cA5pBEwSQUZ5eo+lzyBr4zwdM4ep0Omo0GtZnwlP++TzAEPqGAG5y4fT7Z+J+AZWQaeTJU9r9vU/T/znbxWLRQLNgMKidnZ2J9/I67sOf/WmZYM35LF8GcJW+8zLkP8/v3/Q++HMzvQc8GwHLVTIw/Xqvv/nXfx//0ofLr/PJyYmxEDn/01OzOp2OjXNn73k/YBPf4b+fv0+XQ3i74vVkJBIx4IwzTaDJBch2lX7gc6+SUX43rSOCwaAlYLw98M/j9+oqGfDMOX/Oeb/XozjdvMZPugXohSXDs/p188y+QqFgzBIvg94+ermAoXFycjJRgsT98J7pZ2SP+f6Tk5OJfUWfcB989rQ+54e9n7ZbPAt/Zw+vOmf+/F5lDwOBcf+dJ0+eaGdnR9Vq1XwKnteffeSG8+nXHPYJr/V9r/y98az+fE+fh36/r3q9rkajoYuLiwkWUSAw7pFYKBQ+T9b8OWadvKz6s+/twrRembZNXif5c++ftVaraX9/32wD33VxcaH/+l//q7FXWBNYKYAi/j18N7J2ld/mn9fbkWk9wnNO61js9PQeXHX2/Xr4s+tts/cZ/XvQSwA6rKckY7xM2wPALBI67Mm0PuM8tFqtCd2CnuOzPXA3/bz+X+6TJKcv1bvKv/L6nWta3v2++POI7Hl9BLhNQmv6XHg95OUEUMh/v9+L6fv2SSJ/RkjQeN+Ce4N1jr33eotnaDabn6fLpgEUfB0vpz5W8PaBZwBo9WfZ+yP8iz/6rF+s6Vfyc31dX1+L6y3NlPp6uwhCQ6FxqRjKnEyZN7zB4Hj0b7/f18bGhk0FCgaDxqwaDAbm2JBxhK0DU4ZGjrVazUpIKCfxQUMul7NMQ7fbtew8zQ1x2GkeSklTpVKx4KnVaml+fl6JRGIiePLZZBqJw1hg2pRnHuzv72t1ddUCpVBo3ISX0gKAp3a7ra2tLcsM4Vw/fPhQx8fHlmHlO6rVqrLZrK0P0+VCoZCxqciaU5oFQ4DyDkqAYHDARvDT5ygTI2u3sbFhWXxpDOytra3Z6ynZACihXC+bzU6MIA4Gxw0iB4PxVMDz83M9evRIweC4US/gC89HaSFTjsgakw1G7rzMsTewGNrttrFWyKBTskDZBSVPOLqwVJA/ZJYMIAHM0dGRAoGA7fXx8bEODw/VbDZ148YNxePxCXCKMirKkygDwOl48uSJySdO6tbWllZXV20dYWrs7u6qXC4buEJJFM8I64+Ap1QqWfkEckDJne+pIMmy2aVSyYBegAimHUrjsiCyp8Vi0VhOTLWk1Ay5xXE+Pj7Wc889p1deeUX5fF7lclm1Wm0ChEVOYTgGg0FjK2xvbysQCGhjY8OYhdDss9msnfX19XVjVbCPZMgpMYlEInr++eeNVUH5K8+IgwubhX0EvKDMgcwl5ZucX8A05InzRQaXAAEdE4lEbIpgMBi0xrHTvSVg/lEuCTsK5hrMFO49n89bhpczxmQ7GIoEDOiMnZ0dY2/AdGTyH4wAyq5DoZA1w6akA/AGnUDZ6+rqqpLJpBqNhjFz0EUwH/2UJc53NptVtVo1m0Jw5xv+AuqSNZZkzevREeFw2JhZZ2dnlpGG5VWv17W4uKjDw0MrxQuHwxY0h8NhY+utrKwoFArZFLxQKGTZ7UAgoGKxaJNrYai0Wi1rXstzUjIHiAODjdIspqAuLCwoFouZXSsUCsZM4hwyrQ35rVarxupFJ2NbaFzNGUulUrZ3h4eH1mD59PTUQK1MJqPZ2VnduHFDhULBWGUA5DCOKAPLZrPGHuPsVSoVnZ2daWVlRfPz86pUKlbey3Qs7C/gObqHc8H04G63awEispRKpcxWE/jCLoMVBSMVvU/5DSwe/BLsKAxkygxhveRyOe3v79t7h8Oh3vGOd9jkLSY+YsvR/6FQyGQAfYmegI319OlTPX782EbIU8qKnYJRhs45OzszhhTJLKbSVSoVC6qxBTC1aMIsXU7ERccHg5fTBSkZXF5eNr1EM3qABFjfr7/+unK5nJLJpJLJpN72trdZQ/7Pfe5zeu6553Tnzh2TT3wl5JPJxI1GQzs7O2q1WsrlcvY9TDD1zBnYSEyWg0kEe21tbc2YKicnJ6bXHj9+rBs3btiUvv39ffPvwuGwNYuH5Y//Go1GtbW1ZXLAlEFYlgALlM+xfjDo8Rlv3Lhh5b8wnweDgfb39/Xaa6/p9u3b5sdwrgCpGOZSqVSs3Hdtbc10PUMEeM/e3p7W1ta0trZmZWC+hBZ52t7e1sHBgf0N3+/tb3+7wuExE35/f99A2Gw2a/a/0+lofn5ei4uLZreSyaSVg2IbZmdnlcvlJsrNT09PbX0Gg/GEOgYLoA+DwTHT6LnnntPi4qLK5bINsaEJOn49Ng0mIP4Mk/KQo8FgYOzLTCZjNtkDpvhz+PErKytqNBrGsOMzKA+lzFiSisWi2SbsAGxBGN74yAxaIiHgKxqYbhgKhcwHAzykiiMUGrN79/f3v5JQ7y1zXTOlrq+32nUNSr2JFwaL0iCPxJPx8v1sfCYAZS5dlghN92/AuOFA+gwj/TvIpHkqL0Eo9+PZUicnJxPjwgFboJoz5QsQANAN4+iz9PzQH4eAUJJl+yhrJNPis45MhcPxWV5eNjo8tGpfluWzUP55cSIxRLAWMKyBQEDxeFyVSsXKBFgXno3Afzgc2rNgPHHqycp4wAIH3mflh8Oh9SCi1xWAhM9E0vMBR5bSg2AwaJPwcI4BW3C6fL8DAExKBimhZH0JJAA4PAA3DSqw77BN2KdwOGzOIaAfoJnPkNJvhpIq5Jagh9cTGFG6wOd6YI3pdOwpZRT02aIkBeYBgRKZOOSY+6AfBmAOTip90ThrfK7vBwUIwr0wHYr1YR0JZJAf2DP8PRQaj1cm+GZ0MoAIoAW9MzjfHnhhgg+TEXl+wDP2xpfO+qlUOKE8A8AtI7ZZc/bLA+RcyBPrw2ROZMNP0vFsNGSRc8IzMW6d85ZMJq3fBvqTfUFW0aMEbkwEQ7bRw5Rn8C97CFsBmQRQ9HtPIMt7CexZU/Q1/WMAkDgDZNf5DEpTCX4Iwvv9vpUnc77Zd4AfdAX3xNoBJAFAdDodA53QITj6yCGBIGvB98H8Yg0YZd/tdg20JZijlBu9gOz55wyFQqbjOZf+7Eqa6PfGa1hH9BWBz2AwmJhUFw6HLSDypUQ8P6Vk2GLOP7aUgF+SlRNLUi6XM9CItfAy4ZkO7Al6nYQI8hEMBq2MDaAtnU5/HiMBW4LvwPoAtKBDPTMFe4FNRv+hq5A9dB3f6UFmzjrnwdsj7h9WJt9Dmefc3JyVdlEyKEnr6+sajUba29uz0ivWAGAI3UvfMe47k8lYiSrlPPhA7CuyQckR++tZ1ADRnNXZ2VmVSiWz99zDxcWFAe/oLXoWIt+JRMLONPoQXXxVeRv3BxADuE8LAUnWBxEZxwehpxB6KRaL2RRkAFHOHLqB8lT8UZ+EGQ6HE/0ZKdlk//l/7A6JPdbS+5PYSWzGtK+Jn+mTCOgzyrdZH4BT71Mhr5TxBoNBKwn3vhggJs8NAIGtphydSXfxeNz8QUnWiiAYDOr27dvG7EI2gsGg7b8kO3/08fPgynT5KPYAHUOZK2Xj2FGegefiX38+hsOhlpaWLDlA4hpmEHuA3Pl+UZxb5NTbdtabe+c96AZ0nQf7eK/3HQHVOUMAjfTFZJol38P6DodDA1oBfPkeSitZO6b1jUbjqa3YDu87oT+xO5w93/+U/XqWr2tQ6vp6q13XoNSbeME2wWDCHMJoEyTARiAoBFzxdfyMCQ8EAgZEhEIh+28MBME/jiyBLoaE74lEIgZIlMtla3JK5pwgFmfq9PRUpVJJjx8/tj4ei4uL5mhHo1Frfp1IJCxbQ38VjD2OERe9CYbDodXc0y9JGgdBoVDIGn8T2JLFrNVqOjk50ePHj7W8vKxUKmXjwHlOWBE4oDwbIAFOHfdIIMuo+5mZGWMsSZdlKjCjyuWyZf94bpwenA8o/AQ6sCkItsPhyx4XZKFZCwAraOmSjNlFY9NEImEAF3sIeIMhPjg40Pz8vILBoLHwKG9g7wmiWD8cX54FB9YH+zgcjUbDRk7T04S+EzwHTkatVlO73bZMKuwQMu6ss2eE0FsJ5gHBtJdv1hlH1I94pm8QTC72GnCT3hb0GfABnO87dFU5C3JGfzjWCAYHPW9wvHzZCPuP0wYzr1ar2ff2ej3Nzc0ZKEzDT/ZauuwpRcPvcHjcp+Xg4ECbm5uW7Sbbyb0BprK/BJM42nwXgQ9nE0cdvcSaoXMoZwqHwxaQcQ/0JoOh2e/3DbjimblwpGDOANDgKM/MzNh9SLL3EiBT0ukBnEDgsvExwQuyREBBUOj7gxCgs+Y+gEfGCTKRbYIfzjuMr3K5bM3BG42GOcnoSc4/uj0ajapYLE7ocvaCM0oiAnnCNvhy1mKxaE3U0YUAP76UA2CP1/i9lqS/+Iu/sJ6DAHKLi4tmW1qtlvr9vsmjB8wk2Xkl6PAJGgIjAld0AzbJ66CZmRnt7u7qne985wTTIhqN2jCRQOCyqfDFxYWazab1ERkOh6pUKmq1Wnr7299uepP1R+52d3fV6/WsZx32j4AX+eDZ+D7AEwDTvb09k3dfWlMul61ZN+xMQCZ/Hnw5IkABcoVdwhYhz3wmew3wQQ8eehlh29BF+Av0mkPOfEkOeoh+U9h1zh17x3v9s2AvsYuc606nY+w0fB5fdkWzZljOBN6A1AAfPjgFmGLNo9Go9cNEj2B3kVO/1uwDew1zqt1uK5vNajgcqlqtam1tzd6PrKJD2GvsPH3ASL4cHByo2+3asAr0AeAMvhmJBthi0ehl8/3T01M1Gg1jw1LGCkiBXgTsQ9egDzmPnDdfqsh+eiYnIPG0rue7Pbu/3W4bMwqdKMl0MLrOl+d6n5X7AAxjDw4PD22YEM/Dmcd/humJrsHu4o8C9nFPjUbD7DqvY6+wAZwR+jxy1vGxYOFxFgHy0R28FxC7XC4bcx4WD7Li/QYY++h6b48Aafhc/HwSHOgWgB1+5+WcuAOQE7njLHu74AEwzqsvT6QqgM+enZ21Hpenp6fWB9HHE/RK9MkE7AODnrDpML+Rs36/r0KhYPuG74VvSy8u1oi4iTW8vq6v6+vr57oGpd7ki2CmVCqZYiWjiVIm60awi1Pgm7tSMsDUF+myTwMZDrLFZDNHo5E1FkRx+4wT7BCyRGQtyA7DRri4uNDTp0/10ksvWZNCvmM4HOozn/mM7t69q5s3bxoNnuwTGTWaex8eHto0GpoiEjjChCF4xHlk2gclKFB/y+WywuHxRKVarWY9l2gAy/pj8LvdrpX8BAIBJRIJA1DIJsJOoJksTo0kc55xdnEuI5GIDg8Ptb6+bs+yv79v9OxgMKhms6k7d+5Yo3ICafa8VCrpE5/4hN797nfr7OxMv/mbv6m/+Tf/phKJhK0Xk2/I1tPYFLZRKBSy6WzPPfecRqOR9vf3Va/X9fDhQ+VyOcvE7ezsmMFGxrgf+qJIMseWz2+32zYFDfChUqlofX3d9rvZbOrw8FCNRkPb29sGhJFZpAFwIpHQ+vq62u22KpWKVlZWTI6RLRqDcm5yuZwxvggIaTr7+uuvGxDcbrc1Go1UKpVUrVYnQJXBYGAlp5Tj0GSTQIGzwNQkMmk4LwRHngkViUR0dHT0eftLCV6xWFQ+nzeHilIuMqgepCKzCtC1v79voA/ZZKYskcn206qk8dTAbrer3/md39H3fu/3SpKVWJEpbDablok+OTmx8rr19XUDQmdnZ20NYE7BOAIcBjhgOhABQy6Xs7IA1gVdQNCAPuR9TLojsMa55P9xVvv9cUPrdrttMsL+BgLjxsToUlhlAI2SzKHHuaYEwTfbJshmbWE+sDb7+/sGmAOytVotlctlxeNxK8cAOKD5MhPFkEv0vWfNwAz1bKc7d+6o2Wxaz5zRaGRN6zOZjIF+yIU0bv7sGVlra2tWXuZfT/DT7/fVarW0v7+vWCxmjYR9mRLlNdvb25bdzuVyVoIO65beLmdnZzYhEXYrutqD+AT5BCaA7+wdzZIJ5jY2NpTJZLS8vGznbDQaN2NutVo2mQ2wGnk8ODjQysqKEomENdkFTKOcg2lcrAfsYw8yNhoNlctla+7barUsw8/zdLvjpsovv/yyDSrBBvH3YPBy+hbliLCN2DsAun6/b2UpBPP0Ucrn8wqHx419PeMvHA7r6OhIa2trBl75JtL1el3z8/MW6AIwwAAjUQDoNhqNTI8AosCEjcVi2t7eNhDi+PhY2WxWy8vL1jIA9imJBcoXNzY2Jl6DboKJxTM9ffrUmEWzs7MqFApKJpN2bj0oxndgG2lgnUgktLy8bJMvmUpZKBRUKBSUy+VMbwGIAZr0euNBHdlsVtls1kBlpiEWi0XdunXLyoU823BmZsYGcwCY0UCaKYRLS0tW8gerGF/x4OBAt27d0mAwsPJgziZJFMr2uLDF6A1kEzCUdYLhCMiMLGCL+czBYKA//dM/1fLysjqdjuksz/AlUQGwt7u7q1QqpaOjIz1+/Fg3b97U+vq66WnASmy3Z8KRTEQXNBoNHR4e6sUXXzQQU5IymYytLfa5Uqno4ODAQDJYPIB6S0tLxvLHx+Zs7u7u2hAd1os1Aayh9DyXy1nSrFar2VpUq1X73nK5bPqW58TPvHXrlpLJpJWicT7Pzs5Ur9ctmROPx7W5uWlMWABS9pmKBg+u9vvjIReJRELn5+fa3d21QRWwzwGOAHGwFwwrwQfG96rVamo2m9bUH11Rq9UkyUo4/blgsmwwGDQAcGZmRo1Gw5Ld0WjUbCx+Njbs/v37Vs3A5Eh8AcCvWq2m8/NzKzHnnvEvsPGwhgHcYcQ+y9c1U+r6eqtd16DUm3j54JrgB4MPoERmgdIuso7QnMkqYzS4eA+GBMdTkoFfnjVy1X3haPrv8BkOT4kma8h9odwAGfhMADJADD6fAIr3eBaKXwOe2VOYPeuHi2yf/38AN4AEjKe/F4Au/2w4KAAOBKmsuWdG8B2sgSQDIMjShcPhiaAhGAxOZK58VoY18cEwNHBfjsTnQ73HEJNx989PMAGrDKPL97HXrAvBuS+b4jV83jRDxMsRARbfD2iDPOAIeNq+z8hxjz7Dxg+yRxkBIC8yxB6xRoAdfCfOLdl+AguCVw/o+mmRrKcvu8Qh9+eaZ+K7KEOYXivYUzhIgJnINXLP9yJXyCvrwln3WX/uz78XXTA7O56wBzjK6/z58dlXf8b4DjKJ7IU/J8iIP1/cM2uFPkNX8NkATV53+DIj1mZ6fTzbwa8/7Ce+i1IFLyPIqb9fADCvk/054P6Ra3+GfDLB65Rp/ehZi9yXXx++E5YA++1ly8scn8d+ePvi9cr0PU33//L37c+VlwH22NsSv4boPO7B3zMsF57Jyzs6wJe1+vX3dgAwwssS6+BtH8GHZw0CYnGfMFU5Xz7zz/N5QNnfC7qKz0M/IGeeXcN++7Jnv56cL9aLMwU47vfP+xB+P/059ExO7tczDyjv9LbU22ovx6wHn8N9sL4AZFy+vI0z7AMg2BjIsAchKH1lT5Ez30eINfYJAC/jsP78HntdybMChqFv/HnyvhQADbLh7bU/t5wX709JsjPvv1e67NHGWfeJIYJknp0SLfQa303fJt7r98mffb6P97P+rCd75v0o7wvx/1y+zApWNrKMzPnPYX2Rf4AZ3o/sAjh6ncDZoM0Av0MeIpGIlRx6feRZfl6ve8YXss76+XPgE73oR9YWefS6mDPe7/dtH/HV8PkA8jknrLuvjECf+HPn9TylrP5so3t4Tq87vV1FntG7Xjez5uzTtK3xvgJJGb9u/N3rKdaXH+8PeFvn9Qq6xJ8j71Nh+5EPr3s985L3s7bTzzN9z/g9nvH8LF/XoNT19Va7rkGpN/HCuex2u8pms1bSgEMRDAYtkw6bKJPJGNuIsdewgfg8FC/KFCYDBgyHZnFx0ZgY3hjzOWRTO52OZfkx/mTwA4GA9dLIZrOfV+Jyfn6u7e1tc7zOz89togl9IC4uLlSv180oMP6cpsS+Tp7sIdkiWGSMt8bIUSZGcEEAEY/HVSqVFIlcNrNmzDpNiH1QhPNP9hmQAlDJj6HGGGKUMdrb29vGYsD43759e8LBmw40fakcztLq6qpKpZJqtZo2Nv5/9v48RvL8ru/Hn1XVd1d13VVd1dd0z+zs5bXXF8axAQdWYDuIGBxFWA6HsUwEMiJyIIQglBAsJ1+BggAjnESCHIpDlABSQMGW8YEJso29a6932dmd6Tn6rvvq6u7qruv3R+fxmlfVzq5tbLzs/uYjjWamu47P5/1+vV/H8/V8vV4rKhaLOjk5USaTsRHrTz31lGXNCUwoGzo9vd2UvFaraW9vT/fee68xwGDFBIPnfSgODg4sG0m27uTkxJxsGujSKHgwGIzQ7Vm3bDZrgBmgEQ5Ou902+YMhBeAWDoetFwBrSuNx1prM7mAwUKlUUj6fN2f14OBAr3zlK81Rymazevrpp63JMYHT2tqa0eAnJydVLBZ19epVZbNZYxglk0kVCgUtLCyoUqlYBpf75VlgDCHvsK8INGA3AAiz51NTU7p8+bKVSVAyCkhG0C3dDuBgBgaD5z3iyPqlUint7OwY5R0HlzI7mvuGQiFdvHjRhhogJzSABiymMb4fPR0IBKz3wtLSkubn563ZMiUjlIggj+y/d/4lmVPZ7d5uFH5ycmLNw3F4CFzocUGzd4JOnxUFiPXB7MzMzMi4ekaO86wACpIMtO71eioWiwqFQsY886V+MElgO5FRl6RwOKy1tTUrY0EHU3JMsJJMJq3Rc7lcVrVatfIR9AHllvPz81b+DDuWQAL9SkAGO4Lm4uh+nhGmFyVOU1NTxpRB74fDYeup1OvdbryMbaLEJxQKWVk0Y8vp1RQIBIyRRP8e6XaZEqPuYUzS72ZyclILCwu6du2ayS6MVWwgupqMNmuM7mfd+D5szezsrPb3941FyOdHIhFtbGxY82CAAPQx54gG55wJmCOpVMrGvjcaDWP1NBoNJRIJ1et1pVIpSecjy2EeUiKPXQeY4R4oE8Xe7e7uGiOQ52c/WMOFhQXTx+Fw2HQTAI5P8uzs7Og1r3mN+v2+otGo7TFAH5+FrcIPoLSXn6VSKZXLZcViMeXzeUkymcOnAYTwPa4ODw+td1QgELBBEqFQSIVCQclk0piwsPNgDvFM9XrdGIPZbNbOBeVrMNASiYQxMygbQ55gwnnQGl0Do4VSU5itlHCh99HvyA5M60QiYeu3srJiPhtM4NPTU0UiES0tLdkgEFgukUhE1WpVzWbT/Ldms6l8Pq+FhQUtLS2Z//bQQw9pampqhN2H7cDGIWswoPL5vJ0TdGgmkzEWnAeMOWfsJQDE9PS0MW03NjYUCJw3/vcsX74f+cZHPTw8VC6X0/7+vubn53XhwgVrPVEsFpVMJkdKwWC17+/va2Fhwewfz5hOp204y9nZeSN6GFL4ta1Wy2xKLBazfnj4llQEDAYDew4Y4OjISCRitqBer48kK5GFRqNhVQWrq6vmi+CjP/bYY7Z++XzemP/4igxjAKjFt8Dn7Pf7NogAlhb7HgyelwlKMhAMVh42I5vN2vnknrCLsOZgrqLrsNnz8/Pm/xwcHNja0RsUXw+bIMn2BdvGd09MTFjPNMBi9Nfy8rKVm48nN+hbSHkmDe7pAbaysmJ+C70NkS2APM45+h0QEdvIOrzUr7ug1N3rxXbdBaW+gRfZMZ+RoG4ep94HP2ShFhYWzBmem5uzkqmJiYmRIBknw2cAMCY0IpRkzi9ZOLJTNEjEmPgeAPQI8M07cZJwoIvFogUakkYozTg+GJlEImHTzyg/oy9VIBAYaS4O0ILjOBgMjJ5NoEvwl0wmR8q74vG4lpeXRxoCk3nCwGLMqtWqOW+sqy9ZCgQCFhixzgBRgEk4ihhrJk+x/x4MZD14LsAW7p1nDQQCunHjhnK53IhRn5+f16VLl7S8vDwSKMP2kGS9lyinCQbPS66Y1kaJC8bZOz7cEzKEk4TTSckllHGYCARJPkuFs0EJEQACz+rp1wQwMDmQW/5PphTZwzGjqSUlP5Tn+B4JBFuxWMxAEEm23vTAGQ6HSqVSmpo6n1KFQ01ZK0AJZwegDeeGAG92dtacRUprzs7OrKyN+2LPkAV6C01PT6vZbFqAD+BDQMV343AC4PrMKE4zYDPrjM4hyEAP9Xo9u0dkiGbMnkXip25Shkd/JAIawAb0hmcSsZfZbFaFQsH0gGct+awyugPn3bOPJFmZJlltAizWyDcu53nYQw8MkKXm3CPTNEentwulUGThSThwzmlETjldt9vV4uKi6Tf2EH3Ns1E6SAAJcHx4eGgNmAGp2FMCakAFnpf3YlNonksPGnRUoVAwe8MZwk6wH/T6QP49u5LSvEwmY4Fzv9+3oJp15vPopUhj8XK5bDqeYOHw8NDABvar3W5bCdjs7Kyq1ao1gkcvEPTSk2hiYkL1et3uibOL3AOMABwz9ZP3Ig/sJUAZpTM8BxP9fInIpUuXNBze7sVCQIUso2NZc/QhZ8+Xu7BO6Hj2mNITwB/PLGE9OAvYF/Q8NgaQJplMmt31TaR9OQzgKO8jwIO94VmMg8HAmrj7KZ7d7nkPm0KhoFwuZzaSck5AVnQOpUesE2vD/SOf7XbbygixEfTxRJ/48ldAonH2Cnqq1Wrp5OTE5MfbenQ7NgTwBXmCeYd+RudS1gmYAFgCswcgIBwO2wQ3EgKUnsMqOj4+Vi6XM0CYNfK/p3yTabeStL+/r0wmY3YZP6bb7VrfNWwW/mWlUrH+TwBCq6urI/7KzZs37RxfuHBh5HzhS87NzenChQtqNpum5/v9vulC9IrXZdgnJmPih3Hm0XHo4KWlJbNtHtTjXjwjkiQnrTDwFT2Y48Fs9BGgJwkNgGzk1veKApybmprS6uqqJb+Qe+wbug/2Hr6UB3rRmcgSCed2u21+h2fAefbPOOMJNngikTDd3263Ta55n++JBkiUz+etZI8z6/WDl0O+G1+v1+s9yzcnVoBN7NlqnHn8apJtXFNTU6pUKiOMQFovYFM8M9jHGJxbz9D3zMyX8nUXlLp7vdiuu6DUN/DCMfIUWV+uhnL0FFuCG9+gE4fKsy4ATTA43sHxIAoGHGcV0IASB0rO6JPhS53IMBJkE+TDUtjb2zOQDUdtvByJ7+P5/b8BbAh0CAZ8aQ9rh7H05Sc0UgeI8WUMrVbLjI7vLUGz1kqlYs1uARX4N6PcCUKlUaVM0EYAzn7ghBF8+/fAuMAJYDQ74IZvRNzr9fT4449Luj25hew8e0STTkBBggqcKQARAIt2u209m2BXACLAMPCgwnhZI38ABXid742CLPsyDhw86vXJbCIHvkyFdfVsPuSC95KVhrXkKe80yUVOYBAuLCyY3JINJUDhPmhqzXnxfbQA8vi9L78DvPDlNMg0z89z4WyzZp1Ox4AHXtfrnTdtXVxcNPAwFAoZMODp/uwJsggLiTVkjfw+UVLqdQcyQE8Q2E5koGH0EIAir55Kz5lFp7EP/nXsK03UCXBhzgFu+5IQSfZvnpk9k2R77WXJB3k8I2d4vKzF6yhJBrb5c8/nsd44yeypLyvgjIdCIWtWLMkCdfaKs0tJJ6xSZI+g0L8eHeiddr4bHYP9IDgDUEP2AChgQXqd6QF8bAcBp3fYyeKTbOCzYMnyfr4b3ejLc4bDoa0Nz40O5ln4OeeE/nmBQGBksITvS8h5hCkDiAV4QLDEmvizxPt5RnTp1NSUsVkog+aeAHJ4TvQ8v4dhMRgMFI/HDSj1lw/C0c2cA84WZ4Izjh3w9ghZR8bp8wbrmdcBwsN+8sAK8g47iN8T0AJg8N0eIOe5APNYG7+vMCXo+whIEAqFVK1Wrc8ez8k98nzsIXIH6Ad7GgDXJw0AbthXZJSzh0xiVwCTfIkZsove8HoJvQCoyX13Oh3t7u6abYDtVi6XR3rloVNIPNHAnWQZeiIej9vns56AKdhcWgTgD7C2MNMikYg10u71eqpUKqanJyYmrDdRu922PmPD4dAYmrAmYfgA5nq7wVkCFEd2OUf4L+VyWcFgcKQiwAOu3leFlcwZRQbRAegYkmf4Vz7Jis/Ee/HTALDC4bDpaM/a9OA/+418AqbQBwzmNOcD0JvyXfwJSdZrD53jEzqARPjKAML0rpuYmLCehIBb4+Vpnpnv7Rh+MD629wOJEfBp2DvWa3p62vq3olN4BuwN59SD8diTyclJYxuzRpIMsPVxAPfB//FnPZOKvcKWAwxjO9BrnBeeiXtmzUkGvNSvu6DU3evFdt0Fpb6Blw8EgsHzZtc4DBjUk5MTVatVK+dpt9tWDkVpAE4SgSGON1lggAKyjgQsgAGAXBgu3wcDqi2OPAqfJrM0TZak++67z0qu5ufnDczY29uzjChGl+wIjl8gELDAPhaLmRGHmcTnSbenrnlDRhYeB/Ds7ExLS0sj4AfGhc+VZA4QDiaBErTwYrGobDardDptpSpbW1tWLpDJZGzNPAOMdcbBxwDyOkoefcDXarXUarVUrVatVwJOVTKZtOlHrVbL6OpMjhsMBlZSArDmAweYcDgklPN4JyQSiSgajSqZTI40gvSZLhwBWDq+FGlyctIy+lxkjyUZa4UgGoo5GUSAh1qtZk2PYdkQpOMcwDaArYXDi8PH58HgoDTT9yqhIT4sFJ4R55rAFxAC9tLJyYmazaYxqSgd8sHXOEBXr9eNZQCDwDcahQHFOaOxbaFQUKfTUTabtVH2169f12te8xqT4dPTUwtuCEJ8nyJYZgApnBey7dls1tiHsFx4PQFcp9OxaX+SjPkGmNdoNOxZcrmcUfeRAZ7fB3m9Xs+YMwQeOJkevMIp9+wFAnxKq2i2SuDG75D909PTkQl2Z2dnisViFnQx4pvX8P2wtcLhsJUTUVpMiRigAsEMDjDng+f2oHCz2TTmQLvdVqPRGMnkz87OWgCaSCTM8YYN0mw2tbm5qeXlZWP4MaSAstJxJhiAK/sMGxa2A/KwuLhoY+o5zwCt3e759KbT01PTGTTAPzk50cbGhobDoekrSkZg0DUajZEsNeV1sHzISCN/yGKn09HKyoqtF3vOc5VKJUt+wPCJxWI6ODjQ9evXtbKyYgHIwsKClYVfvXrVbFCz2bSBI7lcztgvPhvP+sJIQC9Fo1HFYjGFQuelaLVazSad+eQHdrPVaml7e1uxWEytVkuVSsWYdyR+PEB2dnamSqViZbMwPynrks6DVkrSKSvC7kqjfWROTk6swTs6HV0J2xPAgXX1TF4CRgLLTqejQqEwYs+bzaadH8C7yclJa+KPLaKENRAI6OUvf7mVy2HjGcDy5JNP2nCARCJhzwRzF2CXBMTCwoLK5bLK5bLy+byxlHu9nrHUSqXSSFlcrVZTqVTSysqK2S3PLi0Wi2q1WsrlcqZfACwAKSQZCwzWDcAOYBjlTk899ZQ11A+FzoeCAKAFg0EDxyhNmpmZMfsMgL+3t6dIJKJ8Pm9nDf3ORF5sIEF5uVzW9va2ldmtra1pf39fDz74oCYmJpRMJtVoNHRwcGDTzPAH+Q50FcAqLRMAgDkXgCUkUKXb/RdhYyEnfnDC5uam6fOrV68qmUxqbW3NfAbYWzDsM5mM6V5sHQ3ysTfdblc7OztmN+jFBfDvJ7iScG00Grpy5Ype+9rXGoCJXzkxcT7BlnYDkkaSQdgEyhKnpqbUarWUz+dNfyaTSUswt1ot04ckUWBP+sTmwsKC2u229vf3tb6+rkKhYIMbAK13d3cNkPMsP8AxGFv1et38UgBPfASAO4Ad9olkBHaec4gvGI/H1W63rYRzfn5etVrNSnQBpfG/sYsksQeDgdnMqakpbW1t6cKFC8aUQwZZawBOZAufmIu1xPfEdtO2AN+XyZQHBwdKpVLmS7RaLdOtd6+7193rb891F5T6Bl84KTACCGhhsJApBKWHpozChUYPwo/TQTAGA0G67ZTiYOM88NmAFGT4+D8sIp8FlDSSxaOOnAwtgAhOCsaD7NP4Z3hwhs/jd760AwNI7wzPAvPlT74EjkwW30uJCtkgMmUAeZQ2EKzSQwFjmEgkLIOHc4Kj6bOq3CtglO9TQRBPeSCZL9aLjKcvX0gmk2ZYmaLEhZNNk1P2XBptUA+rBuAOp2BpaUmxWOxZ2SVklDVBppAHnFPuGdAHGeIZYD6QzcdB4z4JVKenp0eCIRwIaPI4sVDaWXN/XgiYWAcyY7Ozs9aTbXp62iZB+Ya6lKYgqzi/OIesDyAUTAzPlJFk3+mziL5XDj+HMt7pdBSLxSxzyX14xg5rnMvl7FwiO7FYzIABf349m5AzDnuBYAXHD2e4VquN9PWi9wJnBJAD4JMsv89Qs3cw38jojmdaPYvEB/6cY3psjdPuCRx8AMGeeyYo/aLYcwAwAmQCRs9SZf/4A9BL8gCmoKSRdeV8+H4d9NgKhUIG2vX7fWMGcua5X87H3NycjYv3bMWjoyMDtHHwvcPtWWleFmGzAHgg33wfrB32CcCDyWeeMQh4RqAHMAHzi733UxEpLUGeAY4pF+KeCMYAzqTzACgcDhvbivPH6/k89BwANSC6Lzfh98gUJb+sByA0JSTIzcLCgul4+tj5pA4gcLfbNSYGegEwgHIV7BIBEp+P3kWuPZOIwBm9MjU1ZXqcCzvHWcb+oDfQQ6wZ68VrWXfPoAZI9SwggCTvX8D0ArzEJvHeer1uQKs/n97v4H7YS4Lj4+Njm4SH/MO+8baK75VkgGg+nzc7jn4DtPVgG2eDKZm1Ws161lHCy/eh8wC3uAcSEpwT7APyCHAdCNyePEmfzuHw9mRkwBNeh06nLAswCn8HsBi7CFuQ4N6zrNlTngMfZDAYWNDNPgOO+T6I2D30M2ccWwxoznNRHuz7/bFWnsWPrUQP0BsRGUmn0wbqYRf4PzLldTbPh5/rS8FoK+GbjmODPECOnh0Oh1bCCxDmdSX6B7vqWd0kewDG6KnHmnqgibXFZ/R+BrqJUn7YPL4iAqASG+9BMr/Onj0LyFSr1Qzs9f6DZ8nzbD5e8Ikm/FHsH6A+utzbt/HWGSQkkAm+B9lOJBKWIOM+jo+Pbe0oycxkMmbv0QvcB2xe5BXglL1CXrG/2BeS8l6/vFSvu0ypu9eL7boLSn2DLxQ1DgpOBMG3JAusoMDChpBk2W6MHE2r+WwMkq/FR8HiIHjljVIaz9TiOGFEeC89dhKJhFHuMRY0riYoxfFH2fvSlmAwaL1tcKJwmAnwMGLcgy9T4zW+HKfValmQDNsHMCoajRoQBluA9Yd6PDk5aQ02cSr6/b7y+bz1I+A5Jdlzeuo3xpO+FbAXKpWKBWvNZlP1et0MJXuEk4QcUHqQy+W0tramer2u/f199Xo9VatVdbtdY9FJsn2HHUJD0E6nYz0QAD9gfHnmESwrHAaCnkAgYI4g2S6yjo1GY8QBwAnnHijtSSQStn8EWJJG+n8R9B0eHiqdTpv84rTRnB4HEWcbpwJ5IOCZn59XNpu1sd8E/jjyMBwA4HCeyKj5Ue04YjB2CCS9M+cZEpOTkyqVSnYeCaoJlskqEhwy4hhZZh8nJiZ0+fJlW29kKpfLmYzjtI2XiAKYwCygaT3Ns2FJHRwcWC+ZiYkJ+1yCTnqgZDIZ29NSqTSyrx5c5nwT7FPmBFDsQSkcfZ5hYWHB5AuHHjngfFESB4CD7PV6PWNF7u/vKx6P6/Dw0IYU4GQeHBzYnnvQnWCe8hhfLodu4UIGkVscbQI0mLDISTabHWG2STJmRSKRMH2KbqE3V7FY1OHhoer1unK5nKrVqlqtlp0rvpfAFfCAIBf9GwqFDGgLh8PGzoRNGI/HlU6nLbvO+2ZnZxWPxw1YIWgOhULK5XLG3CCwZH9gIXFmYIARQKDvyaL7CWLhcNhGodfrdUt4eFZEOBy2QJiArdlsGtjDEAeCynQ6rbm5OV2+fNnGqaPPYV7BymQdsYFbW1umG2ioDLjWbrdVLpe1s7OjVqtlvWwoG6LnCoASgZfXb3wvzFIAGHrcAHrU63X7GTIiyUBX+kFiWz1IiE5k3QHgeH4CNZgh3qZwln2Ai+0BgINRx2cWCgWFw2GTR4JLn0AZt50kTQKBgHK5nOLxuA4ODmxQCfoSvUifrYmJCS0vLyudTiuRSIz0uTo+PlatVrN+Su1224DOUChkjMhKpaJ8Pm8sIJhkBNWwaj0TDRYQ+swn9LCf9NkplUqqVCoGAgyH5z0La7Wa9SEbDAZqNpsGqoRCIa2vr1t5LeAVLD/sRalUMqAYYJ79l6RSqWTBdqPR0NzcnDHUWU8Agng8rnK5bEA1suwTPfzNWtXrdeXzeZO73d1dm3qL7NLviJ/5sju+g/5Z/f55s2rYNTC9sVckc7jwDwHN6E+EXdnf39fly5cNUI5Go6ar8G0PDw+1v79vTKHl5WUDpaanp21NPNjN9yLL2AVKewG0sQX0R8NHJYGDXHH/PrFFvzP2jPNP2Sn2vtvtKpVKGUONdR5P2sDMqlQqyuVyWlpasrXEf4It69/L72kd4pOBPoGHf+2TyPhmJFPYH4B/dDgJ9JOTEy0vLxvQy1AdQH+a0Xs7WqvVrAXF6empnRdv00OhkH2nLyNmUAu2iwSGt/cv5esuwHT3ejFdd0Gpb/BFaQsGD0cRp8AraH5H5gLlSZBEQIuzC6BAxoxsknS7STBAlKSRrItvLEj2l0axvofIzMyMMpmMBQ0EKjB/aMSJM+qzYThNAB0TE+c9SHxmiww0xp514OLefVYFYwKT4OjoyACB1dVVBYNBo5oDUFGag6PMBB8cB9aODJC/F5wqX2oGMEHg7zNDg8HADCnMN9/bA8BwOBwqEokokUhYljmTySgajZoTsLe3Z98zMTGhYrE40hMG9hf36A0sAB5ME+9U+b/ZG0+J9vJBv4hAIGDAABk4nHjv7Eq3+5swwZByEpwn+g8QfIRCIW1vbyuZTNp0FeTIy7cvURgOzyffpNNpC8phXYxnjhuNhpXceCq+nyLTbrfNgWXNcdwpRyXYAlRhvz04zPkNBAL2PawnGUXfVJXMsO89AYOhWq0ql8tZ/zNf+uRp7JwZz7zKZDLa2dmx7DzrwNnwbB6AmbOzMytXo3+Ibz7sS7WQH9/DjO8ig+qDZPaewID3Ezgj815fsY6Af35tOGOeReGz0dwXzjRyxjohnz5A92wazjwBBYAT6zs7O2v6DPmkhCEUOi/VmZmZMeYHDj4MPvaQMlZkE1bF0dGRFhYWrCk5DrUH8JEjr0dhUyFz6N2pqSlbO5gIgD3IOs+HrsAueCYsco/tqdfrFmhNTU0pmUwqlUqZnvCsXwIhgpRgMGhgQL/ft7Ja5IqzMT8/r0QiYSAta9ftdm1qInsAKA8w7Cf28WwEVOhumGToMkBkhkGgD3zTas/0AyQ7ODgw5qhPsHi2EnoAPelL5wA4kFl0r2c1eBCJzwKQwm75Xm6AQIABvn1AKHQ+VdGzgT2o5YNIbyf8GabsFxsLwwr/x7MQdnd3tbKyYu/v9XpKJBIWRKbTadMvrDvndXZ2VouLi1YC7fU7MlWr1czf8skv/BbYSKwpADO6gsQZICV7wLoiZ+PB9fHxsfb393Xx4kUNBgNjM6E30J0+IRkIBKyJN+ACCQNkq16vmxwTdAOGw5jz7EaAShIEfJ8HXn0CSpLZVF+K6JN/PCODNo6Pj1UsFpVOp0fY0TyTT+J4nYK8cyamp6eVTqfVaDQMXKAc3jf+9omecRs3OztrvZUAGPL5vCKRiOkNXypOT0/An0ajYT4X+ntqakrFYtEAP3xC9BhrMg4Ab21t2aAVWNh8JkwskmOcdc9yZZ/wGQCpsJuw+mZmbk/pBGAGqOdc+aFJ9OEk6QO7rVarmW4ieeCrHNgrzwoLBAI2cZefkVQiESzJQGRkFVvuzxmJHqa6UlqIfuGeAkzRCwABAABJREFUaMHAfZKgBvxEVpiyzdnjvKI7vX/vE/Z8D4mHl/J1lyl193qxXXdBqW/ghTHFcSQL5Bu/Yqx7vd5Ic0Ffu88flDGBnSQLQggUxjOTGAIAHQwo/yczgXHxJWaDwUC5XM5qrylpYHwuzo9n22CkcW5g1lBKRN8gQJKzs9sTwVgLnF8UIQbK97lgvaBh08MCoIZRzgSB4ywHHHgCZ4w+Tj/fQ7bIBwYAQIFAwBhS9HeQzplvZPWZnEKGmp5WGGSybGR3CBx55qWlJQMka7WaTRzB2Z+fn1cymbS+WOl02th0njVB1mlra0uRSGTEESQD7GUNecOh4zM9MwrWC0G3p8ZXKhUtLCwomUxaltIzeDgHMzMzWltbUyqVMqeCvhPQ2X3pFWskyfZivNE4DDT2p1qtam9vT7VazfYfR2ZiYkK1Ws1AFQ+S4eT6zJ8vuYMFg9PFOcdhpncGcg2ASVBN02CygQCNyBz6Ynp62vo2cJYIcCn1IbBCzuizkkgkrDymXq+rXC5reXnZgnIynAAP3Buj2enDRD8hX27g18OX+SC7nmFIcDw9Pa39/X0LiAhQcB4pNfElyPREIxPsmVZ+j/x3eEYbQANBhWewwFrhM3Ga0cmwKwD1PLDFvwnC+A5eD+MJfT89Pa1UKmV9/AiQYFISxDBtjb0na07gSEKAYJy1l26XTBEownKKxWIjDAGCAZIegDmedcK+eNAPPdXtdk0ukAP6tvCM1Wp1pKlzv983Btp4iTmy4xMWPBs6MxaLWXBHzzy/XzzH6empdnZ2ND8/b8kUdA1sGwJ2ziVMp2QyaZNBYfz5kj90iB+g0O+f9zvc3t5WvV7X4eGh6fRms2k6C2CbvUI/cwZIopBkYD/pe+J7JRHQ+rJ7z0QELENmsJ/YVvQX5wY9wP57mfKMFEn2b0CRo6MjWyvOHmcV28rnERSiQ3xJOjak0WiYbPu1AkSlNAtb48/QZz7zGQN/aOYNawebL8nAIlh04XDY3ufl2Qff3DsBsS/5gx3jG2XTGiCRSFh5ISxCGDjIhHQOiu/s7KjT6ZjPBWMI2QgEAuajkUiAEUQyEVAUuccfq1arGgwGI1MB+VxeOzc3ZyxxD5ziA9Xrde3t7VmijzVCplhrZBiAEhkDpO73z8uBmaCKb+BBLdaV93u9zs/owwpoNzk5qVQqZY3w8UlgmlEeB7gsydo1HB0dqVAojIDnANXoGXQM9hNQg6RiJBIZaRHAHiNHx8fHOjg4MMDI9yHDH0BOfSVBLBYzZh9+MCxLzgkyADPQMwwBjnjP2dnZSH8rkuEeuGdP/M8AlChx94CTdF4mSG83dNlgMBgZyONbd6Af8MW4H0p7va0FWKQ1A2uDH8P7y+Wy2W30Kz6175MKUIWvSY+5l/J1F5S6e73YruBXfsnd62u5yFT7/kEEQt4x91M4fFkX4BPggGdCYTwppSAz6DO0BNe9Xs/ADYIynFmUNDR/vrPX6ymVSllmEQcPR2owGBi1l/vBqSXjW61WFQgERvoWYKjIVGH0eDYcVowVmW/PTuHeyXoQeErnxpzxszSQxmGCjUBQ75sbYrT4PdnVYrFomXGca4wl74FtVq/XJd1mCsFKAwSRZEH2wsKC0um0stmsUqmUOZk4iXNzc1paWrL9pVHx4eGhCoWCNXnlDwGTzwphyAl6t7e3dXh4aOPMYQn4CT6+FxR/828+j4AOxx65AQgqFovmBFMWQK8PmvjiNC0vLysWi+nhhx9WJpOxsrBQKGSBMnKB7PKM9KLCgcSZ5d4oqfHToHzPEILgiYkJpdPpkd4RgE7sO8EA309mnmb0MG0ikYhlCZFXwCjKZaanz5uwp9Np5fN5mzg1NzdnUwWl814bkgxwwtGmxwJOKiAYOqdarVp5KoAxss3ZIjD1umg4PJ+qlM/nNTk5aeyQVqtlTnQoFLLmxAQ/yDz6DJ0jyc41gQSlVLBrmJTEveGYewCd7+AsxGKxkRIBH3BCw8dx5vs5p+grAiV0JTqaLDOljzjXgDU8ky81ZI1xyCkhZZLn1NSUlpaWlEwmjQHSbrdVr9ctYMJh5rvRNZlMxtbD620CJd8fw+8DnzMc3u5XBGDJEA3WCICPBs7YHsBW5Ir9Pjs7U6PRULPZtLNMyR5lie12W8VicSRhQQ83wCWSE9z3ycmJgRI+WUBAn0qltLS0ZCWaBOLsC3q5UqlYKaRng6JfffKFfeTMHR8fP6sBPcE+MprNZq2cjQCfprrIWb/fV6PRMNCFvfOAP2Aw3+FZauwpOplzS3IF28KZ5PfohDsFfrzHnxXPLmQtuV90IecWhgayMTk5qXQ6baw37sP3CWONQ6FzJrO3g+122/QwyRwAEg9YwyJhLSSZX9BsNm2a7hNPPKFarWY9wwDVz87ObDofOqDb7ZoO9/IAaOZ9Cs/6JlECkHt2dmb3zutgIAYCAaXTaWORUfJGY3PWm3IiD6DAPgGEm5+fN/ngXACGYJ88IAIwgwxxVngN8kxwzxnBxnMmsTWwoYrFor0fMAcdDBvNn2nuGZ1RqVSsfJbzSuICYAaAhPd7Jh/3Cmjhy8pgQcNw5DxXq1WVSiUbQnB8fGznnMEIgKknJydKJpO2Rx6QB1z3+hmg5L777jNg9ujoSNFo1BKgfigAlQYeKGEipPeDPQMuHA5rcXHRbDTrxrN7PxObx/kJh8OKxWLGQkWv8FqSAN6Oe3+K1gs+qeMTg+iX09NTlctlS5qxbx4QRsY9Q5pEu2ciAvrBXsIXw/eEHctawahCBlqtlp1j4oROp2N+MDqP55ufn3/WEJ+7193r7vXCX3eZUt/Ay2dWfDYTJe4ncxFEeIopdNhKpWIOEqADjh7OkSRzKABQMEI4EDBWPLAyOTlpbA6CrkAgYNl8DDN13ARN0m3ghXICHyAPh0MlEokRFlWn07Hae0mWlcSwMeLZg0usG04Ixg2mBaAJTi+15gADHoBotVoqFArm8BIs8n3eMPd6PcXjcXsOjOtwOBwZy+t7SMA8wBhTokb2lIlROMfecQcAYw8AxiKRiBYXF3X9+nUrN5icnLSJih7ggJKNHFCuVigUJMnuGTADZ5L1gdnVarVGZOXk5GSkxwsOMM+YzWbVbDYVj8etFAin1gNBBP3Q6mOxmJWGkqnDaWbfAWNxsAB4vDxwDng+HBHK1RgZj+zglOEkMtXRs8Do++EbznrHmCBpMDgv1WRPPKuJy7PwYKAAPrHOBDieEcb/2R+CTN9HhsAQeSKwgNkGwESZbTKZNNYje+5LE8iEErwdHR1pfn5eDzzwgDHsPBuNffNlQQCwvo+WZ4jitAM2eaaIB1LGwWeflYV5AoAK22F+fl5zc3M6PDw0IHdqasp6KhHI4JQDOjHZDuBM0kgTV95DNpYz7jO7lAbR/4OJbbA1aRSOIwxYyjmhHxfg0v7+vu6//367F557bm7OeqhwRgE9/T6SPedZKbECZKPshXJOyoLZj06nY+UjAMQeiOv1etrb29P9998/MjWN4Jx7RVeHw2GlUimFQiGbdrS/v2+N/bEpPjlB4gUZZc0BJ7E/6FrPcBkMBsYs9a8Jh8MG9gIgIIfxeFz33HOP4vG4MXGxuTR0Zp2mp6ctSYBsVioVZTIZs30Er4AkTA1lqi2sMxIr6Bl/Bkgc+Z4nBJKATQSnAL2wcTxDDz3G6wuFgnK5nCWUAGLoz8LnU2ZNUI5+oaSGPUN/05vPl4IhN/guvd75ZF76HAFO0icGfwNfwSeo0JGlUsnYSSQd7r333hEZIQD15X7IFnqLfosnJyc2rh477veI5/ZAAEkYzwrDz0P+WSOfYAR4m5ycNBAH+4iNYYjC7OzsCLAFELWwsGC2h+QLfYc4iyQGAfGZfAuIgR5GX3hGDH3L8K+ww/l83mQQcNU3pcanI+Hgk7LIVCgUshJNyr29Pfdgh3QOiANoo8M9sx47zN5h146Pj01OPAMX3QgjDRCQfeJ+sanYlmAwaJMc0UnIdjAYNL+TksDJyUlVq1V7LsBl5IDnH0/owD6EScXrkdtAIGAJXxj6lClTNo0e8TYZP5X9Pzs7MzYp+sGz1PBLAdMBgvFZsNfsGT0i+Sx/ZsaZV8jJ8fGx+bPIEX6M9/f4LPav1+uNlDqi7wDF0QGSLMZifTnTJI9CoZCBby/l6/9fmFKBQEB/+Id/qLe97W0v9K3cvb7O6y5T6ht4obRR2J46j9HGCUJZEBBgqAOBgJUXjfdz8GV2BCOSDKwAYKEcyPdr8ZkM2CaUruEwwt6BmUG2B0OMI0vTRkAdjAYZGgy4B9Sk21ltjKDvQYMh9tllzxTwwZHPblIuSOmCN2ytVsuyZQAlBP04XASf0OPJ3vmgCfq3JHMaaGDKRYbRM9XI4EUiEaVSqZEmuj6T6fdhaup8kiDgjp9050EXaOmUj5BBJjPpQRgaW5Mx5HnJtOLgIyvQ/cmccZ84SLFYzOTCl84R2OKgsLY47AsLC4rH44pEIiOjxtlL6XbvH+6RzKJnwPDzdrutRqOhVqulZrOpWq2marWqo6OjkSwkjhQMMQAonNLBYGAZX4JZ5MPLCs42LAGey9PAvTPvs32AYL5HDxlsHH3umWfndQTcvkfJ1NTUSA8WT8uPx+MWBOPooj/8unKeAM5xSKemprSysmJZYs9YI1hEFqTbrE4ywrCPfPmwB3goRUJnArD4Pm1ef/jSCNYEkIY1ZX8AtmCpEuQA8vF6yjr5PPYAHTXuzLEO/BuH2ssWepSyGM9o8GcVEBrAnybG5XJ5JID1oIzXv5wBzgVywzOwhsgc5YUEVzBnAHq4X1g8fAegFN/R7XZtXDvMT5gOBFm+HBlwANZqr9dTuVy29fWMJQ9UIgfjzDuCD18OIsnK/YLBoAHz9XrdmkkDvPjgnsBpdnZW+XzeQAzYNgAfgCKsjWeXBYNBtdtt02sLCwuW0PAMSZ7fN8wH9PD76XUOAIDXyb58mNcDSlH6zHmDuenZ1wTqXhfASPPl9B5o8QwNSjVTqZQlXChp8wk4zptnIsHQBDQdb5wMaxtdx2fAnGVgw/b2tsrlstk8mMVcnHn0pAfFKKkChOt0OrYn6KThcGgAPcARPgpgAu/xth/Zh0numVgAfYC0AE5+Gie2Hl2H3uZM+5JU2HPYPu6fEk72mZIt7h1544x7/xO9iV3nzPf7txume52Jf8CzAiDSNsDrVXxhdADACaAs+oD3oF/b7faILfaJWRI9MP/Qo4D/MEO9nY7H4wYcodf4w3NwP+gUkpg+weR1MSXMi4uLSqVSNogBv8aDf6wLso2tx69DPj0gz+8Bf5kESgUA5xV9gZ+PPwzQy1kfDG6X1vl19T4LnwXT1usuvxb4JKy9Tx7ybN6OA/jzf2ygB7y8fkTvYKvYF9YS1iLnC/3F6wHn0G/4Kb6M+6V++TP4tf75eq5ut6uf+7mf00MPPWSJ0h/+4R/W/v7+yOtqtZre+c532nCqd7/73Ra3fD2X9/0nJia0urqq973vfXZm7l5/e6+7TKlv4IWiH2+6iLPgqfbUP3vqLpnkbDZrShrjRyYHqjXZT4JcytKmp6fNMfZUfr4zHA5bc0cCHzLqZIfOzs5Uq9XMwM3Pz1tPouFwqEwmY0YBEA2mEYaXZwcMoU+GdD7RiCAC44ERgo3S6XRGRgND8Y5EIuakhUIhbWxsjEwsIVtWLBaN+SLdLuUBvIFRIckCWBgE0u2sIM9Cc1gaQ8/Pz2tpacm+2zNJaJ7tqfgAZsjA6empSqWSrly5olQqpUajoYmJ8wbF9F2q1WojpVewHmCESLdBPNgCMECOj48NSOJ5YML0+30DQHEEWCuCFH7ugxyCikAgYMwCMndkNUulkk5OTox558EAHG3PdsMpxBHmmfg304oY541TxLMxpZDMFzR5ggocJM8yy+fzI1R8AleCU5w3glfkwJfY4uQFg0FFo1GTaYIYeosAwOHcUhLjzzFUfr8nBPd+WhaBLGwRghkYRPQTmp+f14ULF4zKj06ivA9QlJ5GMJmuXr1q9xyPx80pxmHnfNKbgnIUnEJkexywhpbPmYd9x9njNazL2dmZyTkgBQE/rJxcLidJli1nYhNymEgkLKjxPTD4bFg0ACiUKhLw8AywVQgyCbpmZmZGgluYR4FAwEAKSqBarZZ2d3eNYQHLhow1YNh9991nJTNkeT1IJN1m45JxR15gCSGPsLjm5ubUarW0vb2tubk5A2sIeH2wBUBIk/ZUKqVgMKhsNqtQKKRisahMJmMlFQDssDABvDnDp6enKhQKViobDAa1srJigThgLiAv+qvf79v4dtZakpWyIntzc3M2Wl46d8ApnQOI4/z4shJ0MXYP+W6321Y6ybrEYjElk0ljpwDsYcvW19eVy+VsWEOz2VSpVNLOzo6BC7C5OK+SbGosMkLJsvcR8A888EyyiUB0MBhYU3v/fPF4XO1220Bm+md5lgNr5llJPkAl6OZv3//Gszm4R59cApClVBp7CusDoAnGZyKRsB5Ew+FwZNJgMBi0ZtaHh4fGmqxUKjo9PVUymTT7tLa2NsL0I4kAWxhZwecA2INZhmwC/vAZ2EMAWJIC/sJ3IenB2qJrsA2+XB+dha/FYBP8sGazqcXFRUUiEZN/yuK9DmP/8AnZg9PTU/MXKBtE7wJWoKvRS7CMT09PjdWM/4DdQgax5bwHGQEAoNyXZ+92u0okEpJkyTDuj3tBfwC0IS8Aap51DLAIaAuAjK0HlKBUH8YM4DjsePwTvpv3YXM9mIsekGS2FJsfCoW0srJi/fUCgYA2NjbsjMCQZLI1z4BuB/CGKQkreGFhwfwa70fzvNls1tjc/p5XVlZMd+BLo+9g2+HfeV/c+4bjeoe+nQCLU1NTth7IF8AfP/O989CfJCHQXYBHsDZ91QV+As9eKpUMDOPZAbtpi0FsBZjG88Bu9q08XqrXC8WUOj4+1mOPPaZf/MVf1Cte8QrV63X99E//tL7v+75PX/jCF+x173znO3VwcKCPfexj6na7ete73qUf//Ef14c//OGv6/sl6Xd/93f15je/Wd1uV48//rje9a53aX5+Xr/8y7/8dX/23etv7roLSn0DL4JVyj9wEn2QhvLkb4wdiC4BGCwcgnYfnHimFMbDMwkwjj6rBLDlHS0YBhg/ss8EBwQrUH0BfXwfjeFwaPXclKIAmJEN6XQ6ZlQlGSuC12CsPYOM75Zul+ydnp5aw0Oo1TQ19/0TYCXAROB3BKBkfgj6cGoAi8hakvUhq44RZcQ5ARD3ztqTkQ+Hw+akEWD4rG29Xtf29rYmJydVq9WsvAi2FrXyrDvgoiQLILhHHFBAJ8924hkB5aTbjC/+kMn2gBSyx/fyb5x7D2jxfZQDUgoFeISM+swse8Jr+D7P5mm32+r3+zZ50VPBYX94xwn2EY4eWUGCUxhs/NuzGQBSCbA8A4xz5PvHsJeTk+dTc+iHQFDnm+pzln2mkHXgrHNmPSMRueTcEBTigLOngB2UmC4sLBh45IEZHHPPQJPOnYhCoTDS44tzg/Pns7seNKeZKc/Jc7COnGHON2snyco7+R0y4bPfni2Iozo3N2fjvWGI+dID9JsHb9lvzx7xLEnpNvhEQOlBZIJ7dAKgJhlbZJwgDHD48PDQyikBfAjcpNuOYzKZtHtgLQgCvZOIfHnZBPwHrOp2uwYcI3M+uBy3JV4vwZhgrwA2mVzlGXIEOJ4dh6xTkkVTaXp5AIKga+lZRHKAdUNXeYCZdcVeAkYgL+gYZBGdMM7WI0njgy9fpoKc+O/0ZWPICeWxsAr7/fMeQeVy2Z4b3eoZJjCvOMusG9/N2fH7jkzwLJwLD5xzrjwYz/sAfsd1u9e5yA46iP31a4zc+PPsWScA2ZwvgGYA5kAgMCIvsDpoG8BnALoNBgNrAM6+YwOPj49tmh8N6XluzxiEgcHzAsCOJ0V84Ov1HzLiAVDvn6FH0ceHh4cjLEeAZvaJvQc8wBdpt9tKpVJWakU5InKLXfA9+TwjxdtY5MEnc/zvYaiiC72d4Xt8yTX7AQjm7eK4TkHmfGN7PtsnXHzvKg9ycf+U5Xl2zjhDHxtJIpPL+8aALgCazWbTbASyynd5lgXncNyHxK+jhB2ZISmE7xkK3Z52id9JknU4vF2yCABGc3ZYnpxz/DtkLBAI2GsA6JAhdDiANevmYwFsJTaDthScC3QZ+0oig/YUgFBehxFj8H1cJFK8HuM8eBlmvXxFCAkf1pnPrtfrBjDm83m7X18OiM/hYyzWjrV6qV8vFCgVjUb1sY99bORnH/zgB/Ut3/It2t7e1urqqq5cuaKPfOQj+vznP6/XvOY1kqTf/M3f1Fvf+lb96q/+qpUNj1/Xrl3Tu9/9bv3lX/6lNjY29Ou//ut3fF0sFtPi4qIkaWVlRX//7/99PfbYY1/Xc929/uavu6DUN/DCccD59ewJSSOG3PcKwFmanJy0zC9MGqb9SLenSOFoAZYQoGJocYZoaE7GP5PJWKkGGRLGwCcSCRu57hkGBIAEOAAct27dMqc7l8uZczMYDMwxIANIoIbRl2QZknA4rMPDQyurod+SvwgqyKzTRwYgIRQKqVAomNPP1LtcLqdGo6F2u20O6MHBwQgVPxQKGcOLLNZgMDDGDE46RhEHBNZGIpGwXlE47tDKvcODU06QDcU+Foup1WqpXq8rnU5rd3fXMu8+WMK4sEYnJyfa3d01+aIvFIBmIBBQJBJRuVweAUdh47BHlBXAcjg5OTEwrdVqGXjF3k9OTuov/uIvdOHCBXMiV1ZWjNXARZY8l8sZSAlTCAZYtVo1R6bT6Ri1F3YBTlK5XFYymdTs7KwFYr4p8fb2tvW3oq8aWVbAikajYUAezjnZQs4PgM3ExITq9brtN6AVZaK+9MUzKvgMSdbXCkf57Ox8QiH3f3x8bCVFh4eHymQy1rOmVqtpbm7OptbhUHMfExPn/eOYLBaLxTQ9Pa1KpWJMIc7FYDBQoVCwUitYnDR9xSHt9XqWkc9kMvb9W1tb2tjYsACVQIF+cTwjgSVniv+jq05OTky/MDIbmR7v9QZ7ggCOIJ5nQr58cAKgn0wmTQ5xdnF4h8Pbk+7QK4uLi9ZLhNHh9Mnw5T+wAOhpARtra2tL09PTWl5e1tzcnJLJpDF/qtWqlbT4MiA+KxQKWQPweDyuiYkJYzpWq1VLXFCqgjz64IxgfmZmRouLiyan6DwYAsPhUIVCQdPT06rX6xYMETiyHqwRgRJB5OzsrFZXV5VOp5XL5ZTL5awPWqPRUKPRkHTujGI7gsGg1tbW1O/3VSqVVCqVtL6+rpmZGdXrdQt2CfR4HhIdxWJxhMWG/ej3+6Z/CQI5p7BnOPPb29tqNps2JQsQSZLZGgC3Wq2me++91xidTMgMhUJqNBoql8sjwwY2Nja0sLBgDYR7vZ62t7c1Pz+vVCpl+hv2AfoBNgQ2goz96empAbRe96BDAO9YM+k2s4p9ADAlMQYD1oMUfC/nFZmEcQRwAUh0dnamXC5n3wvID9BfrVZtf9CtnLFut2ssMYJawNGTk5MR1rafNApwEggEbPiKD7aHw6E1nsc34V49k9b7TcfHxwbOY++TyaSKxeJIoI/ugAXCGgFEE4BjE9HJZ2dnZm/xF3zCBBsLe2t2dlaZTMZkgvPDGkxPT2txcVGzs7PmD3DW2C98OHop0ccMAIb1R9b39vaUTqcNVIFdUqvVVKvVlE6n7TzC0gK8OT09temSTPVF1gBr8T8nJyfNjvT75/3sPHBIeTkset/XTJKdG88S5/xgHwE3y+Wy5ufn7UzhfzG8AJYfoGi73bbkG2wqzpy3iyRt0GWw3vG5+CzvX2HPMpmMJNkwGr5rfn7eEqKcSUBS/E30CX4j5zwajY6A15wDEm0+eQuYg4/As4XDYfNtwuGwcrmcnefj42NjxwLg8GzY6Gq1avqqVCqZDk8mkyPANvfcarWUy+XMrjabTdurhYUFW1N8TdbXJ4M4R/V63cBSJhNy/khgwnJE94wzsmC1wSB9qV8vFCh1p6vZbBqrXZI+85nPKBaLGSAlSY888oiCwaA+97nP6fu///uf9RmDwUA/8AM/oGw2q8997nNqNpv6J//kn3zF77569ao+8YlP6Ed/9Ee/QU9z9/qbuu6CUt/AC2cFZ4qGfgSxvl8NAAEOK4CFdDtD57ObBNE+G4URx1nE2OLYE3CTNST748tiuF9JpvChn+PIeMowrymXyyOZJp4XJ4hgFQfQZ4MlGasD5xDj4stJeD/OBllv7le63VsFp451w2nBYcfoVioVCw4l2fpR9sdn4tTzeTybZ3xw32SBfIZNut2HhrXw99FqtQwkOTw8NKcNptx4Zsnv9WAwsGeBut3tdpVKpQzEks4DZ4Iosnze4cdYI0+Ao/wNywTHGvnd3t5WNpu1IAGHjECJbCpTbSjFYP+Q01qtZgyDTqdjgTglCmTTmaAyPz9vDI5oNGrfQSDgs7rjbBbOC/s8OTlpso4zx9ljDfjjGQTIAueZYGN8RDffg0Pd7/dVrVYtu4m8wmgClIAdNzMzY+cQ58yzEHDE0AndbteCUj/xDUYeTA/PjPPlYTw3n9/rnU/eLJfLWlpasvIIH/iNZ8o5fzhCsIgIctB97IO/d86+Z2Qiez5LDiuAf8Me4/k4v9wDssVZ9yxTgB2fZfWACplq9Bf3QQABgC/J9pjPo08IDCbuie9H5lh79ChnhOw4jCEPbsAwgSHFH/QSryHoJIHB+nr2BdlyysEYkOF1Iu/zLCOCBt/jhGw0eyvdLpNiKMPKyordA4Euso1sDQYDOwPYDQBB3wMINqkHaz1zi1I6kiOAEn5CGWvbarXUaDRG7I/vl4KOPjw8tLX3QCO9WCqVigGXsFfQvciUL1n1rJXxpBWyjJywz8gvepmzy9Q5bCI+AffI2QFo4ZzBTkJe0GFzc3Nqt9vqdDpKpVJ2xghiYbbV63UL7gmq8S1gn3F+PPiDLgfE9cwd9gt7y315JizlT97+Yse4P4JzWMSeAUliAF8JmUd3wNzwbCL2yzOrkdtutzsypIag15cJsz4AdAD9yBxl1Z3O+XQxzxoGFPLsYJ6HZ/f2wutT7FapVNLMzIyBfCcnJzaluNlsamFhwUpxT05OlEgk7B7RpTCUsW1ehr3ODwQClvACpOPcU9Z3eHho/g592jhz/AyZx+7wHkrbAMSx6wDu6CvOEn4Y+tgzg/jb++z4mug+9JoHswGlkBX2fZwZjuxgg5BPmFvIL3qb76LPJfaas86/fdIC/8vLAAwn9prf43dhh9rtttrttoFbnBcSduh2WPD4SDyj90t5LvyPXq9ng0ja7bbdK7qW5CA6kfPpbTxN9NlnkvX4TDD0Gbbg9S++CzKEXvybAF5eahdN9blINn6tV6fT0c/93M/pHe94h/Vdg5nvL1qYMKxp/PrTP/1TPf300/roRz9qTKoPfOADestb3vKs177jHe8w2T09PdX3fu/36ud//ue/5nu/e31zrxcElPrIRz6icDisN77xjZKk3/qt39J//I//UQ888IB+67d+S/F4/IW4ra/7YiIdhisejxu1nywr2QGfOfSBYqfTUSKRsKwV7BDKmGDw4DRjIIPBoFZXV42aHAwGjdZLA07628AiIhtLEE824qmnntLS0pKKxaKWlpbMAB8eHhrz5OGHHx4JeAj8MIKBQGCk/wjBWCBwe7IQQBPZLYIqskqwa3AqmGYFYCTdbnyI841B73Q61ncE53tqasr6de3t7SmVSlnzYbKip6enllmWbmdMo9HoiJNJaQcgIEERzpB0e8IWxr3ZbKpYLNoEEE+TjkajKhaLFowmk0lNTU1pcXFxpAwBILDX62ljY8MyjzAG6vW6TTXMZDJKp9M2RRH6+OHhoWZnZw00odRuMBgYcBKJRJROp80hmJ+ftyzod3zHdxgtnHHXOFSlUsmy7DhzTz75pC5cuDDStwtwlEBxYmJCy8vL9qw4I7Ozs9rY2LBgmGwjzVdDoZCWl5et4Ssjn2GWACoAshJ4IluwfQiUKIVkvbk3AMnhcKhYLGasOs8kCwaDxuKD+ZRIJIz5QkA3OzurZDJpbAr+TZDBqONYLKZqtWoTJsPhsDmcnBXfyDwQCIywsTjPrO36+rqxlciURiIRCyCi0ahWV1eVSqUs+F5ZWbHSAV47zjaBWcfZhVFG+SKDGwB+OMOw9mBRAjygM/3kPfby8PBwhFkiyQJHD6RLMtYgTCTOD0AScoLzGo1GVa/XLaCgXA9WBIxRgi+muk1MTCibzWpxcdGYAb6hOUEdctXtdrW2tmasNUAGSj54Ps889aCBLwNivcjQ93o9YyLAuqJ/CQACdoazSv+tmZkZk0PAOXp0ZDIZLS0tGXsI0PTk5ESVSkWSrFdbp9OxXl9MulxcXNT8/LxNPiuVSrr//vutx+HBwYEBGZJsvdD546XnHpwcDodWLh2NRnV4eKidnR0L8gGt0etnZ2c6ODhQNpu14QeNRsM+I5PJWMDW7XatDxeB18zMjK0FeqNer6tcLlt5ebvdVjabtcBtaWnJwA/sMHsOC6RUKikej4/0iIvFYqYjYbcQdAEUtFothUIhra2t2bkDGGEKGzJA4O/Zr5496oePFItFm7onSbu7u5ZU8GWUS0tLdiYmJyetnI4zTz+7UOh8Gihgw+7urjKZjPVK4sx5ECGRSGh1dVWzs7PGhg4EznsaplIps72ACACesNGQdc+SxE7TGxOwEN1Ajy4+lzVB56IP0GOASgAt2CZ8K+w8CSxAVxrF8xxPP/20Ll68aEx1zjbJK3T/cDg0XQnbfnd314L8fD5v+hqWFRPhHnzwQUky5h0AOUNY+DmN8uv1un3G/Py8AVeAy7Cx6FcK856SPZhNgACwWFZWVgy84HW+7B8/9sKFC1bWyL7FYjGzibAmWQd0lW+CDshC2SP6MxwOW8ITMD2dTiuRSNjQDvwU9psBFoPBwHrtoas3Nze1trZm9xGLxVQul02vYdN8NQO+IEAcZ3dvb8+C92w2q06no3Q6bT44QD+gGYwidJl0Pv10a2vL2LjYCUl23gjaYWKxxt7PwueF3RSJRKw1AHKOrvSlgjD9sN8whmG/zs3NGfMuELjdm5a4hKoDfE/aRDCdslgsGpBM3yovT8QRTE6FwQej+caNG197kPciu75ephQ9ybj+5b/8l/pX/+pfjfzsv/23/6Z//I//sf3/T/7kT/Rt3/Zt9v9ut6t/+A//oYbDoX77t3/7a74Xf125ckUrKysjpX2vf/3r7/jaX/u1X9MjjzxiZ/N973uffuiHfki/93u/93Xdw93rb/Z6QUCpn/3Zn9X/9//9f5KkJ554Qv/0n/5Tve9979MnP/lJve9979Pv/u7vvhC39XVfZPZ8KROOLIqWDBDZSBwhMgcYZ7IgOCIAQ8Ph7b4rAC1kdOifw2cFArdH3R8dHZkRCwQCBoyh1DHatVrNDDT9P3AcJyfPx0qfnp7ad/lMMM1pcdSOjo7M8PqeN5KMoo7DJd2u6QeYoBSK54EGX6/XjUkByFKv143eTYDuS+gODw8t08Iakr3HESXTwz5xXwR0BKiUuFEWQuBJlg7QBSAKarsvcyHj32w2zWkuFosKhUJmbGnS7llqOLY4YcgEjsra2pqWl5eNkcO94BgQHMDYImPtqey9Xk+NRsNKXsh0kVHFyWGt+/2+gRQwRrhvMmQ4H/T5QWbpDUBAwfoS8OJE8jkw5wgEYU8tLi5aKY3vQwFY4QE5aOU4/wQbZCRDoZAxJwCOWSfkBraPP5vsEZlmggQy6Z4ZSPYdoApWCs3aWV9Jdj5hgCAHOO98DllCyhsoAaapMmfRg5Ews/r9vpXDcMYqlYrdF+Aq388Z8tlkgjgCXb6HDC0ABeVZnvXpGQy+ZwngA8AxPaOQLcBtsq2cdXQLn+X7F9XrddPXrVbLmgbTO6nVapmOBPCnLJKebQSbR0dHljwYDocWfKEPKT0GIAeQoOSM52cf6vW6gWlnZ2c2PQngFP0IW45MMEAb4Bo6F1ByOBwqHo8bwwNbA3BA5h39zb+xM91u1/r3IYvVatV6knhwdm5uboQRyL3xWa1Wy1hPyBcyzDoT5CPH8/PzpufD4bA17WYQgi9TCofDymaztsecIdaNyVXlctmmk0kaKcPz7ONKpaJKpWIgH2cJnQUjC1YW+gMwF9AHZhlsGZiayBPla8jt6emplVByX5wVabT3D0xbdA9l0u1229YAhh12ybOYsU+xWEzxeFxnZ2daWFiwtWg0GpZQ8aX0nmkJWIYOpUQNMBqZmpqa0trampXLlkolSTIwFwAA8D4SiRhzi4CTe8c+oduZwlqv120d0f/cM6xa/AkAH8+Y8WxPEl34HNg8D3S0Wi1Vq1XzF6TbE9y4B84boHm/3zcfRZJyuZwxbwBPT09Prdyd72JSMmXGMGIA1AGW8Csoq4Mhz2fDGELXIFOweMZ/z3lGr0mye0Lv+ybg+CfoXmw6DHMSreh69BvyiO3GX0THYP+xddjfXC6nWCz2rIlwMPYqlYr5YJSLYcfQS5QvkgxCjr2NAnSjZIxS9na7bSVtlNrV63VrU4B+wh+DceLLkn1ZKffoGfgkPbAb6E4mZZPU4PMkmY3j3CATzWbT9g7ZoUzVs3MBVLvdrvlqgGOewY0comfwrThfAHPoaoBHytnZL/zKXq9nJZ/4USS08ak4ozC82GvuG6AM3wBbTu+ul/r19YJSOzs7Bo5KuiNL6vu+7/v0ute9zv6/tLRk/waQ2tra0ic+8YmRz1pcXDTdz9Xr9VSr1awX1NdzLS4u6tKlS5Kke++9V4eHh3rHO96h97///fbzu9ffvusFAaVu3rypBx54QJL0+7//+/re7/1efeADH9Bjjz2mt771rS/ELX1DLjL8NMJGYU9PT49M8oLejjPZ7XYtGxCLxXR4eGgjpnHMCc5gdnj2DIYIZw6jKp03emYKE4wl7sdnSXHaisWiUqmUIpGIFhYWLLvNsxD0QOFFsfv+C8fHx4rFYsaqaLVaxtCYmJhQtVo1A4yhArDAgPX7fZuoBcAH26ter2swOJ/I8a3f+q32fBguMjxM6ur3+yoUCup0OsaUoqcNLDImwgAgtlota+xJRonP80wADCkMkHK5rAceeMCCHrJTBAsEbWSWcdpxVCKRiPUG6/V61t+AzBqOLuvl7xnQj4Cc/YKFgnzAcsDpAyAjG0rJ1/LyspVO0AuAshnYVPRaiMfjlhFEDjBssCPYEx/4sSaU4fCsOMmU7pDZi8fjFvxSqsbPGSvL2hEISbK+XzjoBFE4PpxTggfv/PkJi5QN4LwBXGD8ye4RPCwsLBjrBDkGiKW/RCwWUyQS0c7OjmX8ut3zKUXxeFxHR0cme76nEuez0+moUChoZWVFExMTxgwB3Ewmk0okEtZwFb3AeGxYhYlEwqZgsX5k6+lNE41GtbOzY+vOPvrSSVhjZM+lc5YjfdMGg/MePjwPAAV7BHhK9tWDsDBo2D+cZXQagTuOMXvN3gO6sa8E9ZSaoM88wxP2HEEFoDulm4lEwnqeVatVXb9+XZlMxkA2dGkkElEsFhvpWYUz74PgSCQywojzzZUBqHy2PRKJGGui1WrZ96HHYCmhF2DmwI4EeAOI9ecaligTGdEvgKzjZUiwMwjeGAM/NTWlUqmkSCRiDBnO29zcnAGVgKu+n9XZ2ZkymYyxKMLhsOLxuJ11wF5YBgS9yBkADHIEKPHMM88oGAxqcXHRmCes3XA4NPCKoBc2Ad+N3qdszjNusMcAtXwGZcUAfLBDCHQJyigvgoUImIMME6Bz9tDNAJ7oWZIN6FXsIboLGw6wFAjcnh6ZSqU0Pz+vaDRqjOZKpaLl5WX7bpgVyCisGvQJjK1CoWCNaRcWFpTL5XR4eKhCoaByuWyMPlg6BP2pVEqJRMKAc3+mSWA0m01VKhV96UtfsjJVGHUwebCNgESsK+cAlgXP70v0fYA7MTFhPZAikYii0aitNwBXqVTS0tKS6ViAX+4HX6BYLKpWq+l1r3ud9efc3NzUhQsXzM6i05BvWM6ZTMbK3gDyzs7OtLi4aCV3yB3MSw9csGewvellxveGw2HTJUy4XV9fN5nBj0BXSrdZ5QCVvqej74cUDofN9tOvDqYnnwN4ir87HA4toCUBSO9Mpq1h57BDgO+AyyR7YU1SHkmS7OjoyPwLwC70C9NjYUElk8mRHm/JZFKNRsPOk2dcB4NB1Wo1ex50AHrYtwvg3gn++V4Sn9Jt4NCDDegvgCcSB6FQyGIAdCLsJ382AMCPjo6UzWZt75Bd9o6kzd7enp1zgD10AYwkz8bye4g84GMhS9wrJbUwqvy0PNjh+FYA0wDW9P8jDhsMBiPsZvYX4PDg4OCrC+5epNfXC0qhg57vQheOXwBS165d0yc/+Ukb5ML1+te/Xo1GQ48++qhe/epXS5I+8YlPaDAYjIBc/rr//vu1s7Ojg4MDm8D82c9+9qt6Jnxn/L+719/O6wUBpXwd9Z/+6Z/qh3/4hyXJnI8X60V2GoYTQS9gAAAHBgqApFwuW2a3VqupXC6bw856AESxbt7wSFK9XrfeNL6sj3rrUqk0Ut4G4EKNPY4H9Phe77zxMRTzXq83MqadjH6z2TTgA8dvOBxqe3tbS0tL5vwcHByMUOXJmhIUkgEdr9vHOZ+cnNT+/r7i8bi2t7dHWBWwaVhf39PJ9wSSpIODAwNByOwcHh6OTN8CEAF8gBFBSVOhUFCj0dDx8bHW1tbMkcMh29zctB4iOIJM14tEItrf31ev19PCwoL150qn09bofHJyUp/97GeNOuvp45SEkSmlUSSAiWfHUYfvWU6wjw4ODkZo9fQkYWz85OSkZRUBZZA3ADeysjAh+N3s7KwFarDaWMdWq2UNl3FYj4+PVa1WDdQFGKA8i5Ij2Cw3btzQ5cuXrbl4Nps1mad5brFYVLVaVaFQULvd1uXLl+2eNzc3lUgkdOvWLWUyGX3xi1/Ugw8+aIEIvZkAcQBrb9y4YY7lxMSEtre3tbCwYA4P2cd8Pq98Pm9jp/ksHEOywWR/g8GgKpWK9dw4OztTqVQaKW+lcTXBBgyMhYWFkT5A8Xhcs7Oz5iAvLi4qHo8bY+rk5ETxeFyDwcDKrmjECsNlf39f5XLZwL5KpaLh8LwEEYANhgj6iL0iMAFQpeQYEI8x8ATHvtyWM43OGAwGKpfL1rwUBp/vM+LZKTSUJ3vNPeFsE5xwrjnTrJ1ndHo2ly91bTQa9lyAKwBe9Xpdm5ubarfb2tnZ0erqqgG9nFeei/OJbjg+PtanP/1pCyDYF77X60fOEwAjoBZye3Jyov39fQMtr169qlwuZ2AG2WfWEPkl48znEVDAKCNY3NnZUSQSsUAqnU4bmxbmLiwUdOyXv/xlXbp0yZhbMPb29/etrIOgkSCcMhzA52KxqP39fS0tLRmzh0CcnjjYK8rvCLphrB0eHhpTGdCg3+8rnU4rEonYpMSTkxMVi0UVCgVja8zNzSmRSGhyclKlUkmFQkHb29s2aQ/wnmbV6H8Yw5Tq+ww/jD+AO3rNEUxUKhULzCnhZE3Z//Fy1Xa7rd3dXbMZlMoRYPuEBew0zgQMP+7Bl8Yymh5QhcbI2HXPtut0OpqZmVGxWLRA+5WvfKUx6yYmJhSPx03+6Tvoy4eQX7+PJIJg5FQqFR0cHIwErchlqVQy1gRBL4xZbB5yAruHXlOAsgD0BDT4EwAvyWTSGI38/qGHHrIJeuhJGOIHBwe6deuWJiYmdM899ygej+vmzZtKJBKan5/X6uqqTUIDKKnX68aET6VSymaz1sbh6OhI5XJZh4eHunjxoiYmJmwSLKWd+C3oSc6wdA5mlEqlkWc8OTnRpUuXFIvF1G639cQTTyidTttQmmvXrikQOG9YTLkYdqrZbGpra0vtdlsPPPCAMVva7bb5E5S9NRoN+16ej0SJZ/bCbgFI4FyEw2GlUikb4IONKJfLxobxLEDkIplManFxccTeMnih0+moWCyaTPvyS2wEIEo8HrdkGED51taWtYbI5/OqVqs28AJgBnYiyRT22ietpPM4CWAcoIwSfhiLMI/w40lSkATGxtXrddM39DPFh0CekZf9/X1LUvs4AX+EQT2+aoASZ8BpYhaGPeEXoCNImsMuBkzmfb683zPHAdJu3rxpwPzs7Kz29/fte/ARsCMkmAGO9/b21Ol0dPPmzWcHcS+x6+sFpf66V7fb1T/4B/9Ajz32mP74j//YiAGSDDi+//779eY3v1nvec979KEPfUjdblfvfe979YM/+IPPOXnvkUce0eXLl/UjP/Ij+pVf+RW1Wi39wi/8wh1f22g0VCgUNBgMdO3aNf3rf/2vdfnyZd1///1f17Pdvf5mrxcElHrjG9+o973vfXrDG96gv/zLv9T/+B//Q9J5h/zl5eUX4pa+IRcZMzIrOKBknGEKkR3BwJKNxFEiG0ypECwnjDUGE4bL3NyclbLwXQTIZB3JBvIZBGJkWsmK4LiSSSLTFwqdN2jFUaRkC6cRJ4334yRiYKh5B/whO0XmjfsmKOFZfK8K2DmUtZGNgjmBA0m2Faey0+lYvwOYAgAEGHuf3feKnOwV6wi7ieck+8n9++k+PogkG0nwAnuDz4V+XK1W7fN9w1T/B7YU7/OZXr4buj0ZepwPAhnfRwogUjoPvJiORukM9waTgGwh9+9lixJKwD2yhryWHg3cL+Wfx8fHBkoRgPv7RUZ4DWeEfgG8j70D9OK8kXEkOISNQSDNdCPuD3lnnXlGzif358+5p/bD4oC9AQMDmaOhKWcZwAnmED1+kFOCoWAwaOUT6BmvMwBzOQ9M1eReJdkZ4nm5b9h/PDPMHgBd1l+SgUnIDwwe1oYzx7nzz+j7vPGMMMe4L8AbeomQBUafAsb7kkGypdyT10ms7fi5pmkur6OMwOtaz0RC3/Cs9DGC7UNvLfQj++4ZUv4skimmFATGFQ4/DAbkFlnAhrDGsLwAir1+gJ1J6QUNwlkrgi7KNQBN6AvDeUcfABJSShwOh81WECgDMmLHYAFz5sj8wwrkHr0djcViZvsIkGdmZhSNRk1vcl4AdQCneS4yvegCr6Ng55ydnRlb0ffoQq8gT5wH5N3rY8+IRUZgOJCZhxWL3ANOY1cIMAHCYSgi7zwv55vSGPbK2xJ0lXQOPAAGIX/B4O3pip4FjN1kLfgsfofMSrLvBTTCv0HPIjfoP/QzrEGYYuhxmH++PxgBPzYKhjlnmP0GeKIcDPDO984CGAqFQgZw8SzS7emHMJf5NywegDfsGTLLGqFj6EsEINhoNEzXErh79jwJP2wSPXZ8Tyl0bywWG9ElXi97hhRrenZ2ZvIFwMt588xpAMjBYGD3ABMKXwx2ne+f6NsV4ONwpmEgc3+wsJFjfo9MsZaw/mghgf+IPp2YmLDWCVNTUzZhjzMNIAGbjmfAFwC04d5hi8M2om8WdgV5xLfHpsFUoxcXSULP/ocNzbmAVYo+Rb8gO5wBLsr7SXTjsw2HwxE2MesNKIUuBbjCF4bliv/Me7GlnBf0GToGeaRfHvoCfU0iA9tF2wx+DxsbPcw5974Lfj575eWBBBbniM/Dzo7LN8AuuokqE84a+o/E1Uv1eqFAqb29Pf3v//2/JUkPP/zwyO8++clP6k1vepOk835U733ve/Vd3/VdCgaDevvb367f+I3feM7PDQaD+sM//EO9+93v1rd8y7fowoUL+o3f+A29+c1vftZr3/Wud0k6l+vFxUV9+7d/uz7wgQ+MnK+719++6wXZnQ9+8IP6yZ/8Sf2v//W/9Nu//dtWg/onf/IndxSuF8sFog9FF4NDqRRZPPoppdNpTU1NKZfLWd30E088oWw2q0KhYLRZekTQh4aABeeYLBKZyUQioZOTE+uFRBkdfTrod0E5AEwUnKilpSVrtA3Tit5HkiyA9CAbmRrfYLzRaFi5FH0KCHBxbGAx8Nk4lTgXksy4YZAXFxf1zDPPSJJlXVh3mFI0FSewJSMcCAT06KOPWl8k6dxobm1tKZVK2b1g6Dxrg/dHo1Fz5GCZUN745JNPamNjQ9Lt0jNKKGDxnJycKJvNGnCxsrKi4XBoZZ+3bt2yEeUzMzNGMx8MBkomk0qn0zo4OFA0GtXy8rKNoQdALJfL2tzcVL/f19WrVyXJmFKSrF8ETgqOLEDhzMyMyuWyKpXKSElmt9vVtWvXtLGxoWg0qmazaQESzlGv19M999xj6wVDgcz4YDDQpUuX7HlOT0+tlxYZORz5ra0tnZ6eGmiAYxYOh63MFGeQAKRer6tWq6nRaFi2NBQKqVKpqFarmSNaLpc1MzOj7e1tra2tqVQqWflFt9tVOp02tpeXscHgvAEw38v3MGUQQLjRaFgTZ0pW6B1Fc2gCHNgBnqHAeSejSDkBeoVmwkzNofEnpbVTU+dN/XGuj4+Ptbu7a8ESZR/0h4MxUigU9OUvf9n2CwfOszQA7HyPKRxZwHLkaXJy0vpV0FjXy1MgcN6cncw5nwXTCwCabPDe3p4FM/1+387i6emprl27ZqUJnNvDw0NjyFE6QwkeMkimtl6v27mGmYeu4t/0xkC/5PN5dTod1et1HRwcmB4BiEilUsaa6PXOe2O1Wi1r7g2LYGZmRpcvX1YwGNQnP/lJfcd3fIcFfr73GPoYgAU27c7OjgEKNM/t9Xq6deuWAV75fN4Cpk6no4ODA+vJREYaVgIgVSaTUalUUqvV0q1bt4whCygHGEW5B3LhQa6pqSndd999KpfL9hqCTPRjoVAwkAbbyPMTmK6srGh5eVmpVEqTk5OqVCpKpVJWoheJRGxYRCqVMgCHgJAAjeDJ9/giwKlUKsborNVq1s8nm81a6UelUtH169etR069Xlc0GrWy9H6/r9XVVetDJcnYW5wLemOx/+gOSVZKQxkrU0mxTT6ohE3CmtHkO5PJ6KmnnlIqldLu7q7ZOA82kCjiHnDW0VG7u7sG7nqQkcCV5u2+DJUEA+cYBnej0dDKyoqq1aoNcEin01paWlIkElGhULAAmEmr9CGC8c30w0ajoZs3bxrje2trS/Pz88bqpSwYJtbe3p5NqN3d3VUqlTL5l2T+Ceeai2fAHgEME8i2Wi1rKt5ut5XL5awpO+s4GAzsfJydnRlABwMGn2Jra8tKJjmP9CWEcQ4YRiKk0Wjoxo0b2tzctL5MsEnpzTI7O6tSqWQ+Jz1/fC8x3+MJxtXNmze1tLRkDdSZuEtftdPTU+3s7JhPA9Nlf39fq6urOj091f7+voFw6JlUKmUJKwDrL37xi+Yzk4SDYYiu2d7eNiYkQCZgEWAUvi0sPtj/JDsHg/PBJpQRwWCCjSpJ5XLZzj/6hbJo9m9+ft58NUBuWMurq6va3NxUr9fTwcGBPSNtCgBUsG0wyGDNJpNJ+z3lx/jmsMAKhYKBzCTlfJ8tGETIIAkzfGpAKPxiz1YD2MUGbG5uSpKuXbumb/mWbzEffWZmxhhx3mcBsAI85qxQQo0NTCaTxipFpuhhhs1lgI6f4MmawiLEXiUSiWexAT3rFjDt+PjYem7G4/GR8373+sZdFy5c+KqArUQioQ9/+MNf02dfvnxZf/7nfz7ys/Hv+npBtbvXC3e9IKDU6uqq/viP//hZP/+1X/u1F+BuvnEXQA+9IMhU4sx4OjxOuf89AR+OH6APDg1Oku+zQrCGkZZkGW3YJWTNyGKQ6abPBMABIBo1wj5DiWHDEcCI4+DwOWSBfINEel4MBgPLAvKZOMhkkglaMcp8NiwBwCIcAwIK7hsKunRbMZGF8/0QcOx8oIAzyRpirFnbubk5ex7f28kzxngO/3yDwXkjXZ+V8Vk/Akjq5WESkVEnoB0MBs/qDQWDh3shA8n3EvSRHeWiCaVnJUkyGeh2u5YJh5LtM5848sgjmT6ym+zReB8O7gl2Bo4MwTL7TRkgGWs+A7nCqWNfPQOJNcMxY03IJPJ53plkbzx13GeHyWTj5CA/7AsZUWQLufDnD1kkwPSgFGvnA3Fkg5JMgkgy6sgl388esU/D4dCYVj4jSQDA+WRveE7k27Nw2E8ysJ6pSf8Wry+QE/74NSNzyfhtSfYz7oF79ufF/55zyzrD0OG7ONtkhgGlAOEAAhlRzTrTb41MPWAcWW3PgGE9KbfzDEb2BFYIOhO9QCkdZxtgEPCVzDYsMvQW8gZLhz3xugiwhQAIPcIzEtjyHMi8JAMGyCjDApmbm7N+a/7ceVvhAUx0N7oEBh8ZdGwT8uOZW54BCzOTgC4YDBpLBOYs5ayeDQBbB1uIvKDXuC/uHZbp2dmZBdjoVYI/1pQgEb3HngOAA7bRnJs1p3cMcgAbgUCR13oGEGuIj4A+g8VBmT9nBBngPLPX2HyeCdYg+ojEAevO3vAZMG6QR/Q8rCL2Dd8GdpE/K55xx32yp/QH8kwdXg/TCQAFfQOIwethFHFeYHehZ0iC4V/BikQH+UQfbCr0J+wP7AolvX69SAzBovIMMhIw/B+fx/sontGILp+fv82i9/oG/YQe8fqVs4CuQtfze/Qj34N8obfxFVl79hm7gl0HHEXvwcD39w+jkLPPMyND6ELvu3Bm8T/YY+6Fz/dMc8845qJ0E5/Gs1dJKPKd7BV+gPep2GOYk37Px/UHdhK/ibOK7OFzobuRa3wydAC+iWf14Mehn1h3z1zzlRnsJ7YI28y5Z63w/7DN7AEy6f3zQCBgJXv43cgFPg2+CM/h/SfKWVlX9PD8/LwBV5w9ryuwT+yJ7ymJj05JJH4Dz0jVAueO7/ay8lK9Xiim1N3r7vXXvb5poNTX0ivqKzVW+9t6gdITDBMo4dgQJBDMlctlC+6ffvppXb58WYlEwurQMSTUxkM1xmCB8uMo1+t1JRIJXbt2zUpxyMSk02kDAXCYMTBM1Umn09YjqdfrqVgs6vDw0PoPAXSQhSDziOIHlEKhkV1iMs7CwoKq1aoZnUajoZmZGQtGyNCSAYHiTqkQgenU1JQWFxf1spe9zDKrMD3I0JBR3tnZ0c2bNy1Dxz3euHFDiURCOzs7Gg6HSqVSlulmTyjzoM9IPp8fCbrIDL785S9XMBi0SRK7u7vW66fZbGpxcVH5fH6kpEKSBQMES8FgULlczkpbarWaNjc3tbCwoEQiYSwJjHi1WrWRzaFQSK985SsViUR05coVXb16VZOTk9ra2jLmBKwkAhl62Xj2GtOvYLpJsv5Zp6en2tjYsHHWlJTx/T6D7DO5yWRS6+vrllXkD6wT/uZ9sBGq1aqx3hKJhGVbYeDQ2wInlizc448/bgDD8fGx8vn8SI8ssqiMpPfZZfafM4hjiBM7PT090ksDhxbGlM/0k40jYKpWqyPj3uk10mg0dN9999l7T09PdfPmTeVyOWNfok/oTQGYRjkBzUenpqZ0+fJlo9qfnJxYbysmxQ0GAxthT/lBMBhUoVDQ1taW6vW61tbWTOZwJAlga7WaOp2OObEEzOwNUxEBMch0spZHR0dqNBoWqCWTSTu/gAZMDKLXCll8eoCQIUY+CGDOzs7seQEKAO2ZgjQcnvfxQ26r1aoxbggAYU5QIkP2mslDg8HABkBsb2/r4OBAsVjMeiFcunRJ+XxekUhE/X5f1WrVzhw9YAjGE4mEisWi9vb2NDs7a+PSyVi3Wq2RLLsfLuH3dW7udrlzNpu181atVlUul1UqlbS8vGw2CKAaFgoAFWxewMhu93zK1f7+vg15YN8BKujzQo8vMtyUmtJnC3bQ1atXtb6+ruPjY+sPcnh4aNN+UqmU9VmD9RGNRm34xeTkpFZWVgxExJ42m00L1GFzwGrwwSHAM4Fsq9UyFt3x8bH29vZsCEEqlTKdWa/XdevWLf3VX/2VJiYmdOPGDd13332qVqvWFFqSMXzouwZDET01HA5Vq9VM18DQ4/2cL1jDkqwMFyDs9PTUZAPdAVsIOwjoB5u6UCgYuDIxcT6dkfIy/BT8jGg0aizG4XCo5eVlS1AA/PgybeTIAxd8Hr4HfhK6PpfLGcOEs8Hz7+zsaGtryxiO9XpdxWLReuPU63WbbjY7O6ulpSXroYgPyT5XKhVjpuCnHR8fK5lMWp8cbDOJk3q9bn4SwCGAYr/ft/diF9kH9IwHkJFJSpfm5ubMBpC4uX79usnc5OSksUjW19dHyuTplwWDcTAY6IknnrAhNKFQSE8++aQF6pwR+uhgF4bDobH/eFbsPFMRZ2Zm9OCDDxrL3vc0BcSByc35Qo8waKNardp0452dHQMZsNdLS0tmdyWpUqmo1WoZIxcAETbywcGBVlZWrGyenmx7e3vG9sNWYZNgEONDFgoFnZycWEWCZyYBqHpG2unpqdny4XCovb09dbtdY+hwIResFz7AwsKC2u22+QCsHZMu8WNu3LgxUuFA+Tx+OrLCQJJWq6Vms6lUKmXPubu7q+FwqFKppAcffFBHR0fa3Ny0smlYfycnJ+ZjYeNJnsAMR5d3u+d9yNBX9GbibPqSyd3dXYsPfKkzfczQjySWYc8CrmKj6QNGlUa329X169d14cIF6x1ZqVR07733WgxBMp7YBn+L3+GT0H/rpX7dBaXuXi+265t2KnEmn++ihtnX+b+YLjKSOGVQ9n0/HWjGZFFhAPnaaPpBAUpBPSVLTVYGxwCQgnsgg8f/yQzgdPkMHcaQ15LlgYVFVpDMhc+MkE0m+8098TMYU2RsyAyRtW00GvY8ADQE4GScWUdJI/0G/HRAn8mCbQKg5LM0fD8gARk2z2zDifTZX7KErCEZSrKxfDbBDmtFZtxnrjGYvo+A7yVAwI0DcScWFICHz1DCPOAP64oTxft9JpMpFKw5DBSca/peAXryHGSmcNA9s4VMmWfWsD4EPbCz/J76tR5ntvnML8EQjj3ZXPYFVgj35c8ATApJdkY8y8+/f/w8cJ8+a4/8k2XmTHuZ9FlT1ttnVfksv57j64YjChjNvnJPOIB+zwGlfNmpfw/lWpSE8D3IGowq+hr5DDAADaWQMDgJdJEV/wyAhJQl0WQdfQF4A2sHFpr/HM4aWWYCabLqnCmeF5AK4A5Qd25uzoAz34OCLDPNbGHEeKYka4GjjU7wvbF83xxAGAJpzisstXE2B+eVzwU0ZW8p4eb7uDdklH0CuAHkxBb5/kCU2bGPyAu9f8ZlmHPOd/l78GeGM4qe84AkegvWDu+hrxbBO9/HmqBXPEsB9hv6GwANRgX60uskD0phZ0gYsad8L/qJPwQ27CH2GL2GjCFLgBi+5yD+AbbS27aZmRnVajVLChAU8h7YU9g37Mv09PSzWDv84d4J+gH00Vt8PsxBr+t4Lp8M8r4H308g6IeK8H7YfpJG7s3bVNbAlznhv3DflHZz35IMeMPe0TMGPcFrvK/CPbD/6F3PpqKcF/Yu5WHolHH2LvvtfTmYOehrZI7z5RkenD16BnHW2U/PRASIR85Ya84f9+X7Anl9458d+cB2evvD+QsGg/Z75Nn7ddgxWOXjNotkDrYbOfVgJXYfhiRANLYJdhw+FPeN/4P+4t/4Zawz++z1q/eZ0FH8HzYTzb09c48/vNbrCt7HWqFDASglWVIU/4XP8609WDfPsPRMKH9eSFB4WfEMNj6bZ4fNiK/J8wIue38Z39X7JOgQ9tfrWnxJ36YAmRgMbg9W8eeQ/faMfs6dZ6wDgPN9nEk/IRjdhG8JKxBQmHXD5/NVFS/V6y4odfd6sV3fNFDqk5/85Dfrq16wq9VqWcYXGioZcYL84XCoRCJhPV2o3b733nt15coVLS8v20SoyclJG5dMsE4mFQeCDB8MI+mc8ULvFfpV8Df9IehXQQZiYWFBa2tr1lB2Z2fHegaQTW+1WsawoFSBLFyj0bB+HBcvXrQMExPgYC1Isj4dkUjEJstQtoZBBbyr1+uKx+OWcZmdndXCwoKNPoY5Uq1WdXp6qmq1amV9OMVkjVijp59+WtLt3h1MKGk0GkqlUmo2myNBC+BBvV6XdG7sG42G4vG4Ll26pFqtpkgkosXFRWtmPTl5PnHNZ0il25RiGCwwL5jgFAqFbHJKu922fms3btxQp9NRIpHQ0dGR9aN65plnFI/HdfnyZX3hC1/Q0tKSMdS2t7ftucmenZ3dHscLwET2jvuSZFlaGujD2qAMDLYMThssNXp3JZNJYw+wloyHZx+Ojo4s4zgYDOxez87OVCwW1ev1rP9Ho9FQqVQywHBqakrxeFyPP/64isWiJiYmlMvlrJcIWWoYBbCSAMSq1aoF7AQi3GMqldLe3p71+oGFeHBwoGQyaZlVScamgg1E9juVShlb4vj4WAcHByoWi3begsHzyXgw+g4ODqzvFzJNE2K/PwRbTNTJZDLG9Nrf39f8/LyKxaJe/epXa3p62hhBTHcEECqXy5qbm1Mmk7Hs540bN1SpVLS4uKh0Om2Mot3dXUnnQB79SXBMmQpIwESPCsApnMZSqWRnhlIdgt3j42NjLxDk4JAD+FUqFXN2CTrpaRYIBKy/18zMjGWR0ZmUFvhJgQQnPoPqGZsEw4FAwHriAJoDys3Nzemzn/2slXXB+Mtms0okEgoGzxs5M2GsWCwaK4XSB75nf39/5DvpeXbr1q0RWcbp5zyGw+eTj1ZWVuw8AV6Ew2Gl02n1ej19+ctfNrZEv9/X/v6+sUAajYbpTxpswz4sFouKRCLWw4RnQgfPzs6aLqtUKiM9UJgCyvrRh4n37e7uqtPpGIuXCWb0fOt0Orp+/br11IlEIvac8Xjc1n1+fl7pdNregz1gamahUBhhdebzeQMJsA/7+/t6/PHH9cgjjxgbJZ1Om+3hzJRKJZPfs7MzpVIp6++Gfq3X69re3jYQot/v2/mF6UewycTEwWBgbHJ6/UgyIAgGC2xNkkaU+iUSCdVqNRUKBWNhwXLk827cuGGJG+zt1NT55Fjft6XTOZ8Iu729rde+9rUqFArGqAHw7fdvTyNDz9HnRZLJJX5BPp+33l+UfN+6dctYypxt+gFhH/gZ/akAwGHJHB0dKZlMjjTCx9+iJ1O32zWmFAxbJkYyZdSXjKEDYPPitwH+wSq97777VK/XbcIuTDVsMmAVjbUBdSUZOLq8vGy+FT0IOYcPPfSQ6SQf6DebTZXLZbVaLZ2enhrbcmdnR81m08AiWDCw5wBG6N1DvzP2GzY853A4HGp1ddXAZVhp6FamG1KCDMMZxiLM70uXLplst9ttk6Xt7W0bvADgiL+BfYXJDWsGAKtWq6lSqSgej+vzn/+8lpaW1O12bfo0NiKbzY6AEJ1OR9vb29YqY2pqSk899ZSmp6eVTqcNKAPsQ9fic3DuqS6g9xx2PBwOWy+kUChk64Bc+UbnrHWxWLRpkuVyWfPz84rH4+p2u2o0GgbU4KfgN5dKJStFbDQaymQy5hs8/fTTyufz2tnZsdYbJycn2trasvvB3gMOweZeXl62fmvlclmZTMZArIODA9MD0WjU2F/oHPQD4BC9Zj3Igf2EDba3t2eN4wGwsdn4zJKMVci0Svx3/BIAGGRoOByaviVOiUajunXrlvL5vFU2vJSvu6DU3evFdn3TQKnv+I7v+GZ91Qt2wdaRNBKMk+UicybJkH7pNqIPQwZDHIlErIwEQwDTBMcLoGl+/pwKy0QSP9XGM7UIyvkDWDI3N2fZfek8MMBxxpmjdA+jgtPNMxBw8xn0TOJeyGCQxQfsYEy8n4Dms6PcB8+DIebfsCygRPssvw8AMHgw9sgg03uHNceJkWSB6HjvGKackJkCUKKhNc4+mdZxUEqSTVAjm+j7/3AvGGQCdL+nZJP4GdlpgAD+TUZXkt0r//cUeb6D9aAhJMAO30PWlR4RyJYkAxH8vgCAscZ+igrrTRABmHF0dGSyRBmS70nD90LjZm24LwJ5z8TBcea1yKTvtYDc8ky+Zw6ZSAIWnD3PevMsI56b97C+gFI8G3uPfPh9hq1EqRfMHe6Tnjp8Powi5ANm0HifOBgG/Gyc6UFfES/3R0dHtl8+0+2zxjAm/P0T9KJTJBl7xLMqCMDImCI7BBmA8OwLDBnWAgYRzAjfRwjmIX2IuGf2H50yPT1tDf7Re17PsFahUOhZupUyNv969AgBNKCStwe+Lwnry/dT1kUWm/MDGOy/y/c+4r5DoZCBV5xrkgDoGgBlzhasAq9zfGmX/x50PCWP44wazhXyyZ4B4sDa8YxisuF+b9Hf/g8yip2FTeGZdJFIxMBnGHF8hwel/OfSO8U/H3qSJt70rsIO8DycRX/PyB/rxD57Nhk6AvAcOfFMO1gNMDe8/IzviV8jzgbPzf0BUPF8nPdxncDrfQNldCtrj/xwIV+8F5+Az2dN/O/8vwEAYPAAZGF/uQ900rid8H3SkE30U7VaNdnCBuLb4FN5hgsy4lm5p6enI+vsfTlkF1CK13imNHqh2+2O9DPzTMc76R3u0ZcXe5nzzHR0pmfcoF84j94GwUTx3+vtM9/BOYYJw3743+MjoP/xYb0PgX7hHrDTlILzfsr8vL3CVnlWH/YFfcLrYRoFg7ebxfthF8g2982zsH7jOj0SiVh5M38Abfzz4QcCApFA4Syj27Ef/X7fWGX4JsiQB3lYE/y8cb8FHcsfkjzoE2QvHA5bxYCXTZ7Bn1f+UJrJ95EUkGR+GHplfv72tEWSNuwZ+0ZpNnsP488z79AXPDs+EOwpnpuz7mMLwEKYj15+SMDeve5ed6+/PdcLVlT753/+5/r3//7f68aNG/qf//N/amlpSf/1v/5Xra+v641vfOMLdVtf18UUO2rCCQyOj49VqVRMgeOsY9gBisiqz87OqtlsqlarWb02hqfX6400zOZnZBEPDg7MaNGHYX7+vOFuJpOxSU2UXsCaSqfTCgQClm3d2dlRvV7X3t6e7rnnHu3s7CiZTKpUKml6elrXrl0zujR9esjsfPazn9X999+vo6Mj6yHlAQeyazgAExMTxnDCUTg7OzPW1M2bNyXJgrnXv/71mpub0+HhoW7duqVut6uDgwPrLcFUj+XlZe3t7empp57S8vKyyuWyTk9PLUMKC+D4+Fi3bt2yHhHVanWk3pxMFWuJUyidO8+xWMwoyQSSAFHD4dBAFkodmL62ubmpra0tnZycKJPJ6ObNm1pfX1c8HtdwOFQmkzHGWD6fN7o0ACETfGj8SiawXq/r6tWryufzxg5ZXl7Wk08+af0qWONGo2ETa8hM0QdIkmWu6TMA+4DAE0e/VqtZT4yNjQ2VSiV1Oh1tbW3pnnvuUbd7PrmP56UXB0xCyjnpTUKfGLLTe3t7yuVylrFNp9O6evWqyTo9U8hERqNRRaNRSRqZFMdExmvXrtmUIIIWMsGXL1+2DB9TvaRzMHN3d9cCmIWFBeuBwgXrZ29vzz7fs2QINiORiGX3nn76aT311FNKp9MWPGcymZF+UuxHv983JiY9Uk5OTlQqlZTJZCwz++Uvf1n1el1TU1OKRqPK5/MGXJPhvnDhgjGBtre3LWOZSCQ0OTmpvb09bW9vjzBeCGaCwaDpO/QR54QeJWRIy+WyZbphG9JHiXI5GKM0k5VkATHMRYJH3/vjxo0bJhcEW5wLArTBYGA9RAKBgP2baZuTk5Pa3t42FiLlqwT99LM6OzvT5uamjaqn5Ofxxx/Xgw8+qKeeekpveMMbRp6J/ijIHSA1unJxcdF6fOzv7yubzRrrpNfrGRBBjzWCMZzt09Pz6ZTLy8tqNBrKZrO6cuWKvQ+nfmNjQzdv3rQpVrBDPSN0amrKmG/sKUMAKpWKsQhTqZSV48OOKhaL2t3d1dHRkTHVDg8PRxgZvV5PmUxGxWJxJCAi4CgWizbBdTg873eTTCZ19epVpVIpDYdDffrTn1Y8HtfGxobi8bi9hmBzaWlJ1WpVBwcHxpTh3IRCIe3t7eng4EC7u7uKRCJKJBKKxWI6PDy0fn7tdlvZbNbOV7PZ1O7urvb3943lAKP1woULBphw7pkkSNDeaDQMWAYwgfHEv7GLfujEYDBQrVYz4JuzDYMVm0iyqtlsGlvmscce0+LiojGTYPu0Wi0dHh4a+IUvwme1Wq0Rhs/+/v4I86hQKGh2dtYSKvTtAuSldLVararZbKpQKBiLsVQqaXJyUqVSSeVyWTdv3lSj0dDy8rIWFhZULBZVKpUMHAEcbLfbxoaFbVkqlRSNRnXp0iVres46DodDY1rBzp2cnDSmRSQSMXYHZ+lOvtzMzIx9Js/qewyiv/CT6vW6JQaffvppLS8vSzpnJu3v74/oMibYktiB+QxzGH+q3+9rb2/PzhJMJJr3Uw7G7+r1uj1foVAwthC9k2AJMXmsUqkY6FMulxWJRFSpVCzhwzQ6fFrOO/0TW63WSBlfOBxWNpvVYDDQ8vKy6fN0Om06F38I+1YsFg00ajQaI60R0E/0+yuVSjo9PdXHP/5xXb58WVevXrUpe4uLi5qZmVEymTTQGWARH6DZbJpMNxoNa04P+58EHGCR97VhXT7wwANW9seEzWAwqKefflqZTMb6+52enurxxx83/wGfmxI6SuAXFxetdQDsq6OjI5VKJaVSKc3NnQ+ZgBEcCoVsOvbNmze1tbWlBx54wPQM/luz2bT+cTdu3LDSzlqtZgmcWCymWq1mvVUlmc8FixHd0Gg0VCgUDOQHyGNyJr5xrVYzmUDncn7QXzdu3NDKyoqCwaAlchnmwmd0u109/PDDpjOfeOIJW8tGo2HTGVutlsrlsvXUAjBkvwHh6EtK1QY+1Uv5usuUunu92K4XBJT6/d//ff3QD/2Q3vnOd+qxxx4zxd9sNvWBD3xA/+f//J8X4ra+7gvnlgz8xMSE9T0i8+czG1DRKSs6Pj5WLBYzqi60bSjTOMQES2SEOp2OjcrF4RgMBorFYua484fMOdlogjd+D+jFRDTu6fDwULFYzDLljIsHvKE5OkFgPB5XvV63IJLnpJwpFotZ9o1SRtgWMBww9jj3lJ3FYjHNzc1Z49tYLGZsHxzZaDRqI6F5NkqjcPgAB2iGyDPRDB6HCFo4lHz6DfifxWIxy9L5kj2yZGRcKW3p9/uKx+NWFsNz8IcsHYacrDxBLeVd7F8sFrPSNQI6KOBkjpAHHBucL/ojkUkic+sbRrPnNOYElGIvhsOhYrGYZmbOR/lOTEzY88XjcWumDb1+ZmbGmslTBirJggAylfF43JoMA6jxXQRAjESOx+OWmfSgFCV49AmCEROLxUbWAIo9ZZeS7N45VzSIPTs7M1CKzOjx8fGzzlssFhuZ7kcGFWYOe9Xr9ex7fM8immqTIUf+uE/WHDkg28k6+bMdi8UMBPDyQFByfHyshYUFe/3p6akNTOCz2QPo8X6CkWcXIBsLCwt21gEGkdder2cNiQGpZ2Zm7LPJnPr+IGSUkbler2cyIsnOHOtBuRpOMWU0NHgnKOT8SxphwaBzvWxHo9ER5kg4HFY0GtXZ2ZmtM8CvZ9XxfJ45yb0HAgHTseh69o4sM0xM7AMAOHLA58Gk4T4BqymtI4PPWnnmG2eDM8r+xePxZ8kS+0pJC8Awz+BZgZRrLCwsGKMCVgB9SijrmZ6eNv0N+MX39vt9xWKxEd3PvQEecE9eV7LG6FUYNnwOrDFsHLILiEz5J8EX7EbkAjtGwEbfQdYGhrMHNgClkHlsTqlUUiwWsyDZ9xr0fVAAlDjLExMT9jx+jwDMAGVgRRG0E7Qh5zwT64NdQX9SssnzYKcJSqPRqLEjAE0jkYjZDfQZeoBSTIaijINSvI/ziF1DRjjD6EGSNATF6AIYtNgakhHoSmQPwJ8SW5gtMEz9WeMeKN2F3dNsNk2fcMbwj0KhkMkwujQYDBoYALtp3IYAXFC26UuJz87O7DxS/s/58uXsAPbYSlhWsPOQab4XvYaObDQapt/w7TwoxXvH/U98XUpfp6amTB5ZNw/SAUpx/n3JrpcbwDFvt9CBvhwcmeAssycktdgbSnfHQamFhQVjB6KH6F3J5/p1w7eOx+PGhILNiCxSjk0CArsMo+vw8ND8S5rAU3Y4HA4NpPU+Fr6nlx3sFswk9g1b7Bmt3ufx34duhw3FmcIHhc1I0hD/D1s8MTFhZcDVatXuj3iB5CZsSwZ6eL3PWqKvJifPhwHg/83MzJgMYZ9hiHm9AZse8P+lft0FmO5eL6brBQGl3v/+9+tDH/qQfviHf1i/93u/Zz9/wxveoPe///0vxC19Q65isShJIwg8GQ0AJnpS0JsAOmmlUjEWDQE7oA4XGUAussCSVCgU7N/b29uSZFM3KP1bX1/X3NycTQzxzgZsjlKppP39fetBRHkbmU5KiI6OjrS/v2+15PTrwLBevXpV29vb1mx3/PL3ywWdliAGlogkK/MLBoP6+Mc/bhmuCxcuqFAo6ODgwBxmnH2cznA4bCyBer2ubrdrfRNgr+Bc0xCYgB4a+eTkpG7evGklgQQ8TAik1I2AcLyfSLPZVKPRsEkx3e75NJPHH39cCwsLBsZdu3ZNS0tLI81AKbuEUeeb3cJqePrpp41ejdyQOaL/18te9jLL2iIf9GHBcDX+38Q9f5HVvHLlijKZzEjvqXQ6bUEoe/3Zz35WqVRK9Xrd+hTQv+Dg4EDlcln1et0CQcpTuE+YDslkUs8884zm5uasBw49A05OTix7StDAJJ9UKmUOOE4fGVJ6iwQCAX3hC19QrVazPlE4Nk888YSthe+fcevWLXPAyJRLMtaCdN6Dgcygb+BMrxv6wSCrp6enyuVy2tzctJHKpVLJgvz9/X3dvHnzjg4Uww9gvAEkwWZgit78/Lxu3Lhh+sXrgO3tbe3v7+vGjRtGl+90Orp27ZqefPJJPfHEE5qbm7P+Fdvb25qfn1ehUDDgGKCZRqY46pQE37p1a4Qq3+/3dePGDUm3p7ICJgB+EWgwyahcLhtol8vl1G63bWop/aAI/GGlEPgUCgXTo0zsGt83SSP37x05wDb6m9E/aWVlxRgV169f1z333KNisahKpaJisainnnpKCwsL5mj7htfoBSY1DgYDLS4uqlKp6LHHHtPrX/967ezs6ODgwJimvV7Pen1wf5Qi5HI5sxkLCwva3d1VsVjU8vKylf31+30VCgXTQfRv81OcAO55H3YimUxqYWHBWEHIeb1e140bN+x9w+FQ6XTaphvBmJmbm7OkyfXr10eAWoDDQqFg0+TQpblczgJBnrFcLuvP//zP9bKXvUwzMzNaWVnR4uKiNRxGZx4fH2t/f98+V7oNOIZCIWNHMEXq5OTEAJRqtar9/X0dHByoUCgYmwYQdmVlxeTy+PjYegttbm4aAwO97+0YFzL4XBd62Nv4cXnlovck95ZIJPTMM88YYI687u3tGbCErPvLN8ymj1Wj0VA+n9eNGzeMsby9va1UKqWJiQlls1ljS5LEAESh/+TR0ZG2t7eN0QMjsdc7n4JGvzumwSYSCaVSKXt9sVi0HokwokiUcC7oZwXTDnbiwcGBAdeUX3IWJBkzmws95XszSaPTo5kitr+/b8yozc1N/dVf/ZUCgYCy2ayi0ajZrlqtZuV/kqwnEgkZJhDCVAuFQmq1Wtb7hqQZzA8PpJPkrFQq2tra0l/91V8pkUhof39fGxsbeuaZZ6zvTqVSUbPZ1OzsrMrlsgEGTNXrdrsqFAoGCH7+859XKpXSwcGBwuGw1tfXdfXqVX35y19Wq9XS/Py8Wq2WgX0nJydWFk6JHGXL+DMTExO6cuWKPSvMIHqGAW4AQp6cnBhblfv9+Mc/rm/7tm/T5uamATaJRMKAI1i0gJywu3d3d41FBGg+Pz9vvm08Hrc1isViqtfr9jrYWN1uV9VqVd/2bd9mTMPt7W2zhfSipG/s3t6ebt68qWw2awlBSgpJ3uHTAzzR33RyclLFYnGEAeyTtNjKaDSqp59+2sCwmZkZLS4uKhAIaH9/39bcs+z7/b42NzcNXMKOS+f6Eza1JPOlsFmnp6c6ODgw1rGkkRJFPgNb5S964rbbbWMss7fYaBK409PTun79uhYXF60ke3t7W5HIeU8tmuYD2s/Pz2tra0vhcNh6bjKxGT2JvSMee6lfd5lSd68X2/WCgFLPPPOMvv3bv/1ZP49Go3cMil8sVy6XMwNCGd7q6urIhA/KsWjSu7y8bOV1x8fHymQyI6AU5XtkQzwNluwwlGc+w5cfXLx40ca7X7hwwQJyHHeyNjCdCJrIoAwGA6O9QqUnM8sodrKxHpSCDUBjZZxhmjFz/5SZwNahXrzb7aper1v2uN1ua3V1VQsLC9YHIBaLaXV1VcvLy9YknT4wZIwJ/smoUnKE40CgTanczMyMDg4ONDFxPna30WgoGAxqfX3d9or7vHDhglZWVoytg0PgQSmcNZrEExDCoGi1WsbewFnO5/MjPSRwmmFKkU2jQSrvi0QiymQylimlgSxlCN3u+ehzpl7BFqDUymeHJRk4srGxoV6vp/X1da2vr49MfQGU4l4obUqn09YsPZ/Pa21tzXqakI3FKSdjS4knIB3NLGGE5HI5SecOzeLiojVcRvZmZ8/HgieTSWMCeFCK7D8DALLZrGKx2AgohQwPh+fNj5eWlrSxsaFwOGzNbGdmZgxM6Ha72tvbM1ZBo9HQ+vq6Lly4oHw+r3w+b58NC8VPyaNPApnlwWBgMua/C+ee89Lv97W0tGT7gSNNSRTMtrW1Na2srCiZTGppaclKzuLxuDU5BzQPhUJaW1tTMpm0Z+U5AT9g6CCvm5ubxqjBASIbffHiRYXDYbVaLV25ckWJRMKaqmezWWN8wmBCJwBQUUrozzugFDrj+PhYa2trBkoRtPJvypRgJJI15563t7e1tLRkgRXnjPIY6TzI3tjYsLIQRs4DSiHH6+vrxkIE3FtYWDDWhgelfHkXgSXgFDLEz0OhkAqFgp0FdAIlaxsbG1pfXzcwjhKGaDSqlZUVY3969h3Asgel0FHNZlPr6+vWQHxhYUHr6+tmYzjHsAUp40HGafIPc4dAmPMqyVgIgUDAAFv2y/d2ymazGg7Ph4PkcrmRRt+UzgFKodfQJQQsNFD2vaBgXwA4wqq7cOGC9S2hQS4MHGkUlAJkgPlL4Eb5OKBUqVQyNgB2FQYZf4fDYQPlYe8AeqMf6OHC0JLp6Wkr76Gx/Pr6upVPptNp6wmDjQLIIViHERgMBpVMJk13AdKhx1g/zkcymXwWKIXd8AxJkm74G71ezxrDY7dSqZTZLQ9KYRfwV/AnKI+KRqPG8EEXeFCKKV2dTseGSgBKAT5RikhZGPJ5fHxs5dQEvCTgAoGArTFnjySQB6VoMB77f6xeP1wB+xQMBkdAKexio9HQhQsXtL6+bmWdgFLobM4/DB+ASZhC6+vrmpqass+g1AnWOswvwCH28eLFi9rY2NDk5KTZ0vn5ea2vr5tvOw5KYf+XlpZ04cIFhcNhra6umj+AT8T+wFLCN2LiJIwi+nbi7x0dHVlSgDWXZGB3Pp83YMr36ELOqV7wZZ4kjijpglHG+QXEQO4ApVKplNbW1uz8Y1fw7zwoBVsHXwNQCrYcCQdJlrwAlPIsJA9KwY7jWWCkb2xsGJgP246EDYMzPCjlewkeHh5aYiIajWp9fd3AMkApyn9PTk4sjmANiG1IWJRKJeu1RQsPSurw4wGKKT9Gf3Q6HYsz8DkpQ0TmYZKi4ykdRafj8wNK4XvR9xYbQAL/pXrdBaXuXi+2KzB8AaRvY2ND/+E//Ac98sgjikQievzxx7WxsaH/8l/+i/7tv/23euqpp77Zt/R1XQTjd7ro1+Avltz/zlNox38+/nlfy5ZBXeUz73Q/49/l/x5//TjV9073+Fyfe6eLz/9qn3P8fvyz+XUdfx2G6U6f+9Ws550+804/e75nutPPnus1z/XZ/vO/2t+N7yv/fj6D5deJf8Ng8591p/sc/77x9Rj/3Oe67rRWXo795z6XfD+fnD6XPPiL7/lK6+Uv1uirPXfcy3OdrTvt3/jn3+nzxtfI3xd/+88ff9Y7feeddMRXWofnWrc76bvnusblcfw5v9K9jN//13KNr/Od9ONzyd3XeobHz8ZX0rPc23jWF6f7Tvf+XPvxfJ//fOd8/N/PZ7/8PYy//k6yyM/9891JP97p31+NDD/XZzzX+59rPZ/rWZ/v5/76Wu36nd7v/+Z773Svz/dd4/6Cv7fnO8PP9/M72Wd/3Umv3el9z3U9n317Pnv4lZ7h+a5xO/Rc8v9c3/l8n8nr/bm+k384fm6ez5fwrxv/nOeyK4FAYISp/3xyMP7e8ed5Lp0w/u87+ViSRpgt43L0lXTpV/Ijv9K6PJff91x6xieg73Td6Wx9pXv/amT0+dbD7+Odvmf8u/yQAP7+Snr1Tp/5fPf5XNe4DfhKttd/7tfqT0rnrEjA6JfKRUz6sz/7s9ba4Gu5Tk9P9Su/8isvybW5e/3tvl4QptR73vMe/fRP/7R+53d+R4HAOcX0M5/5jH7mZ35Gv/iLv/hC3NI35Mrn8wqFzscINxoNra2tKZvNWtkRJVqU6uVyObVaLaXTaT355JNaXFzUtWvXdOHCBcuqVSoVY3zQT+bo6MiaQDIyFqZBpVJRNptVsVhUPB7Xd37nd2plZUVLS0uKRqNKJpPGeKC/DX0XaEC6v7+vyclJPfHEE3r44YeNuUAj9mg0as0YKc+gpIysF1Rf6bwUAdbQ/Py8Dg4OlM/nrU8A2WGmczAFiH4HnU7H+nNkMhkbOz8cDvWqV71KFy9eHGn2ns1mlc/nTZnWajU9/vjjunnzpiKRiG7duqWZmRk1m01NT09ra2tL6XTayiPIAkm3g7vFxUXdd999mpiYsKb1Dz30kNLptGZnZ0emeiWTSQ2H51klskSBwPnkMDJpZH6r1aqKxaKxbmBRzc/PK5fLGWOKbB29wMj84bjyHdPT00okEsayqtVq1jCf9W00Gmo0Grp69aquX79uvYrIKlIaCTtjY2NDh4eHeu1rX6tHHnlEw+HQ9jSbzSqTyYz0MqJZPiy/ixcvajgc6tatWwoEArp+/boajYYuXrxoU/aQDybSjN/z9PS09vb2dOHCBcu2r6ysKBA4zwbmcjnLRNLPh3ICeibdvHnTqN78LBwOa3Nz01gpZOulc0bWysqK1tfXVSqV9OSTTxp7KBqNamtryzLe7XZbFy5cUL/f1+te9zpNTU3pgQceUDabNWYSWVycJzKVtVrNRjwz8AA2361bt6x8ZWtry3pZBINBLS0t6aGHHrKyFOSWZ4vFYsrn84pEIioWi7rnnns0OTmp1dVVraysWI+QYrFoAwByuZyV15VKJd24ccO+7/DwUNevX7emp7VazRgUlCklk0kbBPCGN7xBsVhMX/jCFyyLD1uEHijHx8fWw4isMGyg09NTra6uWg8pyhUpz6T/DgwS9lGSDQWQZKW5R0dHKhQKOj4+tp5jlNZkMhljAJKJpp9VIpHQgw8+qFQqZWWkrVZLe3t71mvn3nvvtcmHNJMeDofGQKWfCMAuPT7IjqODy+Wytre3df/996ter+vRRx/V9PS0NXb1UwiHw6EuXLigV73qVfo7f+fvaGJiQvV6XcvLy/r4xz+ufD6vbDary5cvG6vhxo0b2t7eVqVSsWcnW1+v1023JZNJTU9Pa3FxUblczvaSgQonJycql8um56vVqunARCJhzMwbN24YW0WSMeV2dna0v7+vTCaj2P/rL7a5ualSqaR0Om3s17m5OVWrVb3uda8zHbizs2PsqNPT8+lOqVTKevzAlDg5ObGzRWN4WIXHx8fa2tpS7P/1uqPkJZPJWKP6nZ0dVatVG3U+NTWlZDJpLCkYZtvb2zo5OTHZoFcepVvofN87BYYkwd/09LQODg6srLZWq1n5tbcNNOKnByXlejD07rnnHs3NzalSqVipLkHm9evXVa/X7flgfQ2HQ+vf8sY3vlEbGxtKpVLG6IzFYjo6OtKXvvQlY39QbpNOp1Wv19Vut63vEkyyzc1NDYdDLS8vG9tlf39fly9fVjKZtH449Hmhf9Ps7KzW1ta0vLysw8NDW1/623HPg8HAGB61Ws30Zrfb1WOPPabj42Pl83nrZ0cJ/Pb2tjGk0Ef7+/sj/TPR6+Ml2LAs0+m0zs7O9PDDD+sVr3iFrl27Zr10VldXje1Hc3Aa1vv2AJ1Ox5guk5OTymazarfbymQy+tznPqdXv/rVesMb3mCyS58iegThG7RaLd28eVOPPfbYyNS4UCikYrGoCxcu2AAXXw6cSCTU6/W0u7trrEcGY7zhDW/Q9PS0nnrqKZVKJSUSCW1sbGhra0ubm5vWlHo4HBozp9vtKpfL6VWvepX1s4N1vLq6qlQqpcnJST399NOq1+sKBoPa2dmxsv9Wq6VkMmmMYSZ/BgIB/cVf/IXe+ta3mp8KG35ubs5K1P0k48PDQxUKBSu7g1mKP5jNZjU/P28y+dRTT+nSpUt2Dtg3vofebuFwWCsrK9rY2DB9SGuG7e1tnZ2d6WMf+5he//rXm+9Ks33PEJ+YmNDy8rL1WoJNSrVDoVDQxMSEdnZ2jNFOX8FWq2WMZXz4Xq+nS5cume/Ms8J2+tM//VNjUVGBAEsJWaTp/fLysn7iJ35CwWBQTzzxhJUHJ5NJY3FR2svESBhI+E37+/vWA5HybM720tKSrUWhULCm+sFg0NilU1NTSqVSJk+0DKHs+MqVK7b+lOpHo1E7W/RclWT+KiWK2DxJ+ou/+ItvcBR497p73b2+nusFAaX++T//5xoMBvqu7/ouHR8f69u//ds1PT2tn/mZn9FP/dRPfdWf8+lPf1q/8iu/okcffVQHBwf6wz/8Q73tbW+z3//oj/6o/vN//s8j7/me7/kefeQjH7H/12o1/dRP/ZT+6I/+SMFgUG9/+9v167/+6yMjg7/ai9poSiVQ3BhvjCPKEbos/Rt4PyVZw+HQJiTRhwgaN817oULTbJR/BwIBC46YtkMgB9DinRfACkq5AL8IBHHsGo2GfTZTqQ4PD62+nWejjxXgDHRh/hAk0ryUIBwjhxHzvX6Gw6EZU2j9OKXcn3R7AhrAEvfI6/ieVqtla89aSTLj6jM20MQpBQoEAjY1C2cVoJA1Zn0wgDhLADGhUMgCFvYXp5I+SfRq8qAUr8UgEwjQ8HRyctJAqWazaQAiAA+lOu12W8fHx7YnTL4jO0UfDV7PHwJvGsvTVBRQypd+8X39fl+NRsMAHKZ/0VuEZ+esEDj6sgJ6hrDOvgkqVHFJVtLBlD9kkX4cgFJMfPM09UAgYD3Q2C+e298Tcut7JSFf9F2jVAKHmPUBEAaApJwX+cLhx1FvtVp2LignYWoN/ek4E5IseEVWffBGs1LKq/hugFDOLz+n3NTrE56Vc0UJHnKBrkP2eR3lYr4sx0+Ro8E38kC/E9aKIBx9xFpxVtE3/A6nlOcBJPU6kr1mjb1zjR7je6ampkb6oLCGnDP0FXIiycoCxxuxA5wgs5TjEqgjb4eHh1Z+iiyjuyXZa5Ad9pbzBaAFUIm+Qd6wCQBtrAulwjSwJxBCjin74fxQlsMzUyaFbWA9pqen1Ww2TQdQuoG8UGqD3KHXabDrbaVfc/QPfduk8zIQnpl9pSzWfzf2lfPhG4OzH/T1oXyTgJPEA/YEoIHPBExk7yjXo9zNDyRAnpBD5JTzQINimnnTQB09zb+xryRvsPHsL2cJ8EySAf/IHiVJvjk09+cbUU9PT5uu90ku7As+jJ8shs/jp+OhfymR4jORV3pwkoQZDocmX5Sdev+BNUI/4VvxjJSvkhxCPgGTmT7G2SXJAbDJ+vD93CdnEN+DdeP78Q0AAuiTGQqFzLehBxR7wfciB9wzDELWFL8RVgz+GLLAvzm/6CbstCTbW8rdva3gOfk+r18BpdAVkkzeA4GAAXbIC/4qZxBbh11FV8KIAazodrs2MZW1ROZJnh4fHxt4gm3r9/vWswlfCN2C7GADeFbkFJ+Qs4o/TRKQdcW/Qpf6oUGAJfhrlCZ6f4n7RK9gO308wX4HAoGR3kjYXt8zbzi8PcCFNaKFA+W5+D7cc7d7Pp3S23nsHwkzbBFrO243kSX8Dp4d3xwfgWfp9/u27uh2WorMz8+PyCLPjtyQ5ONv4iaSnNwHsgtIii55qV9fidn4fO+7e929XojrBQGlAoGAfuEXfkE/+7M/q83NTbXbbT3wwANfMxB0dHSkV7ziFfqxH/sx/cAP/MAdX/PmN79Zv/u7v2v/H6cyvvOd79TBwYE+9rGPqdvt6l3vepd+/Md/XB/+8Ie/5ufyWeJarWY16pLM8SCID4fD5tBPTEzonnvusfHWUCZp6ElPEJw+pj6RcYlGo5qZmVGr1bImxgS2TIaanp7WM888MxJYYHjI9lSrVd28edOamL7pTW+ynkH9fl8HBwf61Kc+pWw2az1c6DdAxjyVSplTRU8semL45uBkuWj27AMa+kjhOEmyzCR9Sagdp+dBOp3W/Py8sYh4/+npqZLJpBYXF3Xr1i0NBgNdunRpxDAuLi5aYITDh4NJ3yuYDQShsCww8Iy3pSk0fQqogyfADQaD1m8Apz+VSqlWq1nmiSaxjJpmggrMAdgkGG0/8Y/m0vQRIDAlmIEC3+12dfHiRWswS7NqGrfOzc2pXC5bw9KTkxPFYjHNzs7q+vXr1nMFp8f3gUmn04pEIrp69apyuZwmJyet+ShjvP0e9ft9Pfroo9bTA7CGzyMYW1lZMbbNwcGB9c7AwWPik89OEwwwMYseFYFAQKlUSs1mUy972csUDJ5PuZydnbWGqMlkUplMxuSNPggERrD+cEw578lkUrlcztg/Gxsb1rcIhwnHHJ0XDodVrVZNH6AzmHjGqG+a2U9MTCiXy2lxcdECbUZ1R6NRZTIZm7B0fHysjY0NBYNBY6Ekk0kLtmdmZrS0tKRsNqtAIKDd3V0DJtbW1hSLxVQqlawP17Vr1yy7D3BarVZ1enpqzW0ZAx4Oh62v1vHxsWq1mtLptKTzoIMJe/Rp4szR5FY6d5jz+bxSqZQFXTRgXl5eNhAMFh0BA/fBSPput6vV1VUDMujtBAuGoIbpcLAmAGfINBN4XL58Wb1ez3ob4YAzPQ2mAOzJpaUlZTIZY8gMh8MREL5arZr8MAY8l8vp4OBArVbLMsMAcAT99A2anJxUPp9XMBjUG9/4RvX7fdXrdRvCgF4HAPGgLcxUgibYYn5cPQEfDYA5wycnJ0qn0zZFbmpqyjLg6XTaJjJ1u13L1K+srBi7aWJiwgYOBAIB6yWG7Ukmk8bcmpiY0OXLly0QgpVaLpdNLnzD32w2a2eGtea5k8mkgZwEudiharU60rh5ZWVlZIooYFSpVNJHP/pRvelNb7KeQFNTU8bQ9MMNJBk4Q0BL3z16yYXDYWsk7sFY2KzYAgBMeqmg/2KxmBKJhAEf9PzhvbBj6DFDjylJ1mMxHo+PMKXwXS5dumS9EAEiZmdnlclkJN1uWI9/Q683euf5/jPZbFZra2sGTFWrVQusGWCSyWSMOYOcesYSgxoApZLJpPVle+UrX2kgIbatVCrpgQce0NLSkoFMU1NTZhfp2wWLirPPIA+CfRpk93o9Y9EwJSwajWp1ddXkBP+n3W5bzykArdPTUxWLRWvKPDU1ZYz2b/3WbzVWDT5GIHDemyiVShkLHAYefffwoQAy6HXY7/cNBNnd3TWZAfipVqsGGsG6h40MMAS7FUZ+Op0emVrHXi8sLBjw1Ww2lU6n9dRTT+kVr3iFVlZWdOnSJV2/ft3OXLlcNmAhHA6b/xePx5VIJNTpdPSmN73JWIG5XM6aqfvJdOzz7u6ugXkkb7D5mUxGa2trppdKpZIeffRRra+vKxQK6cKFC9YHdXJy0vwrwPmFhQVjJQYCAbsHdBZsu1qtptPTU6VSKTUaDc3MzIz0cOO8cW7r9bp6vZ6eeOIJra2tWeJleXnZWLHz8/M6Pj7W0dGRsa1JJpGgQ8fS2P7ixYvqdDqmB/EF0XOwqmAVk3xAvkii4LN2Oh3VajUDD0lIAsLjE8IqGwwG1iMX/yAcDttZqdfrdmb9xFBJlvSDQccZ73Q6unz5sjEZYTaSgGEyKvqds8c0RBjMgKcv5esuKHX3erFd31RQ6sd+7Me+qtf9zu/8zlf1ure85S16y1ve8ryvoQThTteVK1f0kY98RJ///Of1mte8RpL0m7/5m3rrW9+qX/3VX1U+n/+q7oMLhewzamQ4PWUUMMKzQ8YzoDjdPhuFYSWIQeH4DAUNN3HCuSccObJzvgQEBwkn2mfjyc7xb/+c/CFjBTWWZ8RI+caC/jnJBnum0Z2ex38O2R4ow/ycLJPPKvs1ZP0AnbgHms369+KAwkbwTA6yuWQuWSteA+uMNR1nfnhKsc98ArzQpJdMPOVNvB66PFRuQCbez/fjeJCZIhijZIx18zLCz7hX1p7n4bVeJmEG+OapvBb5IBPGmlK6xt/8zq8tssTPARFgmLH/kqzRKoE+zCH+EIj7/YUZwHexh0xj4jnGn9uXS7IuZNz8sxLw0CAV+eNZ0BH+zPN5kgyYGz/HnH/OiX8fjp8Ptvx+s96eSeBZnOwre0qw6s86nw+YzGdzvwSLgK6shWdCoXcAA1h75Bi9xmf6M8mzI9sEk16+2ROfDWUv/dnle/mb7wIsYl15D+vCM3Juvf72+gm95GXY61Ovoyg7QQ972QCc8/qVdfKywf9h4rCvrBXPyX35c05WnSw3z+xlxa8V5w39hr3g+dlP7sPvI+uAbLJ2Xs+M63bOPbqTNUVGeA+gAa9D3safx+tvPs+fLb4fEIZ75rlgGgE0cP/+WcftNmU23maM2ybW39s7mC9etpFBf779dCnYJNgMGFjcA+eJ/UMWvb7jtQCS/mwig6yLP68wdpFX9Iw/F8gPMjNu57394N+sHboJFq0/j17HeftKEo999Xras4v8+UGv8N3cn5dbv4c8j3++8X3knHidBXMaRt/4c3Ov/pnYP78W/Aw9jC73uoTPRT/zLDxPMBg0HcfPOd9+H/1+wcTzsgPbGn+Tv/FtuNfT01MDZbkvQA5v+7zuIVnj1wH9hQ71Ns9XBwCYeP8U2UXv8VmsG0mSUChkgDDN5xnS4P0n5NTLodc10u1hGuO+lz/P/p69LAKiot9ZL3SAj0E8gOv9Nr+mfKe/V77f+2E8r7eR+EleTvke5MTLof/+cZ3gZYLkyLgP5hn9+GH48X7tkHfkyJ8bdBj381K+7oJSd68X2/VNBaX+03/6T1pbW9MrX/nKb5rQf+pTnzLWwHd+53fq/e9/v5LJpCTpM5/5jGKxmAFSkvTII48oGAzqc5/7nL7/+7//a/ounEJ6OcAigIVB3xfAhF6vp1gsZpmWs7Mzy4qSZcOw4xhKGqnhZ3wv72PyEYE1DiIGo9lsqlarqdfrjUxlo/fMxsaGMY6Y7INxCAQC+rZv+zZtbW2NgGM8E9lF+r7gpJNd80EwzgjZ3G739gQ1nAYciqmpKctWQaWfmJiw3lcLCwuWYSQgwXHAmCWTSV28eNEyQWSgJyYmjAlG2dfR0ZEx2ii/wumcmZnRYDCwvjf8zNOpYfnAmqDsQ5JNg/Jjj3u9nhYXF3V4eKgrV66oWCwql8vp+PhYzzzzjNbX1226TiaTsWzVwsKC8vm89Zcg0CeQqNVqOjg40Gc/+1ldunTJmCqAAfSogD3os6n02SHrGgqFbGoizDfYdtVq1cAxyjvonXJycqJGo6FIJKKXv/zlVoaJs3V0dKS9vT3df//95hRR9gaLh8AJ5pQkGw/PPcN4abfbqtfrOjk5MVp+IpGQJGUyGevPcu3aNetbQ1kHvdYefPBBC6b8tDzo/kxi6na7NnVOkvWomJ2dVbPZVD6f18WLF63nFqV2OH1MsDs7OxuRE84nzj7ZSBg86C9Yiuwd+7S/v6/Z2VkNh0MVCgVNTk5qZWVFkUhEi4uLNrGQyZLJZFKJREKzs7M2QahYLGpra0sve9nLNDMzY85hIBCwCZoASgQFHmxDJn25LVlKygwkGduNdUY3wgJENgEcG42GTWUsFou2Fmdn52ytmZkZy+pyb0xCJTPPmrP39O/rdDqW5abfDDoIncT0LbL1TOiih1+73TYmAwyFbDY7kqlGdwJqFItFhcNh60lEvzjKsOr1uhYWFmwaIzpycnLSppuROSfZAeuj2+1a7z8YDel0WqlUygLhVuv2ZNd+v28Zdkk2Xa/T6egzn/mM7rvvPmMLomeYGMt+IecEUxMTE0qn01bWdPHixRGmGGvPXhBg0XsrkUjYNFXOInax3+/r6tWrBtSfnJxoa2tLmUzGerZ4gK7X65kOpn8TwWO1WtXc3JwxDgeDgZ0NJkd2u+dTtmBjHB8f65FHHrE+LfSkCYfDKhaLikQi1usIZvDU1JSx9LAv+/v7Zoc42wRyMPRgrXqAgYAb3UEZ2Obmpl772tcayxqmlQeA0HckPlh/GGmnp6eqVCqmt2FBc3GusReUcQJKw2QgqEVfRiIRnZ2dKZFIKJlMWrnY7u6uBoOB+USSLNGCLel2z8fVMy2P0j4Y0vQ5gz1CeRQMF2wKctdqtWwdYE6jT1inQCBg/eAohe33+8Yogg2ytLRk946fAssEFqD3yfb29vTEE0/o2rVrevWrX62nnnrK5Byd3u/3tbGxoXK5rFgsZn0mKRMuFAra2dnR7u6uMRRh2YdC5z1HAXAA7WHWU6ZFgI+/Q7kZe5bP582PGgzOp6I+9NBDVp5KnzlY+zBk6D1UrVY1Pz+vnZ0dzc/PK5PJmF4PBAJ67LHHtLa2ZqxefBCmUWMDYd/AVMM3oDwSYAR7DGuT84Z/tLa2psFgYH2cXv7yl9vzega779GIn4R8VKtVez3+JGvI9GSYWuhL2MIk8bBryDe92AaDwQiDEjAIm+ZL1gaDgWq1mqTzaoKVlRV1Oh0Vi0WrmMBH96xA+j355FMsFrOepMhoOBzW008/bXb18PDQzizPhA7xSXLsyWAwULFYNJ3CPsKOSqfT9vPZ2VmVSiUFAgFjfmFjmW7NumPHJdm+FotF00Uw5AGrMpnMSLkez/xSv+6CUnevF9v1TQWlfuInfkL//b//d928eVPvete79I/+0T+ygPFv4nrzm9+sH/iBH9D6+rquX7+uf/Ev/oXe8pa36DOf+YxCofMx21DPuSYmJpRIJFQoFJ7zc31GWZLRQHFicCw9mwkl7rM6ZCX4uXeCfA06l2cbeQXrMxLjysRnN/0f7o/fY1QljWSbfcDpX4tB4DtxoAiOeB7ui/fyveMZat7HZ/jn8d9NIEx/Hj5znFVDsAGg5DMlnkVypzIaT4327DG/lj6DBCUaA+2fgew+z4kDQl8BngfnhKwc9+OZVjwngYBnQeBUY+Ap8ST76DPryI5/Pp8dY028jPh9Ze9wsn3Wl5IsMlo0VcWp53P4M56B95lz/3svH76nCIExgIPPVkoaOVv+bBDMUb7gWQ6cA89SGD9TgCqcddaTPcJZ9XuGYw/Ag1Pt15r3+PPtM/n+jI+fZ0AFgE7PNOKeWA+vp8blgefAgWQfCAw5d36fxu/NX+gSvxfsAWs+rqf8mfbsB3SjZ2NxFsa/n/d7thJ7gRzf6YLx4HWYf1bPluPekAu+k+flPHv5RX/48jnYJnw25xTdIN0euz2uU/1ncy+UXbEOnpnq14K99/YGnTS+Fx4I8jrbs9L8/vJeno0LnYbuQD/716BTeCbkdXwPhsOhJQr4DPaLz4WJRuA0rj8AtPk+5MXrZe4JIITvk0Z7qIyvib9f/8efH9aCdWHN7qR3x9fAnwd/hsbvGVkd33uvk5EFf94pF/X37uXhuew9v/fghr/G9xybOL5/gG/IL+eGRBssQn9Gx30w72P5z/fyyHeP6xC/Hryfc8X+ejvvdRX22ScIvY4DWKBE3esdzxqTZCAfn+9ZMOP+5rgf4/URMu19MO7b+2N8D/qL8+L9PD7T6zWvM7yf4+XUs5Lwn3it9714Ji9X0jkYCqgryUplvU/KegJKIcfYfc9eQ996hinrwO+8z+3vxTOt/BreyX/ifd528H7P6kWuABbHL54B2fYsIy/b/H78HvkOr088Y5Kfsc+sn9/Tcf/EnxPv02ADkTm+x+th9gOf1cvYneSL5/SsynG942Xa38u4nrh73b3uXn+7rm8qKPVbv/Vb+nf/7t/pD/7gD/Q7v/M7+vmf/3n9vb/39/Tud79b3/3d3z2i6L4R1w/+4A/avx966CG9/OUv18WLF/WpT31K3/Vd3/XX/tx/82/+jX7pl37pWT8fDAZWG356emoZn1AoNNIj4uzsTDs7O8aUWFpaMhp5qVTSxsaGZauY4EITQAK8Xq9n2Yd6vW7MF4JP75yhlL3BCgQCxiSanJxUvV63mn0/zQdGEUZckk3cw8gPh0OjaDMhEENDZoZsbSAQGGnsDRsF2jHBunTbyEFHPj4+Vjqdtj4i99xzjyQZKwdnDUo8zDCyL6VSSdVqVZlMRtevX1cgELAMyv7+vgaDgdW8895u97zPCo6jdG7s6RlGE0YaP8bjcXU655OVOp2OEomEPTv9c8jcUT8PYIQ8TE1N6emnn1a73VY4HLbGwExbqdVqRtmnESV9Zebn57W6uqp8Pq/T01Pt7OxocXFRzzzzjIEg7XbbWD1k0lqtlorFokKhkE0ipBcGDBIcS+SRzFqv17PeGIFAQK95zWt0fHxs05f29/f1tre9zXpyjdPDWWMcMd/QGTmBDXV8fGx9tZrNpm7evGl9NgApfFPbwWBgDEX2d2JiQktLS+p0OpbtvnHjhhYXF60vGxnjs7Mzy7jS74w+B+l0WtVqVZKsLwSft7q6auyjXu98MmS5XLZMaSAQ0AMPPGAOfygUUrPZNEYGPYqmpqa0v7+vbve8iawvReCMwLpaW1vTtWvXlMvl7Dy3221du3ZNr33ta7W0tGRTfGh+T58y+n6VSiVVKhUFg0F967d+q+bn51UsFi37+elPf1pra2smMwSHXLAH0U2Tk5NaXl7W/v6+rZ10HmT5aT4wo3zA55sCn5yc6OrVq3rggQfUbrd1cHBgvV42NjZUKpVMD/geF+12W7VazZzier1uZZAeJIblEgqFFI1GnzUEAD0pyfpU0UOM/QT84yzPzc3ZdDky9ZSwNBoN6xU1Pz9vgcP8/LwikYj1xWBKUa/Xs94osIjQj/T042zGYjHdf//9NnHo+PhYV65cUTab1crKigE1g8E545OeG2TJ6d8EoI2szc3N6ZlnnjE2BL+bn5+3Kap8Fuzaubk5HRwcWHBLv5ibN29aT5rd3V3TkejGs7Mz1Wo1LS4uWu8s7ARNcAlmYSXRQwg9sb+/byyls7MzbW9vG1MD1hCM2ieffNKmT1LqGI1Glc1mjQ3Zbrd1/fp1PfbYY1pfX1ehUFAymdTNmzeVz+etn8xgMLCpU7CB6YGDniOZADOPqYHFYtH6nfT7fQOGkTMfnKGT6H8IO6fX6ymXy5kNvn79utLptMkIbE16EJJkg4GH3s3lcsrn8+r1eibPHsSE/ez9msFgYKBmOBy289ZsNpXL5QyAKxQK1geG/nQMNUC/Yq+73fPmzEwthqkdjUb1hS98Qa985SuN7QXjjbNEs3qm/eGL+KSi712IDsNn8iAGPlA0GtXk5KQSiYQ9eyqVsvVnqmW9XrfvRgf4JOPs7Kz1Em21WlpcXLTkTqlU0uHhoRKJhFZXV0cmwB0dHalcLuvWrVvWj4k+mJJUKpU0GAxMdgBeYDANh7cZtOOgq/cPT05OtLGxYWuyt7dnU3GZVopc+qb5PGM0GlW321UymbQzuL+/b4ysGzduKBAI6GUve5l9J+AbgwYymYwl6bCtX/ziF/Xyl79c09PT5uNgC6LRqCWncrmcNjY2jL3N2Tk5OVGlUjHfY2FhwXqA/uVf/qX1sYJJi98N2xYARZL29vasnx1sa6YY9vt966UJwAXjB12wu7trU7Gx2Uwc/fKXv6y1tTUlk0nrMYW9bjabqlQq1uOv0+kYA4yBIDBH9/b2zL6jN+lB64cGwR4iLsAHvOeee0zHci8wjc/OzmzgTyBwzn6H0Ym/Nzc3p263a/5ltVrV+vq6+QO9Xk/7+/ume7GTvd75lGWfUCD26XQ6NjXy4ODAmNusE0kZzjk+FQNc6GP4Ur88KPe1vu/udfd6Ia7gV37JN/aanp7WO97xDn3sYx/TU089pQcffFA/+ZM/qQsXLphR/Zu6GHW8ubkpSVpcXFSpVBp5Ta/XM2f4ua6f//mfN+XWbDa1s7MjSZZVoNeGz7p6hJ4MDlkkAKTxjJ5nGPA3f7xzM95Hg5/5TDkGkZ95lgxBLkE3AQ+gUbvdtpHulD/4zOJ41p2fwUR6riyjfyb/c//HZ/v8z/w9sH5ksenR4LMwlN9htFh7Mkh+kh3Bqs8g+6yNZ+GwXwArfIckK0uiQSYlBgBTXH5/YTpRluUbP48zNvhenGnKLQAD+Uzk6k5ZI2TAl4mxD96ZGmd8eWYCso7ceWYOAAWgIXvh+z6wX+OZxEDgdq8hv97j2V/fl8BnLD37YzxLPp659plBzoxfK5x3ACT2+E7nkfePM9FYZ/aUtRzPOnsd4NfRy4r/Pdn0yclJhcNhc/p5L4Ad7/Pn2E+t8X0mAOK4F6YGAjr7rC6f4/uB+JIEdIvXEZxffj/+XKyFz2hLt/vqIFOcC/7P+3w/Fp+59WxQf97H2RLcm99X5ABQxK8pF+d3enragDnu2wPmfjqfZwz5JIIk2yfW3J9jrwf9mUa/+dJTAjWAf69veBavT7knrwd8CRkgCIMceEbPaOJ5vG736+v18Pj54Qydnp5amRzrh97wjE32hD+emcHr0UGAgiQuYFJxRmEIYRPQswBenqUxGAxsDefn522txwNR1micUYSNRP79+RmX0XE59D/3TAfP/pBktuZOdva5vsfrS3SCT3R51oyXK77Tn3X0h5dt3g9j3L/efyZT43zfKL8vvvQOlgu/xx9D94yvF+vgdb7XEV4O/Z55nQGwg/x0Oh1rtsx++ufxto+zgT3w3+N1+rifwbrwGg+m+T1CrscZPt52jjOmWLM7BaWcU5+E8DLkbS7Phh3xw2u8Tff+lf/OYDBoNtLvlyRrneD7A/n7m5mZUSwWG9FV/jsA5PEX/O/Q1/58jZ+Pcd/Ug13oE5JpJFMB673e8uuDDLBOgLX8nz88C6+h7M3rHcBmdDPy7BlcPIdn4Pnf+TXgs72d8J/FGfCfxzn2tmTct/TxCffJOnjbi57gnj3TCt0iaeTnXP7scEbxK3nfS/nybLGv9c/d6+71QlwvyPQ9rnHF/jd97e7uqlqtKpfLSZJe//rXq9Fo6NFHH9WrX/1qSdInPvEJDQYDve51r3vOzyHgGL/ILMAkoQSQaUs0IGa6EmVXtVpN5XLZWEK7u7uSZON1aVqJA+tZJT7jT2afTD3jW5moQt+qo6Mjm7jG8ySTSZskMhic16nTL2h3d1df/OIX9brXvc4MFhkSHCkcQgwIbAbpPHNH9jwSiYzUtpNt48KZwvjg3JBBjkQiljUhg8oUIrJ5vd75BKtIJKJqtapbt27ZZ5GNxvlrNBqq1WqW4SabyrpS8hIOh63/wv7+vhlrxmfX63UtLy9bkHJ8fKxcLmf0fLJuHtgiOKUJaK/X0+TkpGKxmJaXl3X16lVlMhnrZVIsFtVut61vBQF5LBbTcDhUpVLRo48+qve85z2WFaOfDAwi74CUy2Xt7e2ZI0fPAN9wFaew1+tZdo5MM9MWA4Hzkc/9fl+pVErb29sGpDF96OzszPp9wEJhxO+XvvQlrays2HPiLB4dHenGjRs22ZDMPL146BGCwyeNlihw77OzswbWhUIhy9YiP2SOcXq4RyaU+fKcRqNhGUBK2QjcTk5OLFNZr9cN6Eomk9re3lan0xkBG0ulkjFB6H+F08QzNZtNTU5O6uTkxBgRAH8LCwsm36urqwqHw7p48aLJ+c7OjhYWFvSGN7zB9A/MiUgkokwmYw7+3t6eDg4OLJuZSCRsMle1WrX353I56wd3dHQ0EvRJsvXy03ZgtzWbTc3NzanXuz3BC50VDocVCoWsES2OI1lo2C8wYuLxuLFrmBJJWRWTRGGCwb5gMiDyTBIEncp9kw2H1dHr9UbGnAeDQWN1oT8AQpiWGA6HjbmK3mg0GiqXyyqVStbnjt4alUpFt27dsj5UTPe6ceOG9Zhh/9BdAGA8C/2cYLWFw2EtLi4aiHD9+nWzTc1m03QwDJNer2csk5mZGVUqFW1sbBjbKpFIWF+nYPB8QhN2kJHtZO+73a5u3bpl55ng3E9P5XsAERlPTmnmcDjU5uamms2mVldXzQ4mk0lFo1Fjj3gWI6wz2BCVSsV0Uyh03mPn6tWrNr1xbm7OpsQeHh5akMf6ceYrlYr29vasP9HBwYFNFASgg51Eny7WgT54nGmfoCkUClaCyjRc9guGFPvNe2FMYmslmZ8QjUYt4IbxiC9AcMYod/9dHvBDPxPcbm9vG5uHUkBAAXoGwpYJBAJKJpM2zODk5ETValXRaFTFYtH0OMxJmFTRaFRnZ2c2SW84PO8ft729rUKhYGwLJj0ysW9lZcX0+M7Ojk0b7nbPe6nR15PyzKOjIzWbTWP24E8ge+MAXrd73nsP8AY9EQyelzKnUimTEcCmL33pS8ZWHg6HKhaL1u8GcI4kmR/6UKlUNBgMbM0vXLig6elp07P0TKT/FrYB5tutW7fMn8SPwkY2m03rd0jiLhA4ZxvjpyE3MIYBrT2wdXp6qnK5bAxgX2JLjyum3tJHjz6X7XZbTz75pKTz/o6Hh4f2GYFAwPrpUYbONDX2Ht2VzWa1u7urfr+vWCymer1ufna321UqldLq6qoBOj7Benh4qGeeecaYybDcPFCIrKD7fYNtEgTYf2zN5OSktre3rf8REz+vXLliPm4kErGJotgW+nvh+9GLamFhQS9/+cuNMYnPOBwObRI3bFWAwX7/fIIrkzPZE+wXzHuAHOQYBjH91qamplSv1w20BKSkxxZ2meSWHyLDeh8eHtrU1+npaVUqlREQu16va2JiwuwV7CueBd8JmTo6OtLi4qIxYJlwWqlUTKYPDg6USCRsci2+IImpo6MjHRwcWIz1tQ6yejFef12A6S4odfd6oa5vOih1enpq5Xv/9//+X33v936vPvjBD+rNb37zHbOlz3e1221jPUnSzZs39aUvfclK0H7pl35Jb3/727W4uKjr16/rn/2zf6ZLly7pe77neyRJ999/v9785jfrPe95jz70oQ+p2+3qve99r37wB3/wr6WwGB/ra5xhF/hMgmcNEMgQhECH5vN8AEKJxdTUlDmVrBkGg6APg47D32g0LOAiY+PBIAJeSeY4UR5G8O2nccEYkUZ73GAkAXL6/b4BXb7EEAcWAw9ARc8nDBMZMxxMHA2+A6fRl20Q/PR6PWsWyXqT8eECMKEha6vVMpo24BdBh2cY8N2SzKmiVIPf+Qw+2R/WiYCC7CnZO88coryBbCnNPX3mD6OLgzA3N6darWaG3k819NlGgjQa2eN4+ICJMhq+m7Um2CL7BYiCnFL2QxDd7/cNzMK5A9SiDxVgDOChz2j7zLjP4kmyfjLjWXDPCvAGlmAAWeC1gKWeFUZJR7PZtCCNEkz2MxA4p6wz9nh+fl6dTsecycHgvDk6QARrgEx1Oh2Vy+VnUekJEMezogQ2OLV+ypLPiPPefv+8WTaAYCgUMuDg9PRUtVrNaPS1Ws1KCHwfl2q1av9HrxGwjjM7kC2AWZwiytd81pSSHUn2fN7JRl8MBgNbe77XN65FH6BXKbVAdvz3EdiiOwFGAAthXTE4gn1iLTmL6HjuwbPHAIDRpfwMZg7fjYMuydiafA/6GZYBMu+Zd2TOAcyQC5x7Sruq1aqV4bZaLWMseGYL945uJONOX5NSqTTCvAgGg2q1WiMsKYJf2C/IOvfKv5ELnpN9ork1e0pATFmuT4Jgm8jeo1cI3GGTjE9XQxaQH3QNmXqekUQHnw0g41my3k6N95jz7EB/kUjgNZxPhgLQUPnw8NDAJ8AkX97uyxzRO9hv37+J9fOMPF/qwlnBBsAiwzbPzMyoWq3qxo0blvAiWEfWKHP2sowu8CXi6CSCVoY79HrnTdfRP+h5yo/8eWAdPCMPsMizRXyik2dh/2FVAwLwc2weZwF7CggHAOgHMMCMIijHvqAD8L/QGb61AT4P55Dv9gm7g4MDk0OASQaW4LMBpiBXnp3KOQVYQW95piLnDl8DmzXOysTu4zOw1uhRwFdsGUNVOCP4nbVaTYPBwFpUYMs8u9sz0wDdSMxQ3sm5o+yTJAQDIbw8IKvHx8eqVCpW3oaMMISBdcIf4UwDvqJXYMNSHoq9Ayj0rDj2F/3rkyyA6vze91AjaekZbbwOgIq/WU/PdGFNODeeMcRzc24ozeW5KpWKrQe+Fffl3wtL1NtgzhsyjR3vdDoKh8O2/thTZBFby+ciC9gq7Cf34+0uIL5nCnp/iH9zP5FIxL7jpXzdBaXuXi+2KzD8JkrfT/7kT+r3fu/3tLKyoh/7sR/TO9/5TqVSqb/2533qU5/S3/27f/dZP/+RH/kR/fZv/7be9ra36Ytf/KJlRb/7u79bv/zLv6xsNmuvrdVqeu9736s/+qM/UjAY1Nvf/nb9xm/8hjkrX83VarUs4+ENmQdpMB4elALcganiHRpKVAgKcLw8nRgDimHA+GAMYAxRh06PHRxZDPZgMLD+Vx7k6HQ6ajablk0ko4Mz47Pb3hGSZEYMpYgTC/jjAwIP8PiyOYJRT7vFeLJu8/PzI/Rrfx84Co1Gw5xksl0Yf5ww7ss79Hzn5OSk9dQgUPLlAbBXPMBG4OaBIEkj6+FBG0APH+T5sjSejcAUx5/nRVbOzs4nnwGs4Rx5J57sFsEdzjIOLnJBHyvAnWg0auvN58EAw1HyfWNwyILBoGUAcRwpdWDvAA+QHZ4RR5qeAL7fB84wk9I4G8gRe4UTRSYPhiGfgTz7rB/yHYlErF8F/TQkGavLB2DIRS6XswyxL6vlDPugGwcYh5XnB+REDvgMAppAIGBsEYAW74h7fQM7AT0iyQBPzt7R0ZFN71tYWLC+boBUBDOlUsmAbT6X+/IObygUUj6fH5nGVi6XrbSQQA2gy58fnyn1ACKywJQ+dJkHCCnp4Fx5fcK6sKZ8H+CPByx53lAoZGcfMAfwDHYqMkDPF99k3AfUrJOXcUnWiwaHWzrv3+TLPTxTg89BH2azWQuo+WySF8g1IDDsFXSzB9I4H8g39zE5OWl98+i/M66nfEmdJLMN0Wh05HWcMe4Bph7nwCdzkFnPTkBmAOgJqvidl0UAEw8E8zvPnIVBMjExYeCQD3bQY/zxwYwv10dmPUADKIFORa7QTXwemf/BYGBAO/vDvrM+HqRnvTmvMPhqtZpSqZSdR38meCaelZKqmZkZJZPJZwG6fDaMom63a8klfueZhQB+PDfniGfHnyB4BZCGTcP6oNfQdzCX0JucFR/YsuasFc/P+fOTGH1ZfLvdNr8MG4AdQWZ8EpHkFueBJBg6h/ODnfBnm33F7mIT2M+ZmRkDJ+mfiT3yMuSTczwD5+ro6EjJZNL0+WAwsH1mLfCt0GHowmg0av4QOtMznwE6WA+ufr9vUy1ZL4B2ziayx3RJAEb0Dv7xeFJqPFHGWnBOfbk0OtLbXUBRJlmTdPCyg1/APrCXvqQM4IaEFeARfru3gxMTE8ZOx/fmd6FQyNYZecYf5j4AoLgf5MaXqbFOw+HQbJQfoIJvSULZrzX3w/ng+ycmzntu4mtgn3g/azfe54n982eRnyN3sN7oseb7NrLv6H70QCQSsc/wSR18EL+H+AreZ/ZrgU5iPRuNhprNphYWFvRSuohJ3/ve996xqucrXaenp/rgBz/4klybu9ff7uubChV/6EMf0urqqjY2NvRnf/Zn+rM/+7M7vu4P/uAPvqrPe9Ob3vS8iO5HP/rRr/gZiURCH/7wh7+q7/tKF+PJJRnVHkQew8+o4uFwaGVkU1NTyuVyqlQq1oyv1WoplUrZeHfYSgT4ExPnDc4pS8lkMpYhPjo6sibcr371q5XP57W+vq50Om20fj6XDNJDDz00MkJ5d3dX+/v7evzxx3Xffffp1q1byufz1tCcbMq1a9fMUFN6Jp07c8Vi0ZQ/ZWHpdNqMHYAb2TwMK1ReylAkqdlsKhQKaW1tzRzJyclJ3XPPPSNgDUY+FospEono5s2b+sIXvmBg1t7enhYWFrS/v69SqWSNXpeXl9XrnTekxqk5PDzUxMSE4vG4lpeXtb6+rkgkYky0YDBo48pnZ2etyaVv8oxRlDTiIB8eHmpnZ8dKCW7cuKF0Oq1oNGpZSRrKN5tNY3BQRkiDZILPVCqlnZ0d1et1vfa1r9XKyooSiYSKxaLK5bIxJcg2xuNxnZ6e6saNG6pWq9ZQuVgsWqC4ublpZVzD4VCvfOUrbb0p31paWtLU1JQODg7MgGUyGWuQzaj0e++9V7u7u9aI+/j4WHt7e7Z3qVTKQCoYNDjZ5XJZ6XTaGnh7sHA4HGpvb0/Ly8sGHgYCAc3OzioSiZizjgzNzMxoZ2fHgmrf0Pno6EgLCwtWClWpVPSyl71Mr3rVq1SpVPTZz37WmJmJRELNZlOHh4f2nThW3/M936MHH3zQSmYJKGAqUgLFSObDw0MVCgU9/vjjdnaCwaCefvppyzgTbHvq+8MPP6yHH35YjUZDe3t7ymazSqfTRmenZAAZAegIBALK5/NaXFzU5OR5A9TNzU1tbm5qZmZGDz30kHK5nEKhkD73uc9Z49XT01N99KMfVTQa1c7OjgUCgNi+zGF2dlZve9vblM1mdeXKFd28eVOf+MQnFIvFtLS0pHK5rMnJSe3v7xvQRGNv5I9R7wA+nImVlRUDtmguD1harVbV7/etpOj/x967xkiaXvd9/6q+d1V13av6Pt1z3fsuRXLXEkVaYmiLpGWJNGXZMkNBpAA5CKxEiT4FiOMACRwkdmBL/pA4BuzEgGQjQUAhDhIatiWLlJaX5S7JvczsXPte91tXV3V3dXVV5UPnd+ZUsWd3Sa4lct0vMJiZ7qr3fd7nOc95zvmf/zmHfd/rnaXEkZJJWjPrnUwmLRVgbGzM0punp6c1Pz+vK1euaHp62gqyYlRvb29ba/HV1VXNzc0pkUiYs076rE9VwaEgOk9aQqVSMQNyfX1dm5ubpuN9ShVyMDY2pvX1dX384x/X9PS00um0GeXz8/NWsBz52tzc1GAw0NbWlkqlkjmiktRoNFSv180ZRU+vr68rkUhoYWFBu7u7un79ur0nbBaK+FcqFWOh1Wo13b17V+973/tMn5ESHo/Htbu7q2KxqKWlJUt1I20YoIk6TRQGpvlGsVjU5cuXNT8/r6mpKaXT6aEmAKTqcD7duXNHnU5HoVDIwDPkIJFIWIrw3Nycrl27ZqCyJKunSNHqer1udYwCgYAFAABRkFEaIJASiRNbLpcN7CatZnZ2VslkUsViUUdHR8pkMkM1h1h30orm5ubMJmC+5+fnTR6mp6f1x3/8x/rQhz6kXq9nQA+M4larpWKxqLW1NWWzWeVyOVUqFS0vL+sjH/mIFhcXNTZ21vDi+PhYS0tLCgQCevDgge7fv69Go6ErV65oMBhYKYR6vW7pj5lMRt1uV/V6XTMzM+p0OpqdnbUSBY899pi2traMqZRKpbS0tKR2u63bt28bo4I0NZhbU1NTNl/oUg+iA1R4ZttgMDAgpdvtmtw3Gg1L9el0Orp3756lPMXj8aEC9YBK7C3S59PptK5du6ZLly7ptddesxTKqakpZTIZ9ftnLe9pIIHNAHhXrVYtGEhx7U6no0wmo0qlonQ6rY985CNmb5CGj26CHYftc+vWLeVyOeVyOd2/f1/vf//7NTs7q6eeespYV5VKxZhtpB5ubGxYaler1dKzzz6rtbU19ftnjRAODg4sAMI5QXDGA7SdTkdLS0v68R//cTujU6mU2a3IYqlU0tLSktlg/gwlCMTZPjY2ZiDXxMSEstmsarWaqtWqTk9PTQ/Nz88rm80qHA4P1ecCjIKZVygUlEgktLW1pZOTE8ViMWN3Y48AqB8dHZkdwZlNsGV5eVm9Xk+7u7t68OCBpqenzTYBSIpEIrp165bC4bDZ3pyRMzMzevbZZ3X58mUr+UFB9Z2dHQNdKEcBqwyg6/T01GqAAi6tr69rZmZGCwsLBnQdHR1pc3PTisqzRwkawx5DH46NnaW0/pW/8leMBZjNZo1B2mw2LS17Y2PDnk3qMQ0bYHAfHBwoGAya3KXTaTWbTT3zzDPKZDLa2NiwEhY0EMBeATh/4okn7Gwvl8sGhu/u7pp9jj7EVsBm9kFVypGEQiFj0L788svfv8N3cV1cF9e7fv2JglK//Mu//F3MkffS5dMUfGTAU+8lDdUWIGKH4wHKT4SD6AGODICJZ85ghPtIoKdGE50iesMhiYND9JHPAYrhlOEAEdUi6kL6BtEwImHSw6KKRPxGU90wFjhYOThgbnCojUauGo3GUCQNJ8+nOPj35pAliuLTHPg+xhIXKQNEjoiwcYC3Wi0z3FkTH43xLDA/H4wJZsrh4aEKhYKx0oi2+ro7RM0lWX0qUi54j16vZ0BFMpm0dYUxR70emFg4ULBMMO6hm/N7SWZsMEbAQt6LeaI2DMYU0ThSM3w9FaKLPAcnm8gXKWNEhIkeMmekNo6yXGB08DeACeArMgzo5FmLnpXgI2msJamWRG29rPs9yfeQf/aUp8Z7BhWODn98xA/AzLMkYHUh75IsNY2IKPdnT+FQYaTC0gCQBlCYmjrrCMk7kkbCePxcwhBBLtA/GMnMCTJMrSWfhoL+g50AEwmwhHv4vQ0zjr2FPML8BBRjvbg3zALmzK+7JKuT5vUt+5Z94Wtn+Pp9koylxrPQGQcHBxYsYD8gq0SCj46OLG2J9UIn+z3H3kHnoI9Id6hWq5qdndXMzIyq1epQOiqgH3od+fTRe+aEdAm/LyYmJpRKpSz1yzPsGo2GqtWq1d7hPWHr+tQmdC7MFNg3jANmpddJtVrNaqbBamVPsj8AIH361tjYWXpyIpEY6izFPoY1m0gkDAwFvABkrVarBgyiG9ClntUHK4sxsed8+rjXF/58wYnlM6OMKvYtIBXrw9xyP0m2Z8PhsE5PT61+JIAL3xllUHqWGfuDvcu+os4M5wnjAXD3bEACA+gIwFZ00tzcnOkCUvw8286nBXqdDGOOlCBkhb3KvCJvrA06wjO9cbI5c/05zTjRI+hp9i9gYb1e1+LiotXG4bxDL3sQCnkGUGOvAzBxbxiQHiDB7vDzwb4kiAdIOTExYQwrnx7oQRH2CGc2e9Yz7j3DEpkABGWvsm/5PnsdfUyKIcAUegN5Rl54Bowir3eYF9LcOO+QgYmJCQtmcm7BamT+6DbL85FVdBlpdehl5Nen6GK7SsPNgwDLATrYz9QC8/ZDt9u1c6LX61nHYl+TDeYp54ifH7p28m6w0klNH02t9XYyNgXvTqDcM0e9DcI6Y1egYwhce8YxLHZkHTvS2y0wALEbWWcvn5wJdFD2DNiDgwPzRXyAh/OUn8G2Yt49SImNwXPf65e3cb7X711cF9efxvUnCkr9r//r//on+bg/8QtjFePbU0W9EoVhwO+grh8eHlq6A8qTqCzRRg54HEvSMag10Ww2NT4+bnUqfNoOqTPRaFQLCwtDKSZQ4ymOTq0XIuZQwBkLUctEIqFIJDJEu+dAo0hnKBSyYpSS7ODvdruKRCIKh8N2mMCIgD1B4VqMc5g31Dvx6V8cpoyTKOqlS5dUKpXM2APU8Kkq1CGAiu8PfAxd1rRarerKlSvm6M3Ozg51fhpN3/EOlK8hdXR0pO3tbR0eHprDSIFQauhgLEMj9/fGuavVasrn81pYWFAmk1EikTCHKZVK2fwC7HS7Xd25c0fSWWQLmaRegE93ajabQ1FAjIOZmRmbw/HxcUuJrdVqFi1m/hKJhBnUpDMcHx9bO3RPAQcEJE3MywBgw8nJiXXWOT09axuMY5FOpy11DgON5/V6D2tb9fv9oW5Z/CFai+PgUzyIonva/+zs7JBDgTwBjEkPGyCwFtzXA5qRSMRqJrXb7SHHAscAIx6HBWNwMBgokUioXq+bIRqLxQzMwRgHlMPZpB5RPp9XPp/X1atXtba2ZtFtxg3L6OTkRIuLiyqVSsYKzeVyQ/uFP7wL712pVLS6umrMUAxoScZsnJ2dNbYNjReYY/YSIC17XHqYCocRi57FOI9EIgYY8u44pQCXzC/34N4+XQ5HHeAGx2RmZkbpdFqJRMIYWycnZ7VO2De8N04HZwU1CGu1mqVOYbjPzc0ZkIGDRtF4XyQ6HA4rEono9u3bmp+fVzgcVrlcVigUUjQaNaARBx3djPOFo8TZ1W63h+aHwt/Ly8tWAJzzAmZQqVQyoJnxptNpA9Y4q3wqWCaTMaaoDxYA4EYiER0cHOjOnTsmk/1+31JLAGuOj49t77O/gsGzpho0m2AtOCuz2awxLeLxuDEK9/f3TW/s7+8rl8vp4ODAwGS6qFJbDj0M2I2O9PqTeyO/HgCiAQD7xhesRxZhWpMGBNOL88AHFtgby8vLNs+woDgTAK0oxs/5TUovLE50LOl25XJZ0WjUvofsUUw5GAyaXhkfH9fc3Jy63a7y+bzGx8ct5Q/2yfj4uPL5vJ1LABHYNj7FinOPUgS9Xs90EHt9NCDEv7kITJASNDU1ZcXX4/G47UsCWbAzOp2OMaA9IA6YHAgEzH7gvCMlMRKJqFKpmD4EJOJ8AJT06Vh060XXkH7q7TzWCjn0oEcsFlMqlTJABN3POevPJ85BbNV4PG66CdsFMI9GOego3xSCsftACPIM+wXglz1D6ibAPOPztgOMQrIM2IOSrDkLdhKMbt88BiYntZ44S7Cj4/G4er2esZ2onQn4yh4EvIK9iZzDjvZFw5kbzjFsY0CbaDSqRCJh+gGA3Ac50DnsK9YHQIraVtjPvjYaABnNKZjzQCCgRCJhzUM4Z9ALyAQ6FPa4txvT6bTi8bjVhcIvYa05Q9F/nBOcdT6gSEkGgtvY/5VKxZqZnJ6eGqBOzSw+6wkOvANBN9hn3gebmJhQNBq1xiQEvt/L1wUodXH9qF3v/Upvf4IXUVhfwwAauI9IYGwRLaL4LP/mgCIyjnPpo+QwpHDAeK5XJqenp5YCsrW1pfv3738XM0R6WOMAw4eCjdx3lPFDBxjf0WaUlSDJQBi6HzFH/v1gz+BMe8cJmj3zSWSFKEe327VOKjwX425ra8uKTwP2eGfAdzpiDnB0+Zk3bin8SKrhN7/5zSFGDsauL0zu74vRzN8ASnt7e3ZoY9gVCoWhiL803MKXexNRpugv6Q4+5QkHi2cTKSWVAuOaqBbGoTfmAf+2trbM2OIdAUoxRr3hzDzncjlzYGHykHbK8yqVypDBT7om+4d3RXaIjhG1JupI3SIAR5xXWAPtdtsYDZ6l4RlBGFJHR0e6ffu2dXikO5JnhPk0Aebs29/+tnK5nKWOtdttTU2ddcAkhQMAzMtCLpez6DiAEVFyov6eHXHv3r2hotJHR0fa3d01ZxL5Awz0BuDNmzetrkexWLQum/F43OQH+j7PJZUS41B6WNSW90fWer2evv71r+vevXuWvsL84Zz5KDv3QTdSBw4wRpI9l+inJDOWPRPBpxJKMqfP6zB0pWc4SDI96hk/7FOcG6K4yDFyvru7a/Pe6/VsTZAZIrw+esvfjUZDrVbL9gTOR6VSsTXkbw/GVKtV/f7v/76mpqZULpcViUQsPYFuecx3s9lUrVZToVCw+yGD6Fwi48h2o9FQOBzWd77zHXMsqEWGbmVeRuvmeDCT+7K/CoWCpZPBXMKZ496Abqenp9ra2rIaJgCxnsWLswjIzPmDzkFvkXaMHgCAwznmuexvihujd5FfnFLWGjlBtqgzw97w7IZRVu1gMFCtVjMnkWcif5zxOLb+XMLOoGsszj6gKB1OSQPCoe31etrb2xv6zGAw0De+8Q3dvXvXAliAuCcnJ7p169YQ2/P09FSxWMxqTwI4ce6gl8vlsgEag8FAb7zxhv2ehhA41RSzDwaDNg+AScgOewaAgTmEnY6thNwh3/xBzglweDa2Z+kA2Hr7inVmro+Pj/Xiiy9qb2/PQArA2fHxcWs8AiBOzSdAH9aYc47AIO9Kqpy3IXxgErltNpva2NgwsBJ7hLlARrjXYDCwTpv7+/vGUoZV5Ds0skfy+byBdLwHcuBtEoAsD4ICQgD0AcbD7mKey+Wytra2hmpFsVacnwQFAJk8+5g5BKBDB8Dc4r7M8c2bNzUYDOzsRf/6III/rycnJ/Xqq68qEokYa5FncXYxd4BbnL/II+nIlOEgqIUMeiY54wSk9naA9BDA8/v1zp079u6zs7NqNBrK5XIG+gAAw75C32JDtdtt/cEf/IGduf5cDIfDBnRzdhLoYmzYDpT6QCbQed1uV9vb25YOzTPQx3yPvfDiiy9qMDgr0wBIHQgETOc1Gg3TUbBAAe97vd5Q5gDnEIDae/26AKUurh+16wKUepcvjJXBYKBoNGqGLgeCR/g9xZ2DHQowzjnKnBQY0H0ULUYaBiAHl3cOONShE2MsoHj876Gz+89zbyLDExMT1tpbethty7MRJicnjRINu0p62EHKMwAGg8EQKMPBQjt3fk4U9fDwcIj+j7EnySK9AEX8HwOyXq8rHo9b1BVDAzCMNAPfBYT5hQnmC7ViRGBkE9XFOMJo4XDACR+lpwNoUneLSD9rhaPFXAPEzczMWJ0exuBT00bTnDCSotGoAR4wjoj2YXRiNOF8ICcYuNyfqDNrRjoXjKlOp2M1PmClIfekcOKgAzAkk0mL/vIcHHGcEqL4HhT084QD5/fB8fHxEAMJoxOZYw4AQHAE2dve6PfpGcgGzgWGLbLr03BYe94V55L/YzghQ8g4+8VfyBMG8sHBgXUflWSsK6Ll1EKSzurA0Aqaoqs+JQ/H1jt/MBklWcTfp115RxnnBwCJtWcu0FG8F+lWnsFDsexAIGCMQth0rIEH8DGMYY9gwMOmQX48K48i8dRTYh9x+fpwAKHoN+YUhhSAkiRba/YBTjlGOykP1JXB+RkbGzOnBFYiQCWfw5EjTSsYDCqTyZhOpE7IycnDuilTU1OanZ3V3NycOaTsFXQ3+oe9gTPHPiQYcHp6arWgAP3R715ePcOUMwCZQAZqtZri8fhQ6gzgx+TkpJ5++mlNTExYQXLWDCe61+vZ2qIXAAeRRXQ1jA+cOJ+u2ev1rDYJupF3YA3j8fhQ8w0ca1+Q2DObfaqOT8ljnfk/8wRLk7PPswApNs8ZzDnlWcJedpvNpp0jBBaYCxy2UX2CTABWZLNZY7ukUqnv0nfcz9dua7fbVjcT5g9nKyyvTCZj46SBBLYS7ENYqayht1m8bga42t/fH0qZYt7QS6yld/7n5ubsmfwN0OnZXego1h4dg75iffr9vskJDKZ4PK7BYGAAHGNF3gKBgHZ2dtRsNnX16tUhxiY1mHwhb4A/5p9gDaxSajtub29bXTDOQj6PvCADMEy9LTI9PW02IfoARgzzwV5nP7AnACOYT/ZZKpUyYMQDPthfPvUVZhBzzc9h2HP+etCDgES327UuxLCG0dcw/dg3lBtgPmHSYquOBnFh1bIH+R0A2tzcnAW9vM6WZIzKbrdrYBogCecCe4vzFUYiQJkfE4EBgpDhcFjHx8fK5XLW/Zo1OTg40Pz8vL0bz/YAOGPAPkfn+1Q7zhLGx3sxbvbZ4eGhsb2QHw+oDwYDA275N6xpxu39henpaQP3CeQSUMXv4ozFz/E2K++ArsWfeS9fF6DUxfWjdl2AUu/iRY47FF4iy4BLHjSIRCJGhebA5aD2F8rBHwQ8yx+UKGCvTAaDgVZWVrS8vKxYLKbLly8rFArZM320lWK4u7u7dtCVSiU7vI+PjxWPxy3VpFQqWZFJoo8cWlCAKTociURULBYlyQw1Dr1R8AkDBacTRxmQgMMdQ//KlSvGDAAgSaVSVvD56OhIxWJROzs7ZqSsrKwM5fBzcGI4Y8RiCEMTv3z5ssLhsE5OTixSlk6nh/L6SeeSZNRx6op4hgbOV6lUUq1WGyo2Sb2qpaWloVo1AF7eQMUwY+4AzWZnZ81RAOyCGUTBx0KhYOlsFNSWZAw2nLvj47OONcvLy7py5YqlME5PT2tpaUmLi4tWVLnb7VqqDGyniYkJ7e7uWpvzSqVita9u375tKUYwfjx7BqfcswJnZmaUzWY1Pz9vxcT9vCCTGKisZblc1oMHD8yRaDabymQytl9Jm8E47ff7unbtmp566imVy2Wr58CaYHQSReT773//+61wMgZTKpUy4xi5gk3BfH/9619XJBIxtuTh4aEV0pZkQDHPvXr1qp5//nn1ej1Vq1XduXNH7XZb165d09WrV+2dASJIU6JTKAXOq9WqEomEVldXlU6nNRgMVK/X1Ww2tbOzY128Go2GCoWCpX5SMBxwAqOy3+8rkUjohRde0OOPP65KpaKvf/3r2t7eVr/fVzweV7lcNgNWkjF8iDoDhuI4jo+Pq9FoWOoERilgCcY0oLpPlZMegl5ep3r9Kcmi8DhDXKFQSKurq4rH48rlcsYAwlmniQTMs0qlIknGkGg0GpaKR+SWgt+9Xk/Ly8s2f4BdnA0PHjwwpx7w1qduLy0t6WMf+5il8JEmdvv2bXU6Hb3//e/X2tqagYlbW1t68803dfv2bTP6qfd2cnJWDPmxxx6zCP2NGzeUTqet+D0ORKfT0e7ursrlsvb29lQoFMwhx+GSzhoCdLtnRa9LpZLtK986nUYGpE6PjY0pk8mYc4I+q1arSiaTGh8/q5919epVFQoFdbtdJZNJGxuyJJ2x5FqtljERd3d3rXAxuoQzhXFPT0+rXC5byjcOZjwe19ramjmI6FXAXc4QgFLSy0brOaG7AVxI4wMQB5RBdn1RacAEZBdnlLT05eVl29vsIxjYAEowETKZjC5dumRs3YWFBT3//PO6fv26NQB45plnrCbVm2++ORQYA6hifmFLnJ6e6tKlS/Z+pVJJJycnds+ZmRk99dRTGhsb061bt/TGG28YUMiZkUwm7V0BODy7yKdvwqja2tqytFWYK+ypfr9vZwvnSK/Xs7IEBLu4fNDKMx09AJNOp7W2tqYnnnhC3W5XmUxGJycnWl9f1+XLlzU3N2fyIUk7OzvW3KRYLKrT6SiZTBoT5uDgQJcvX9aNGzc0NnZWemB2dtbmB70dj8etqzLM9QcPHuhb3/qWjo+Ptbm5qZWVFRUKBS0sLOjHfuzHdHR0pGazqWq1aiUe5ufn1e12VS6XzfYIhUKanZ3VM888o1gsplKppDt37mh/f19PPPGEJiYmdPfuXWMgosMBSCh0TkF/gLXZ2VkFg0E9/vjjJhOA3fv7+2b/pFIpra6uWtFr9gyNDubm5tRut62zKwwp1olmCkdHRzbOtbU1DQYD5fN5TU5OKpvNanx83IJu1WrV0vd88BPbB9CRNeEPaXGALjDv6OhWq9UMSIb1vb+/r263q2g0qve9733WfRz7BXsMtipnLPsY0BD9D9v08uXLWl5ettTmb37zm8pkMla0/8UXX1Q+n9fjjz9uTHdJlioH+Mh7ffSjHx3SfbVaTaenp0PpjoVCwWxoggOcUehCgCPvkwSDQS0tLWl5eVmFQsH2JX4D9ht25/PPP6/j42MVCgULpmA71et1JRIJk4uDgwPNzc2ZHUNKtWdxE1CdnZ3VgwcP9F6+LkCpi+tH7boApd7FC2Pdp48ARuBoexo6aTI4ttDuqcVEDQNPT/cRQpwTjFXqYcBOITIrycACOowR2YdRUiqVtLOzY9ReIkZ0e8PAwoiG6UIUjvfn3QDefAFfPkNEjnH71B9Pk8bQIfKBQ0sEBmCHNsR0GKN2AQAAUUfYBLBXOEC9o9dut40JRZoGzrFncxA92tnZMUr6tWvXNDc3p1qtZoYsTgBKHgOAznmebtzpdBSLxaxuTKlUkiQrEE10n05ORPQ8o8szePw1mr7nI5w+NcHLJ9EnnH/k0wMByA/OFuwt0t3m5ubUaDSsaChgGXVB1tbWTJaJVgNYMmekeVDYFgNXkq0RaTuMh1pJh4eHVqtHesgwwNDl3ZGJYDA4xJBA3onWUp+oUChoMBgoHo8PARtE6IhaIscYbtQ5ADDlvXHogsGg1Wwgqkiqrk/3YX74MzV11j7cF3tlvzKH1MzAsTw4ODAHELYPDiyOHuvp66BQa4o582xBnBAio14vslepCebZkkRWYQAxj14OAFxgGQBacC8AZop/++L7rL2P9LKuOLHoSQBGQC0iyawF48Epx5lpt9vWZQjdzn7pdrvGOJuenlYsFrPaHXQPRDd65msymbSUV1KOuTdRc4BfzwZhLxI8wMkPhULm1KK7R2ug4Jh50K7ZbCqZTJouJNWCCLnX7/wfnTpaF0XSUPe4+fn5oaAKuhWQDSCSTnzIAnsYp4dIOfuKeyJTBDo8e5FnnpycaHt7W5cvXzZgEdbv3Nyc1eqi1hAp7tTTAswCYABI5Y9nh/mzm3HxOd4DEARWBHNCfUDYIJ1Ox0CvarWqpaWlIbBveXnZ2Fae1eAZHIyL+n44+TC9U6mUsWv9mUnKJGMC+PFF5QmmFItFCwD458bjca2srKhSqVhwjJQs9ijghPSwCQD6otFoWHfE09OHjWW83eP1M0wuSVYvD6Yk84IMB4NBA7eRc3Qk+gbG9OLiogEp1A7knAZAIyDAeGBVUizbpxmRDsk70fwEZjTnGcwbzk3O/06nY455t9u1VCf0MGsI8OeDONg/2CAAPuxjdECxWBwKJpBKLT20c5m3W7du6dq1a2o0GlY3FQATvQYYwbMBXWA9Alggxx68gA1zdHSkQqFgcuvLX8DQIqUZIBJGO3oV29AHNPw5xfoAxMJqwq7ydQ+9bqRuXiAQsIAuzSk8i40aXIA6sPlIBeU+gLU+TZiLWm/tdlvT09OqVqvWnbVcLmt+ft50kWcjEjDG9kbHwg7jD51SsQ09U73dbpv8cm/fWILi7gDNAEzoY3Qy94NZSJoxbFX8G9ZvYmLCmGIeJPd2FGvLu19cF9fF9cN1XYBS7+LlU9Ckh+wmHFPvPPNvFDMGB1FTn/qEQYvTh2HHwYnCxRnBKAHcof4FbBMOfA4NDDOi4xyKgcBZweR2u23FqjFGMSoxoDF0cMgjkYji8bgdFly8E6kajJcoBk4Dz5HOAASMwVQqpWKxqHA4bHM6NzenTCaj2dnZoZQMwBKMOopmMw7PiMJAgQXB36FQyBhspPhQEJeIf6/X0/3797WwsGAGPlEjDlocPVLZMLoxepkPxjQ+Pm5GIkaLP7i9fPHOyJan93MQewfJp/L4teQeGPwACNQ8ABQKBoMWZcS44578m6Lb0hlbgTbFgIXQ5mHUMT8+3Q7ZxekidQfnCEcVg16SyXin01GtVlOr1bKIM8VWMVLn5ubMgWIO2QswPTw7DYee6CG/g9UDgDM7O2vsr9E0HCLMkuw5zB2A2+zsrHXjBBRlzDhEnhkGqJbJZOznyBpzSNFdHCdSSRgvTCrmD71CIWQcCCLHyA372zt+ODukYPFu7NWjoyObe5hpHoBCvv3cAwgCqDGGwWBgwARyDhMAR469w7yw75hPggDIGXqWNfNpwADSjIk25KS6kH7tn8+4KF7MPHA/QAQcNJ+KkkqlrE6cL1jP3oaNC6MUthfgCQ4b+osiyNSX8V0EA4GAstms1efAkUMG0dO+MDWOO44YsuDXHh0MEDLq9GWzWVt3Pj85Oal4PG4OuE9XY7w+7Q9wFyeVewHueVYRf9B1OO4UrYb5wBonEgktLCwYqwoHnLkApAVkJIUWZxFQl3MAEBkWCCmSnMuMnT3MvDPPzJtPvWJfIBOw/VgXzxjijGUeAKoJiAECesZto9GwQv6cQTB4ARpJ94UFR4202dlZAztYJ/S6Z2bi1JNyGAqFhtK6ut2uPcuz2wCn0LeA0qwrz+RMwZ6iqLdnUfJunHO8nw+kcT6T/jMzM6OlpSUrEI/uR8ZwoNEP2G7tdlubm5s2FtaItcCOAMCGNQpLCnaO9LARAgyQQCBgqVqcT3Nzczb32KvoQ+aBgAlyRSqpP+fZw4BH2JbIFvqIz0xOTqpYLOqxxx5Tt9s1nQJ4DJDD/PM3+5k9z1ng7R6CSr5EQqvVUjQaNeYaa8fZQ/Fvvsfao4v5N2AZ8sbeAmABQOKs8LLtU/MIbHkdSYF6nx7PWnlbhP1Yr9fNFieg6btfI5Ps8VgsZk0E2H8LCwtWXoH3xNYHYGKfYKePjY2ZHQ8ARGAG+4BnExgBzPJyg67lrOMdObuxfUYBdO7LHPZ6vaGgpJddWH7UYcTO9Gcmexsd8e/DdcF6urh+lK7A4EJif+Cr2WwqGo1a9AqDAsXL/zm0fLQHwx6nD4UMcINjj5GKEe1rUuDQk5uOYscwIQLkDXv//H6/b21YpYctqzE8Dw8PzSny7AzG7UWIw5vaAzjezWZTkoyVQDQEw8hHJ/2//RwNBgMzkAGlMDAAgDAmceJ99JyomSSL5Ph3wbCZnJw0Y9YDDkRoYBD5VIBWq6V0Om0GAmuEoceFMeOLxRId8mwYQCocQ4weDleMZX7m39uzpZAZnF7+MC/UFPBsFv5NpBqGFO+HM+QdUt6H55G6SMQPhw4DkM+RBsO6sA+khy2mYd8AkvkCvDwbWSEy52s3wFgCcJJkBpKvV0IU2LPJYBF1Oh01Gg1z1mElzszMDMnQ6empMeZwDj2ziXXA6PSgIemy4+PjlmKDgeejlESsY7GY1Y7yzhtzQzoQjg7AHPJLvQ50A4AGYCj3BSyH9ZPL5czA5mesIfIeiUR06dIlq69BmpWn0rNOzCNrzphgkGKEwsZizXAsAP48mMM7oWe4JzW2WBe/bgAFyKIHl+PxuBnvnmXIegEcAPKwd4ji+tRSnF2/d9nryB/PJzWS9x89O6LRqNbW1kyPEpzgs6QowWylThcsul7vYRFonAXP0KG4MGwO3gm9hx5Bh/Au6CDu1e/3rVgv8wuDzOt5v7bRaNT2EJ/x5wPMQu7BuQew7c8BdC/6ZFQGer2epYJwHrI3AST5P3MGKxrgyYPanmHjU74AlDyLDMCJC1lk/yFzMGP992AloyPpUghbgDRF9g7zIMmAE1KoAoGA1tbWFIvFbP8Q3PAMNMbgzxyvg1gPmEenp2cNS9LptO0vagIBItJQAUefMbAP2Md+n4+uAWczMuQZwX4uvc4JBAKmLwD1cGh9UIfzHqd/MBhYLbhMJmPrDDDEmni2rWeCIqekAPugI3XFuAfyQqAMABpwliAJZxJ1+7ANo9GorR0sMUmmc7EBeMd4PG42Va1WM3CbNTk4OLDzFYCfscAq5AxlLSqVijKZjAX2YPYMBg9TsbD5eDZrg13hmcfoBW87oUPoaMdaebba8fGxstmsrTPy0Gw2h8AOD7Rhr6Bf2ef8nL3M89ER7FF+h9yMgp3ILfvMry3PhzXl609hL2Iv+bRl32RjZmZGu7u7Vluw0WgoEomY7eXZ7rz/jRs3TMcDIHp7uVar2Zh4R/QC9auYKw+s8zfpl9imHhhmDpnfaDRqMtrpdIbYiqSIev8G0A0/xq+f1yHSWfoiNdjeSxc+6a/92q8NnS3v9Do5OdH/8r/8L+/Jubm4frivC6bUu3gReaRzFFFsHFkfbUH5c3BhHGKYpdNpi8jjmGEcETUiok30iShQMBhUsVjU2NiYlpeXjVlCbRJS1KhjgZFGih/MCOo8YHQUCgVtbW1Z1I6xepYEDkwkElEul9P9+/c1NzdnxjERMQwHipIDZOCAUbcDw4V6BaPAyNTUlFZWVgwwwiAAZCNF5fj4WPl8XpIUjUb14MEDM9rK5bIVcSW6CXOA9YnH41pdXbX0rb29PaXTaVUqFY2Pj9vzKS4Jy4XDmrVGFjisqc2STqc1NjZmwASGvGd2AWbRqhg2AZFuHGHeAyB0MDjrLgMg5h2iSqVi3aZ8Z0Tktt1ua2FhQYeHh1pfX1cmk7HPIVMYZrDRqK20ubmp4+NjlctlPfHEE1bLwTN+Tk5OVC6XJT00pJg/CtoPBgOrZ0aEFOcylUpZapKvT4GBjGMFAIUT1Gw2lUgkdPfuXa2vrw8xbXyL8/X1da2srGh/f187OztmbENbZ19SQL/b7VqtCCKTyHalUjGADgMNcCiZTKpQKNi+b7fbevDggRl5+/v7Q2kOExMTWllZ0eXLl835Q24lGUV+enpayWTSmBwAM3Q2m5qasvQxUnjK5bJR9EOhkJaXly0NdX9/X6lUyuZ5f3/f9BYMBxh4zzzzjNLptPL5vKLRqDY3N4eAG5wxUmAANgHHSBlCH+BMl0olJRIJhcNhNZtNpVIp9ft9A0EBu3w6A2kIsA6p/+RZit7xZu/iHC4sLFhtvPHxcYvEB4NBA1sAaFgLfgbzBHaID054turBwYGlTeLw37x5U+l02hwq6okAcKRSKf3kT/6k1StjTf08E70H5Dk4OFCpVLL0O2Tr+PisixpAFA53MBjUk08+qXK5bI7H2NiYfc87iezDWq2mxcVFFQoF1et1LSwsDDn/6BtYNdQVQUel02ldvnzZxoy+4zkeiOc8ge1LpJw9CgsnGo3amkejUXOwQ6GQyuWyFhcXtbi4aMwHz9jxoGO9Xrf6hMwDwJUk5fN5rays2L4NhULa39+3znLIOE49TnihUDA2XSBwlgbIO0uyv2FCsy9wcmHQ8D6XL182m2F7e1vJZNIYYYPBQPPz80qlUpYyR62nK1eumJ0SCoWUTqdVr9eHauShh6ThouOtVssK7HOG0vCENCDGiD7inGm328rlchofH7fGHZxHBFAODw919+5dZTIZDQYD0wWeiQo7g6AEjjPphQTSIpGIdnd3zRmem5sz55zAGrLmHd5gMKiFhQUtLCyo3+9rfX3dUpKRS77L2NFPBP44/3C29/f3bY/C0kHvZDIZSbI1IhjYaDS0t7enSqWi+fl5q/MIk29yclKbm5t64oknVKlUNDExoVqtZjqAtPZ6va5KpWKNJKanp3Xt2jW1223duHHDADFYcIFAwIJEnBsEMhYWFvTMM88YSF2v182WIDU5m81KktUoBBxFjmZnZy0FkjERWKFBCww8dBZyhI2NrenBPAIpgBUw7KinGovFlM1mDYQrl8u2D9An2NJ0oIPlAyiKTcIa5fN5AxbJXIClznuNAmzYpQRy+RmAK+AWLMt6va5Go6H5+XktLi4qFArZmYoupmQH9Vc5I/hus9k0hvHq6qo+8IEPDDXg4OzBXk0kElYiBDCNswZ7h3XivMAOlaRLly4ZWLq/v2/2KnuToFQ4HNbCwoLpWbq8StLe3p4ikYgFAH0gl3OJOfNgMrW7/n3gYwAifj/f+1G6AoGAvvjFL+pTn/rUn/ZQLq4f8LoApd7Fi5x6DEYUNUCSpCGHBVYBwA4ADBE+H+Eh5cdHDD2jg2gFRo/0MNKPk0WtAJxpDgXPrtnf3zfQh0OMlAGKMEJfxhjBUWF8PiI7GAys0Lf0sF4Gc9Ltdu3+niXD5/3fBwcHisViQ6luOBiZTMYMNgAdHAscVJzaaDRqTCnmiQLJGE6shTeUMDZxmElfxLFljnkX382LtWbtmGMijtRyYX4xVP3cIgOMBcoz4KF/XiQSGTqMMXA804J5AQikwDJGEXPv20MDqBAlYyzUPiBVbnJyUru7u2bgYWgCQAIcYFTyfsgEaTFQwgEMAMF8WhaOGVFizzrj54BhyB61JaDXI8ekthGxJKpPJBmQs9VqDUUpqWPV7Z4VMc1ms7py5YrVO8JwPj4+NtAXYHJ/f1+Li4tWX4fUJNYe9g9riBwGg0ElEglLJQTY9vtwdnZW8/Pz1pEP0I3aS6FQyIqwA47jmHW7Z12OlpaWzJnt9/sqlUoGpvm6QoPBwOaTtMr5+Xkr9stnfd0wxsq8YuBKsjVBNxHlZ87GxsasOCv6wQOPyK/00DjzaQgAeJ59gy71jDr0EsY54ACMBZ8CAlDhWXLUF6MmEfqf5yLzpHsh19TfYLzMn2f3BAIBLSwsKJvNGtBDjReK6rJH0JGky1JzBB3E/PjaLYAkV65cMQcFpwEGAw4g0X/Ag2QyaXqYVCz0EXOJI4lMAHhT44wuZqTsEDQAHMHhK5VKdvbBuvEpcgANnM2sO6wev//9vcPhsKVWMZfsfc4yGMQ4YKTGoidgLo0CiqMMUX9mcnnmnmdteJaJT01kLQAdAKVItRrtFIhebLfbdm6srKyYPpmbm9P6+rry+bxSqdRQQM2zUznL6vW6qtWqPScYDFq9KOSBOWVeKVYOaDM5edZUgz3PecB56NN7kB/ek32LLjo+Ph4KDLKfPLPFnxeeWelZ6MgZOsqzwJLJpAUEkR3S2rA7fPoRY/V6CpYWADJyE4/Htbi4aOcQKZDUTkK3+iYInFXoRxhhXv4PDw8txdTrcnQLoD1n+cnJiZ1vMC2ZQ+YdGzcWi9k5TKkCdCnAErLuz2hvI5NOPjk5aaDV9PS0MpmM1aiMRqNqNpvWNAN5wz4k3ZugIvsDAAswamJiwkDXhYUFyzrwqZbYgJlMxuo1YfshGwQcMpmM6UECJbB/APJ4P4DG0WBdMBhUuVz+Lln0cspaIPOMLxaLWcMI9g/vja3tUx+pbcb/T05OrFkQ4Gq73baU72KxOOSDcCazN9B7zCE6y1/oS585wDvBzsd+BwxnfdGDyBbz5++NHkVfIH+crV5+38vXDwso9R/9R/+R/uE//If6e3/v7+k3fuM37Oe1Wk2//uu/rn/xL/6FgsGgPvOZz+i3fuu3FA6Hf6DneXkbGxvT4uKifuEXfkH/3X/335k+urh+OK8LUOpdvFD40WjUNjUghfQwh5822kTAT09PrSg4LXwxijEWSRPBYcI5IqpGbncsFpMkMyii0ag5pGxUmDQcdmzSk5MTXbp0aagmDqwaaOcYdjg3GC0+FcXXXsJYks6KLxK1gWLL98mvx4HqdrsWKeYQTqVSymQy9i4cjOTnE83moARA6Xa7Q6AIETaMBNgYo6l3RFpZCzoR9vt9LS8va3x83Cjt1N4JBoPWoQQwEAOTmleSDLxptVq6du2arXU4HDanamVlRY1Gw7o4+VQ/jEk+SzTe13j46le/qqtXrw5FRIl44ux5wAXABrYWTgqMrXg8rkwmY8+PxWIm3ximGIUYPbxnOp22dQPcoe4AVHKi0zgSdGsqFouan5+3COvs7OxQFK5SqVg3H7of+ronnh5PDRoilZcuXTKDl4v3wAnyaW8+LTISiaharZqzT0c2QNJYLKZ4PG7U92QyaTXIJBnoi0MyMTFh9X46nY4WFhYselmv14ecTNg6i4uLFvFNp9NDNSJIXaSOFAY6UdT5+Xml02ljJVYqFSt4HY/HlUqlbH/CNigUCsb4ganB89mLOMgUqmafUFie2hgY7r7eEPuQtJDDw0OrR3Z8fNYBlOg7TB50H4wCamnBikAWfO2OQOCs2CwdHtHP0sPINBeMkUgkokQioVQqpfX1dWOM7e3t6fT0VPPz89YpiXmjMx9RcQ9E4YzCksAhnp6e1tramg4ODnT16lUFAgHVajXNzs6qWCwaC3B6etrAqJs3b+qjH/2opXChC+j8dXp6qmKxqNXVVYVCIQMhOZP6/b7pfEApZAyGKmkugKoAx4CwOH0U+p6amtLa2pox8WA9zM7OmgziuJOKhRPCOQaQPxgMTH8gH+xbWEKwBhYXF60DV7Vatc5mjIF1v3z5sjX+uHLliuncfv8sbTccDtu+Pzo6MmYEY9vY2NDU1JRqtZqefvppcxxDoZDdG6YZbejZX6TnA+Cid+LxuLFscbRgJHC+SbL9zPxhC5BKGI1G7V6cnQQEOBdhtQL6k+oDkA5baWLirMMkQKtPrcHRw8aBfR0IBJRMJq0zn68hw/oDOHB+T01NGcCAPQC7udlsGgiXyWQUiUSsXg6gCboH3UHdJvQRuhSZYq1IFTs+PjZghndDr3sgdGJiQvPz81pdXdXk5KSlqxGIJMUK55q5xdHyATzkNplMmt6SzgKcdEPNZrND5xjAfr/fN1mk1hAOOsDMs88+q1gsZqlcOPiJRMKYvdgPY2NjSqfTCoVCpucA3geDgc2VJDvnaIDD8xcWFoZsUTp2oi9KpZKOj4+VSqW0t7enS5cu6fDw0JhmBG0jkYiWl5eN8YvtlM1mjZ0F+J9MJnVycqJEIqHZ2Vk7dzh7AOvYSwcHB7YvmNerV69qfn7e9gyNhgDeY7GYFhcXLXOAvRuJRJTP5+1c2traGkrpZq4AW1kvznrSMf35R8CNumwA0ASeAfMYC+9HmlUymVQymTQwiZQ92LTsEWxT7A/2IGy5mZkZJZNJOztDoZAODg5UqVSM7Q9ohc1EjShAp2q1anYbYPLJyYnZF7Dr8EGwtwGfYFQiU6w7vookK+FRKBTMFl9YWBjKsmCOALIWFxdVq9XsfLy4/t1dX/ziF/W1r31Ni4uL3/W7z372s8rn8/pX/+pfqdvt6vOf/7x+7dd+Tb/7u7/7Az/3n/yTf6KPf/zj6na7+s53vqPPf/7zCoVC+m/+m//mB773xfXv7roApd7FCwMPIIaIE6g/BzrRT0AsDgkPFnHgArBg1MFiIDpPGgCRLZxFnHAOE5gzPmJCKgEH9snJiWKxmKamppRKpawwJmOkyCY1L3yKEPeBHssBx884RKXhNAQMyGAwaAYh70DLYQAoDqhYLGaRNdKheBZOu0/JwQHAIPa1pzygxvr59DouIsdEdIj2wRSiuKckc374N6wigDMcL4AhmD90EAIkmpmZsdQKomiMBXCMueEeXP1+X9VqVcvLyyaTvrYGBgVGNwc38gbrgbWh4CZzSI0HvktUC+AGecaY9N+D7YE8+mK8yAXPB1yZmppSLBazdCjAVJhUdDGisw5GDe/pmWVeRnHuASowwMbHx42BhCx7Cjg/lx6CnxS2xjD2QGWn01E4HB5yvnmuLwrNfCIj6Aq/T+hiA0uOsWLgMh5YWbDLcLxgwbCXcGY96DYzc9bRkr0N0w+H0Ud3cdp5d9af/YKhC5AEGwvwFEfEp2l5XRmJREwmSZHxzgGfRabQfYC4ANukUrIPmGsuxuNZgvyc/Q3LA3YZRvRgMDBdwBxNTZ11RASUYr5g7rCfSePyLJ1EImFADNFs6YwFhMyh2wHvmKdoNGrz4OvFkfKK4Q6wC6OBvQi4xH4hRRgAGwfWNw/AIeTsYi2QJ/Y0KW7oLBwM9CBzQEoy30c/sJ9JAfPACuwV9FWz2VSn0zEGISwrgBO+6+tBzc3NqdfrKZFIWFDG14Fib+A0co5SDBgAJJFI2JoC3LAmgJ6AE9QaQ65JwQQwRMcjt96xJGWX96AuGAXKAYgo4ozcMUfsI5h5fJei2uwf9p30kCElPUxD8ylTzA/d7ZAR3mNmZsbYuTyTvUkwBLYXzCL2LY6vT8PlDOB8QUY8I520etbAs6TRHzDGmGPWnPGNj48PgSYUVicww35GDj1jErnBvmC+YFL5IIivoQQ7iudjB7BenIXYC15fn56eWj05An3MEYAcoAVzAKPTpxyz5sxPvV7XxMSE2QPoFeaF9HrOJv7fbrfVarUsGMj4vVwAchCUYu3RNTRwwE7xOmZubm7oTMO282sNIAwgDsANEMcZ7mUI25MAJHqI8VUqFYVCITUaDWNDoj996ig6D1sJfYgM8+4EUpEVL1c+GAuDmKAgdgsNF3g+KdmcV55FyvO52P8eoCJ4gX2G3kWO2cesG3apD+YS8GQeOEvRF8gsugn5RaZJO6S0hWeRY1vwPN7HM6PQkZSdICD2Xr/+tJlSe3t7+vVf/3X9y3/5L/UX/sJfGPrdrVu39KUvfUkvvfSSPvCBD0iS/sE/+Af65Cc/qb/7d//uuSCWJN29e1e/+qu/qm984xu6fPmyfuu3fuvcz8ViMc3Pz0uSVlZW9PM///N65ZVX3pX3urj+3V0Xhc7fhYuichgaGG/8mynGmMM4wllCcfp0K0nmHHHAYSgRZfe0ZyKmHmDCgMO4lzR0ODJG/va0WR/pQbH5tB5JQ+kv3njGCQFQ4B4+BYLDx0deAVW8webHiQE9StX1EVxPdx491HHwfb6+H7t/lk+RkGQggE9ZYC0kmRHA+P27cIgyPn5ONJVnIhc+9QyAjXdhLBzKHkjwcsI7cuAjEzyHe/As7g8w5R0QDD+YA54O7o0DPo8hSFteGFOeieKfBzjlf+ZT7XxheN7Rp1ZgpPJsvz7+M3yXNQPA9HsLufZGER3XiAAylxg7zC/3hvaOg+2BCN4VGfBgDwCrTzXl8z66z7vjbHB/ZNCvCf/3+8VT5H0Klge8PSDg9Q4MN+SbtfKAN/MNQ4uoPql9zJN/F7//MGjZx4yRuSatgrH5Pcl7ez3A+7EWnjHqwSGfGuAvHCuALlLJ2Ns+MgzgyJg9w8LrF8+WYE5wLgAhSYlij/g9zNrgqHU6HcXjcVtX1mM0HRoAx8siTq2XGS7AQgIoHoBAV3nw2suD12vI+eg55HWAn3uYQH7emEdkjL+9vKNDfYoLae4eBAWMII2W9UBH+Wf7OfLy61OhPDua+4yePYzJnyt+vtnDnO2896gcP0qvMS4cTuwLvwb+bATA8A0SqGnE79k3ozrS6xOvB3g/bBpYVB70Z59xBvr3R+/hzPui/378nJ3sF3Sjd/z9mcleHWVBMh7+zXpxeXnzfwAk2et+P/PufJZ7+vH4y8+ZP88AYnzKpP+8fx/ky8sMc4E8eH1AYIU55PPYfT5Qg7wRBITpzGf9GgNYsN/8/iRIyP4CjBu1Z1l/AoBevn1gyL+nB0j8ueVlFh3hbVjmjjVlPOhHvo+O8/djzn3DBZ/+zJnFevmxcT+/t3h3f355eRx9Z78f0MusHc9nzqmViC5gTdBp3IexRaNRA2FH97fPmmAcnB+csd5+Q6d6fY9fwjqM2t78mzX3YJ23V1mbYDBoZVBG/Rb+eHCbsXW73fdkMW980i984Qs2/9/LdXJyon/8j//xDzQ3/X5fH/vYx/TzP//z+k//0/9Ua2tr+o3f+A1L3/vH//gf6zd/8zeH2GpkT/wf/8f/oU9/+tPn3vPZZ59VNpvV//g//o/a39/Xb/zGb+hb3/rWUE2pQGC4xtSdO3f08Y9/XL/yK7+i/+q/+q++r/e5uP5krgum1Lt4JZNJTU1NaW9vT8lk0qLXnhmEswtSD4W12+1qc3NTS0tL2tjYsO4UpPsQjRt1/Kj1kkwmzUggp3tqakrPPPOM4vG4FVCGKk2EgpxuItPxeHwoqk8tAT5HUcyxsTHt7OwMReuoLUOU6/DwUNvb2zo+PtbBwYEymYzGx8e1vb1tKW44BjjxHNDtdlvNZlPxeNyKo66urhp1X3roaMHooujy9PS0RbWq1apqtdp3saheffVVO/SazaZF8waDsxQBisbWajWdnp5qdXVVV65cGWKhUFB2aWnJ6OMzMzOKxWKqVCpWCwHDksPQO084TETxWq2WGo2GGo2GisWizTXgCMYMhjDGTCqVUrlc1tramr7zne/ohRdesLQJOqF4x6VUKikQOCtYuru7O2SslEolq5FBYdFOp6OPfexj1mbZF2aliHy/31c2m7WIXaFQUD6fVzKZ1OXLlyXJIq2DwVntFR/pxRGlTgZXtVq1NAkOyWq1akwU72gis4PBwBhSOPYYXb59+PHxsUqlkkV4+/2+8vm8OT1Xr17VpUuXdPv2bX3jG9+wmhL1et2aAZCeCXvws5/9rCKRiK5evapsNmudsLyz4oEIavBQt2VmZsYKjufzeVWrVRs/3YImJiZ0/fp1/cRP/IROT09Vq9XUbreVTqdN7jDuSPOkBsXk5KRR8+n0RMF7nPhkMmmd/SjQ3Gg0dPv2bTUaDY2Pj+uVV17R9PS0EomEpXBMT08baPSX//JfViQS0SuvvKLx8XHdv39ftVrNovbdblflclnRaNRSbwAOBoOzzm9ez2H0FotF0wHlctmYO2NjY2o0GgYYYfRS3Jc0SKJnODiwIyYmJuzdxsfHTW6y2ayuXr2qSCRiBfKvX7+uYDBohYZzuZxu3Lhh9ZwWFxetGDuGPWt9cHBga765uanHHntMp6enunnzpiKRiNWRyefz+sY3vmEp2ugqDzxdvnxZf+Wv/BXF43FJZzUa1tbWDKysVqu2vjhA3rinM2I+n7dzIxKJKJ1OazAYaHl5WfPz81pYWNDu7q7NdyDwsLg/7Fr0NoXAKcC8v7+vWq2mg4MDc9gajYa9D+vGGsOI4wyiaxdsE0CglZUVYzD4Gj44YbVaTTs7OyoUCjo6OlKxWLTnU5vw3/7bf6sf+7Efs4L/S0tLpgskWWe4vb09lUolA+hmZma0s7NjzS6WlpYs8s8ZxLlH8XUKzJMOjeM7NnaWKr6wsGAF/UnPhx1BZ8CpqSkDw0ibgX0yPz8/xO6iZkulUpEkS12Edbe+vm7t5lutlubm5vRn/syf0ZNPPqnJyYdNNAqFgq5evTrEMuHspPOdB9wAkiVZvSO6XgKcUGtHkrFbut2uCoWC2Tg7Ozva29uzND0cVACQer2ug4MDpdNpkykYv6Qw8Sxq9G1tbdn5gW116dIl1Wo1SQ+78mI/MEaY4gB5sVhMV65cUSwWUywWU7Va1dbWlgKBgDF2CoWCFZLHjmC9sVk4o5g3gJCbN2/q2Wef1Y0bN4ZYbhRoHhsbGyqe3+v1rDtsIBCwelOJRELXrl2TJO3u7urk5ES1Wk3Hx8e6evWqJiYmtL29bbIxPj6uZDKpxcVFszNgFQaDQdPhxWLRgkA8NxqN6rHHHtNjjz1mrMGFhYWhWnT7+/u6e/eugSelUsl0LelkMzMzevrpp3Xp0iVLNz86OtLS0pLi8bjt6Xw+r2w2qyeffPK72LjIKCAUxd/39/f12muvKZlMqlgsmh6A8XZ0dGQNTYLBoDW6WFpasrITMInq9brtHd6Fz/PsarVqNZzQv7A14/G4sa263a5isZgV2ydF76tf/aoymYwBdAR7fZDLB1sGg4He9773mVwhC6+++qqdmaSCIxP1et1qtsFE+9mf/Vk7vzizAa+KxaJqtZpyuZwBc9TzOzo6snOBYBp7vlgsKpFIqFqt6s/+2T+rRCJhdhFyi53c7/et8+zjjz9uvsrW1pZeffVVXblyRVtbW5bChx2D7sGm5vmcT5VKxdJkS6XSez59zwfAvtfvSbLgPRfM93dy/ff//X+v8fFx/Sf/yX9y7u8LhYKVXOAitbhQKJz7nX/9r/+13nzzTf3Lf/kvjUn1t//239YnPvGJ7/rsL/3SLxmY2el09LM/+7P6L/6L/+Idjf3i+tO7LkCpd/FCsYLCQ8P3kXocUkAcDhYiSEQOOBT5DAwVHBJJQ8YMdQtgXPgCg0T6cYL7/b5FolA+ACekaaDYSSXjebwDUQeiMRwCo1Fd6h9wLyIl/CwQCAwVfPXUXeaI1CJABcZAFIl3g4mBkYFjCnDD30RV/CHvn8ma4Lh5YxJjGweaCFu/3zfqczgctvpQRA45bKWHkU5vfHD/Xq831CLZr5eP+IyySnhPjBdSpHCOPIvGpzBJGnpvmE2sHXIM0ADYAYMCqjRgCykhsISIXGEEkfbCWvJvz9wBvEOGGJdn1hAt80y00Sj0eQwcxuD/7+n1nknEGAFMPVuCzokYSzhpGK3hcFjJZFLZbFZHR0fflTrmQSnuD+BGCgFMM/8+no0wMTFhqVoAcdTj8Sl7rCc6xqcr0G4ZkAjWFukpfq4xgP3cMRbSEjGwcTooQo9soxORK+ab56IDfXSZMbAeODA4xZ6RRsot+5Tn9PvDtfM8wwN2BusLQMo4YGMwPlJXfHrOqE4NhUIGtrF3PSuHtWRv4IziCMNK9EwbwIZRB5Z0Qt4hk8lY6lUgELDItq9ZgrFOkWnewY+h3+8b6JNOp61DH2tKbSuKCKMXAO2RM0DU0fPDsz/Qgewjb0gDEnKOodfovET9J0ApagP1er0hMI73YxywhPg/5x8pT6y1nzu+R6DJnwG+1hqgFqlcrA0AgncsYTCM7g1k1evBQCBgDj/OPPuNM41nsIe4F6krnHdel6IDCar4FP5ut6uFhQW12+2hYsOcue12e+gM8ewq7sle4R2waSSZDAGK8n3AZfYef7NvmNNRRps/W9A9nA3YU747J+ewd+B8AXXGw5xy7vii1ZyxnIEASbBsWWO+C+sG8IC544xGXwFwAcYxToKPsDR9Ghtry1qgf/z5h07zTCfOJ8489Jkkk2vPMmENOAt9KQP2Bgxp9nSv1zOdyfryx9sLpEljzwGWJZNJqxHHfqVmJqnqo8+Dzcp5ymcByQGJ6PRJIBD9RJo/9SGpBcnZAKsQZqEHpXwGA0FjAljIDmc0NSixt3h3UtiQe85YbFSfogigiv2L/ueZ7CH0l9//2DOBQMDmKBqNWvCN85DO2aN2gAcAR/0SfxYzHwSKkFev6z2bi9RkzgZvn/LerNWozTfKTmTOuM97/fpBQamVlZWhn/+tv/W39F//1//10M9+53d+R3/9r/91+///+//+v5qdndVv/dZv6ZVXXhliF/6g161bt7SysjKU2vfjP/7j53727/29v6ePfexj6vV6unfvnv7z//w/1+c+9zn983/+z9+18Vxc7/51AUq9ixeHdjgc1sHBgVKplE5PT41BgBE4Pj5uziuHJIqayB81PqgTgSOBcdJqtUyx4/BgpGDQEMWAKhuNRq31PIoax5EaGjjfh4eHqtVqqtVqajQa2traUiqVsshWIHDW9YkI8MTEhHX6SKfTVtzSg2iDwUC1Ws3q/khn0Vu642Dww6CCKoxxMhgMtLe3Z1FOOoN50AJjSpIBPOVyWdls1u7Z6XSUTqetrS8Olu+gA6MMR4h7YjDG43Fjw/gC5slkUrFYTNeuXRtKgeLCUaD9O+wXDvGZmRktLCxYAVhai+NMcmgDWnQ6Ha2srFgEf39/34qR4xDipGWzWTNAl5aWbE2IMqfTaWNK8DkKdNLOnS411ByYnp622kuStLW1pWKxqBdeeMGMT1hz1WrVImPIN3KVzWatoC/1GjB2qZUEww8WQDgcVrPZtJbCrAnyT2HZVqtlLZvr9bqy2axqtZrV/pqamjIg0KfZ0N4c1sL8/Lx6vZ4V5ybSTi009g7sGtgqfNeDqexX9vTJyYlu3bqlVqulZ555RjMzM8pms2aAA2yxFjgbOGnT09Mql8u6d++eLl++bAbw4eGh7t27Z0BTJBIxGR0fPyuuzx7HeKWo/NTUlHX9Qzfx9/T0w2Lc7Fcun0IEq+P+/ft68OCBOY1ESamHRC0KL+PoxEajYeDZ4eGhFYvt9XpaWlpSNBpVr9dTsVg0MA7dRlo1TB1JQzIA80aSMWR8oWKAG0BmAAdkOJ/Pq9fr6dlnn9Xc3Jyy2awVAPZsG5z3QqGgYrFowA1nBewgAEJJVpyZ/x8dHVltQJx3HI1Op2M1TTY3N/XUU08ZKE63qrt379qe9/JHp75AIGCsE4CkQCCg+/fva2lpSYeHh1pZWTGgbX19fShNrtVqqVwuq1wuG+gwMTFhDQF82h+F0Kenp1WtVi0FEbbL5OSk7UkcsHQ6rXq9boX1I5GIHjx4YEYqDjB1RWKxmNbW1ozNuLa2ZgArzJ1PfepTikQiVp+LWjTMcbVaVaFQsDMDZ3FmZkbXr19XIpHQY489ZuDCYPCwUyYspVarZYyPweCsTpgHjNh3jUbD0lNh01HcnfRxajHBMIblx3V6emq1HmmSEY/Hjd16enpqxYg7nY7tKd+5jBQKOmam02ljydFVCxvm0qVLKpVK6nQ6SqVSlpYFCxx2hg8swZpk7a9cuWJMLZhmjAdGw8LCghVlZq8EAgEtLS2Z3XLlyhVjdHvgkDOYoumBQGCongw2AY4YdZX29/ftbGN9AW9gP/V6PWtAIEmpVEqJRMKA0kKhMLTP2CvIQq/Xs1pGvuD1Y489ZuDPt7/9bSuYz1kDy/Tw8FCZTMbYVTBdotGoisWibt++rbW1Ndt7JycnarVaxpaiKD51f9C/0WhUnU5HuVzOGPLPPPOMgR0AUt1u14A3uue2Wi3t7e3pxo0bJosAK9FoVMvLy9rd3TUdjq5g3Kzn5OSk6W9sCezLaDSqF154QdFo1D7DmOhq6G0f32l0eXlZuVzOwEtqYbVaLes+DbvWzw82DozIhYUFpdNpsxkWFxeNNX56eqpms6mFhQUDUNDtdLq7fPmy1X2Dkfb6668bU6Tb7ery5cumI2BesUbHx8cql8vqdrtaW1tTMBjU0tKSMZg6nY6uXLlidjc+AHun0znrlkkwbH5+Xv1+3+az0WioUqkoHA7r/v37mp+f187OjrGdsEVgvlOvDD2C7U3h+enpaTWbTQMvWbNcLqdoNGr2RTgctr0Yj8etGQl14WjasLCwoGq1avWmRjsB+vMGJhd6l260m5ubei9fPygotbOzM5S+dx5L6ud+7uf0wgsv2P+Xlpb0D//hP1SpVNLq6qr9vNfr6Td/8zf19//+39fm5qbm5+dVKpWG7gXrHzb7D3LNz8/r6tWrkmS66Jd+6Zf03/63/639/OL64bsuQKl38aJoIMaGL2yMwUEkyNN4MdYANzjkfeFcnEzv7AHC0HFHelisk44+GNsUpcTZxvAkykvUmWi89JCqiaHv64vwN+wkDHki/6FQyN4BQ4WuKaFQyIwQSWZwUEOBugcccL5IJw4v48GYA7QB2GE+MIYoAM3hz8HM+BkLxgfRcSJbOCy+mDmpNty/1+uZQzpa20AarmnAOH2uu482MU6i4YHAw9pDvj4GdRyYcyJcjBNg4vT0dKhIJPPju4IR/fO1EjAm+L5P1yQiTCojEXCcJu4Jrd4zSXgnGAYwT4guSrJ3RY59xHcwGAztL6LWjA0mBYcrewegFGCJKD71nHA4iUYSAaV4OYYPTCAKtiJzyClRW88gwahlbvnDPDE/yHMgEBgqEA94jfPruy2xn2Fe8XPAMl/Qmb3OM3hHnAPfepznsk7MmS+8C0DG+o2NjQ3tF9bOMxsxJHu9njkCgCD8zZwCTBL1ZP2JulMQvtls2u/YozBP6MQHs40iv97RR3aQN+rseBlg3tnvRMdJmYRhxnoix+wrXyPG63yi/j5V1xcbhsEIIMY4fXF7WBTIECAaALMvMg4zgef5/er3G+/MM+bm5mxcnslLBBywmnt72T09fdgMgJ/BVGU8o51TAWN4V0Al5BwAyxfW9+xVGGHsf5gN0sOGEcyX/wN44NMVPAODvTc3N2epp6wpzjN7C13t2Q6soWcA0dU2EAhYSjnAeq/XGyrgi45gPP4slGS/4//IPvIUCARsTTmHkDtkjznCSSS9mrUiYOPZNDCAkG1AaPaPZ8R6u4L1Q7ey7owR24V3RbZhE6FbCWxgNzEXdLnkntyHuWRtA4GAnVmtVsvmkLMFFoafS+SO76FfpbN0QM56D8qxbugE5h45Y694oAo9wrmPPFEcHjnGbmKvoauZf89c88XKkXnelz3DXHLG8nv0sQezkCfu7e0wZBs2MGuLrQmLlDMPHYZdyT2YBwAWZAE7CxuWYCD2FLIZDAZVq9WGzinex5eg8JkDrH+32zVQyjN6GSOp+gDpfs3Zu6wdz0ZHwzD3TQ5mZ886DTPPsL187Tv2LrYyOpB7Yscwf5zDjIOxcEbxvugN7HLsAOYCWUNGsMeQb4JK7A+Yfl7PMkbPKERO8ZHQV4wf+YBFys9Zb89Mg13Fhf0AwHVxvfU1Nzf3tjWlsBf99bnPfU4f+9jHhn72Mz/zM/rc5z6nz3/+85LOGE6NRkMvv/yy3v/+90uSfv/3f1/9fn8I5PLX448/rp2dHeXzeS0sLEiSvva1r72jd8GXIIvo4vrhvC4Knb8LF0XlJJmxMZqG8CgK4yjNFKPHf++8JRr9vb+Pvy/RCH/f0fuNUl65j//DYcoYRz/nx+lp7yh+P8bR9x792aPe0VN0fSoGPz/vXt6Ie9S7+Z+Ppo74+fHvNZqCwvNG5/FR1yit+Lw15veP2qKj8+0ddhSwf0c/535+fGrUec/jnhj+o+von8F7YRD4VIvRz/mxnDfvo58Z/d3o+3gZH6Vwexn1+9OvwXnvgrPpZdmvj98TfJ+0BG8ov9X68UzvTPEz5Pe8PY7zxv+9sTmaGsX7nbfXuf/oPPI+Xg6Rl9GxjO4jDy75VCI/jtH1HZ2r8+T1UXvzUXrNj9tfXt78PvLz4J+NDuW+AHB+zvn7vHfxcufn08/16PohEzzzUTLggQA/vlH5H5Vf7oGM+Tnj34zD1y05T6b9vfy88v1RGfaXn4/zzks/t/4zrAHz9VZz/ii94581+vfoevnr7fQ93/HzMXqf0bH4+fIyed53zpN5fz6NjpP38PvFnxt8drS4/Oj+GtWlo/aOH+eojvH/B5j04xiVbeYOPevffdRGepR+8M/nj39n5m30HBidl9F19vYA3x99Fy87b3XWP8r+Yh9je41+d1Rn++Ca33Oc234sHhA9Tw+yt/wffub1xeg7+bRNr4N4T//80TkenVtvN4x+xs/b6O/O2+uje+W8tfWfGf29l+1Hnenn6ffz5og1A6ga/czovJw37tH/j54/o/oDkHx0ngD5R+ffj43xsK787e2G88Z6ns4ZtQ38Z95qnf04Rj9/3nceZTOMjrXf77+nC53/8i//8vdd6Pyf/tN/+q7OzWihc0n6xCc+oWKxqP/5f/6f1e129fnPf14f+MAH9Lu/+7vn3qPf7+vpp5/W0tKS/s7f+TtqNpv6z/6z/0wvv/zydxU6/yf/5J/o4x//uPr9vu7evau/8Tf+hk5OTvTGG2+cu/curh+O62Jl3sVraWnJCipSyBsjLxKJaGZmRvv7+6rX6xbF73Q6lrpASt7U1JQVnsWhC4fDVicE48NHE0jdiMViRleNRCJ64YUXtL6+bqlg0Wh0CEjhYOJ+7XZbpVJJpVJJW1tbGgzOouS3bt2yKODY2JgODg4sslepVKzIYLfb1erqqpaWlpTP5/XSSy+ZUguHwyqXyxbVp45OKpUaOmiI8nW7XR0cHBjgR9rf7u6uRcxWVla0tLRkLKBaraZoNKpsNqtA4KzwLukevqA8EXPyyqemprS5uWkMDtIFicQuLi7q6tWrCoVCarVaCofDWl9ft1RFIjOkzHijzkfs+dNut5XP57W1taW9vT2LWlFc0hu60kNHFaOPdM6joyNVKhW1222lUimFQiErKE/0giiovx+U9r29PW1sbKhUKlkKj2eKwUaQpE9+8pO6du2apaVMTU1Z4e9gMGgpIgcHB+r3+yqVShYxg713dHSkfD6vubk5RaNR7ezsKBwOa3V1VYPBwArnHh4eql6v6+7du3r66actah0MBhWNRlWv13XlyhVFo1E1m02L6MdiMWN/SbJ9RcHGSqViRW1hNkHxn5mZsQLM7XZbgUDA1rharWpnZ8c6SoZCId29e1fLy8va3t5WOp3W5OSkyuWyfvM3f1NPPfWU5ufntbe3p8uXLyubzWoweNjxhXQuZLDZbOqll15SMBjUs88+a599/fXXtbGxYWkQ/X7f0n2efvppvfDCC2Zw3r9/3wruRyIR7ezsKBA4i7Z+5Stf0U/+5E/q6tWrymQyGhsbU6lUsgLnNCJYXFxUNBpVv99XvV7X7u6uzXGlUtFLL71kaWe9Xk9bW1tWzJhaasViUdlsVp/5zGcUjUb11a9+Ve12Ww8ePLAo9crKigqFwlCqCKAcUW0i5YFAQPl83hgEc3Nz2t3d1fz8vMbGxpRMJtXr9VQul20f+pTpXC6nUCg0lL5DlA1GDnVHYCSRIsqeXFxctCLuly5d0szMjF5++WU9/vjjGhsb08rKitLptDGk+v2+pUc0Gg3T2TCLJiYmTI9QT+fNN9/U1NSU1Yg6OjrSv/k3/8aKX5fLZWP7UVz3mWee0S/8wi/Yu8JSOj4+1pUrV5RKpSwdOZ/Pq9FoWAohRjupjdSwYi5qtZqef/55Xbp0yQq7+4LiFO6uVCoqFApWUJzo+NjYmBKJhA4PD+3dWBvYmBQIHgwGQ2w3dMXh4aHW19cVDoe1srJiKUeSLM0YBiVRf18kndQXUqhw4jwQ75krzWZTc3NzVkSaNvbI5szMjBYXF7W8vGzsjkAgYKl0vd5ZwelcLmcNEA4PD7W/v29/Wq2W+v2+2Qakm3HeSw87PoZCIUtr4TOePc0ZR6dViie3Wi3lcjmtrq5qZ2fHmjCMj48rFoupVqtpeXlZoVBIuVxOh4eHunLliv7iX/yLWl9fVzQaVTweV7vdVjQaVavV0h/90R8pmUya/RCJRLSwsKBer6e9vT31ej3F43E7x8fHx63YNwXyKX5fqVTU7Z51vjo5OVEmkzE9wxlCUWJJSiQSVhMrFovp+PhYmUzG5pAz1tfpRKf0+2fs8Pv37xsT6PDwUM1mU9VqVdFo1NLJJCmTyRjzs9FoqNVqWVoZ6Y++ZtRP//RP65vf/KZCoZAef/xxXblyRZFIRHfu3NHp6am+9rWv6bXXXjO7BIeZ9KdCoaBKpaIPfvCDCgaDNoekppFmDFOXtDIYJicnJyqVSrp586Z2dnYs9bher6tcLpuOopbZ1taWotGobty4oUDgrBC8ZzsuLi5aqt7u7q7u3bunYDCo5eVlnZycaHt7W/V6XcfHx6rX60N1j65evapnn33W2MB37961NOtIJKLFxUWNj48rn8/rzTffNLY9jHDpLAXyypUrunHjhrLZrDXXIU1xMBhoZWXFGG7SmbNK2ujdu3etlhznK7q82WwaG5/SEOFw2JrLwNYpFAp21mQyGcXjcZM19n2v17N0SfQZ6d6kxbKfsdtJLyUtEBmF7VsqlbS8vKzj42Pt7e3p5OTEbD10/u7urmUcNJtNq0VHcXhsO8YWCoX0h3/4h2Zbcs9Op6Nbt24pl8sZM7pWqymVSulXfuVXzN5oNBqSZPUrx8bG9ODBA9XrdeXzeTvXuK9nzr/xxhvKZrPG/IMd/uf//J9XIpGwFGEAWAJ6pBWSfkyjp1qtZimMJycnVlssGAxaSuzx8bGKxaJ9L5/Pq91um61Kevvh4aFu3rz5vTt6P0LXKBj7vXzvT+L6nd/5Hf2Nv/E39B/8B/+BgsGgPvOZz+i3f/u3H/n5YDCoL37xi/rVX/1VPf/881pbW9Nv//Zv6+Mf//h3fRZGViBw1gTkIx/5iP723/7bF4DUD/l1sTrv4uWjZ/ybPzCW/P/57Ojvzou2+6i1j4b4aJ303ZFVjNnRQqw+yjl6cHLocqgzNlIyPH1felizgXHyTCJdPhrlx+sjIKPv5OeBe+M8+D88CwoxaUCwBzDioDn7OfPz5f8ejYqxRswjc0Nqmy/sDS3ZR/mgtvtisKOpLt4Z98WTfSSMeee9A4GAAZ/+u9wTGjcAnL8fTjfrNCqzo/+XZPOMQ+Xfn89Ru2kwGAwVw0ReeB7z6X8OEOPlzO8dxsnv/Vp4OeAPxj/vyjt4ucV58nvSR2lJL/FjInKNXIxGU306Bn+TfoIx5SOHOKYYV6TT8Gw/Zq8vcE58PTWeT0oYRjTy4FMgcCQAOjzFH+OOe2HYMw/I3+h+9HPhZXmUOTb6+VHZ8/I+ug/Pkwu/R/zvR2WYy+sr9tqjxuP1DLLEe43qAlIckD2frsczeS+fPjaqXwCI/DueJ6M4hKRlsNaAkeFw2L5D+glrzloQHAH0A0j2aZ/oNAB3dBjPZs+ROsE7eX3BXAHkoPNYP+aGv/1Zw5x7vcK9kZFRfewZNqztKCgFCM/akA7IH8B57uHTzXxqH3MGSObfdVR/PeoP8uhl9LyzcNR+GP3jP+/3wHln8Kgd4uWYOm8+3Y1UGklDaes+9ZkLYM3XH/RplugI7kWdLOoBAX4C4DC3gL7YKX6NkR1+xrnHOiAv/r3P0w1vZaN4PcMe8XoAG4DUTS8D2FT+TPT3Yk+gO3zBcc5Z1mG0sD57bHRtvb72+oPPsn8om8B7eDn2azV6Pvv54Lvci3fy74CcjdpTBM14P/QO5xDpf4PBwxRq7Dx0JXqPc9HrYc45Usn6/f7QPFL3DL3M2cln+BlzDdCCPkEnSg/ZYDCRsAP9eFhP/u/tF0lDdUyZS85g9Bbj8LII+IiO9+UuvE3m2WyjOobv9vt9m2Oflu1tgWAwOFSk38vEeTaCn2Mvs7yDP1e9XcscsK7Im38O+9/vgVHd6M+X9/r1wwRKnVe/K5FIPJIV9ajr+vXr+spXvjL0s0exEi+uH73rIn3vXbh8+t4P2zVq7Hqjl8vT8f3PRj/zVt8/75nn/e7dvs4bz9uN4fsd0+izRkHD7/UapZn/oPf5fr5/3hgedXnnaZTy/Xbj+n6uR9HC+f95z3/UmN5uLOftgdH7vdP38c7M93Kf0T32dmvDeryTcfF+o+N6q/c97/ffy17CAPxeZOz7uUbn69/lM/z/z9t334u8jMrweTr2rXQynx11qh817re71+jY+P6j9Nx593vUvnyna3Penn+rs+tR17shE2+1776f7/4omFoerB29HiV//nfn6Y9H6e+3u36Q+T/vHo86T76fa3RPnLdf/J54q/PyUXP3Tt7TP/ud2mxvZcuNPvvtzqrzvvcoHfF2Z8vb3eedzM/3c9a8E3n4Qe2yH/R6p/bZ233/7ex8rrc6Ux71ve91zr+XffgoefRy8f2u+Xs5fe+zn/3s952+9zu/8zvvybm5uH64rwum1Lt4ra+vW8HSQCBg0ZepqSnrNlWv1617EZH38fGz1rlQUUlhglIcCASUzWYt7YdixKTyQG2lwOPx8bFisZj6/b6eeeYZXbp0Sc1mU88++6zm5+ctei7JaLx00aDTEG1xS6WSUqmUut2uKpWKtcTd2NiwQpYwZOiWRKrggwcP9K1vfUvr6+sqFotaWlqyjnOnp6dWBDSZTFqqGRFOItQURiRd5MqVK6rVatra2tLa2prW1ta0urqqtbU1i6gQpez3+5a6t7W1pQcPHlgRyoODA6OLb21t6emnn9bx8bGazaalApDSFY/HtbCwoMuXL+vo6Ej/9t/+W/35P//n9fjjjyuVSllUzhf6JHp0cnJineeOjo7sMAwGg2o2m3rllVesk9tgcNYV6sqVK1Y4mQiaZwx4xpj0sK4Av6fbSTAYHCrsy2dPTk4sxeTBgwfa2tqyDnV0jaJbHB1UBoOBfvEXf1HPP/+8crmcyuWyms2m1tfXdfXqVcXjcY2NjVkK3/b2tr7xjW9obm5O9Xpd8Xjc7hcMBq04uY+cwiSDfl2v1y3qSYoYBboPDg701FNPWRoNUWdfUBS5pgtPuVxWrVbT/v6+pZpNT0+r1WqZcw9D5Pj4WAcHB0omk9YNc2Njw1JKSEGZn5/X6empGo2GpqamlMvl9Df/5t/U448/rvHxs6Lwq6urmpyctLQUxhn56dwAAQAASURBVEVaJB0pb968qWw2q3Q6rVqtpng8rt/7vd/Tzs6OotGoqtWqqtWqxsfHlc1m9cEPflA/8RM/YXtyenraUnlIzRwMBorH41pcXLQUmbGxMescR+HUUChkuuH09FTlclkPHjxQNptVKBTS7du31Wg09G/+zb/R4uKiJicnrQsmck6kmzH+tb/215RIJPR//9//91Ab51arZem5pVJJ6+vrGgwGlpLA3MfjcZPjw8NDxeNxHR8fq1QqKZlMqlqtKhwOK5lMWkQd3UE6WigU0v7+vsrlsur1ujqdjubm5pROpyWddWaEZbS7u6v19XWdnJyoWCwqGAxamunS0pI9//LlyyoWi5qfn7e59YX4j4+PVa1WLV2q0WhYMWaKZ0uyrpGLi4tqNpt69dVXrRPXycmJotGofv/3f1+JREKnp6cqFos2z81mU71eT88//7z+w//wP1QikbAOT5FIxNKYL126ZN2Kjo6OVC6Xtb29rVqtpmKxaF3ISB1D756enqparWpxcVGLi4v68R//cSWTSWOvkKZ5584d5fN5YzjAdIElQ1rlgwcPrHgwaxkIBFSr1XR4eGj7sFwuKxgMamFhwWQP9sn09LTS6bTK5bJOTk60sbFhXS4DgYB2d3cVDAYt1X18fNxSsdFNnrWEzJHmR5pWs9k0xiedJ1mXVCo1lDZEGtD+/r5eeuklpVIpNRoNdTodRaNRBQJnqS2kRzcaDVWrVWMpUGCYTp4wMnyB53w+r3Q6bfvWN0JIJBLGwqAocTqdNlvh8PDQGgoMBgNrODIzc9adkC67k5Nn3RQ/+clP6tKlS5aGvrCwYOf0zs6O7t27p0QiYTJy5coVY9r5lu+kZW1sbGh9fV35fN72Nl2A0X337t3T0dGRUqmU6f5IJGJ6AX0JewPGEwwZOhu2223rRohNQhODTqej+/fvDzGtjo+PtbOzo8nJSW1vb0t6mOpBkJG1pQA0aXzpdFqdTkcLCwt64okntLGxoRs3bujSpUu6fPmy2U61Wk1/+Id/aAzF4+NjY4LRfKBarerk5MQaJFBmYH5+XisrK8ZmgiGUSqWslAGys7m5qTt37lgKG/pHkpVdkM6c1UKhoMFgoCeeeEITExOW/r+/v6+pqSnduHHDUlS3trZ07949K6MwNzdnqZp0iGOOx8fHde3aNX34wx+24tx0dW00Grp+/brGx8d1/fp1HR0d6V//639t+4U01amps65q8/PzNpetVkv37t3T448/bl2C0UXB4FmqPc+oVqs2t7CWfGORqakpLS0t2b5Bl73++usqlUrKZrOanJy0czSdTmt+ft7knb2Wz+eVzWa1tLRkbDzP9iGNj6ZCHjwJBs/SoOlACtuHhhyTk2ddgukGSGkM0vuw8wuFgs1vIBDQT/3UT+ny5cuamJiwEgl0lUb2PRvs8PBQxWJRlUrFOmtms1lFIhF94QtfUDQaHWpQ0ul0VC6XbT+wb/v9vnXh5fynMyflAbDLJicntbOzo89+9rNaWlrSG2+8YSxxmJecjfv7+2Y/LSws6ODgQJubm1bagXTeQqGgg4MDJRIJ2zuw0Jg76axkRSQS0cbGhp544glLmb+4Lq6L64fnugCl3sULg4zitBhDgUBgqNvWycmJRc84PMnJljTUQlh6CCTwB0N39Oc4Ffx/9Pe+DThGjv8O9W747Pj4+Hd9j/oX/A1913cSgybNe/JuflweLMGYZc6YF76LEcqcjI6VfxN9YRzcx3/Wd4tiviXZ2LzzjCEwOv7R50I9J02Auh+np6ff9XyfasDPO52OPdff36dFcuAjD55u7SnjkoxKHQgEzCDiGl1v/968J397uWRsbzUPyP6oHI3KI2s0mmYFKOXHhMHm95GXNz+n3jjESXvUWPiDs4rsAaz4z/j19/Ln/+1liXX38ufXmz+szagsn7c2/m+caP890sn89xiD/z9pC/5n/J8xnbe3Rsfl9wxz7TujMa9+PPyOdeW7yA6pX14WAQsfJaN+HUffjRSHUb07Op7z1h3n47y1P28fdLvd71p/r+uYM57Hs5inUVllTn2tDtac9ffr5tfHP5/6OufpI/7PuPisBzlGZcKfGf650plD7z/HvPo18nLjz0W/p/3PfUfG0bny/x7VDcwT42cco6DU6Bno78lY+S7OoC/SzTw9alzYBaN6FlDK177ied6W8LKCPUH6Du/sx4Gu9DLg9ybt5/1c+mf7d+As83PJ70bXbtTuYD96WRvVb8jLeXray5E/O0kpGgWl/HfR5efJlj8n/NnG5Z83qju9XXPenvXv6/e9PwNGv886MBZkzL8PMoB94X/un+P/eP3p52XU1vDv6M/YtzozR23PURvtPF2LTI7aOPxuYmLiu2xl1hW95OeSe42eq35d0Ol+jrweJL1u9Gwbtde9jvT2+ahMeVvM39fLK3qSdUaPeDvA61EvTz74MzqG0XUe/b7/jNcpo+tKGrd/b29X+rXx+93rGD9v3mbh3TnHRscPsOnf/7zPen3K/UblDJvSP5vaW/ybFNP38oVsfT/fu7gurj+N6yJ97124fpjT9y6ui+viurgurovr4rq4Lq6L6+K6uC6uh9d7MUUNn/SXfumXvu/0vX/2z/7Ze3JuLq4f7uuCKfUuXnRne+ONN7S2tmbR/1AopHA4bMVXj46OrHtdIBBQs9nU0tKSRX0k6eDgQLlcTvv7+4rFYpI0VCCQwtnNZlPdbte64hBtmp6eVj6f10//9E9bWuHs7Kzm5+eHqN90/oLuTVoIqT+kJ5GOSKeuXq+nYrFoqRVEn3yx79dee81SikjPajabmp6eVrlcVjqdNlZLLBYb6g5ENI4IVC6X0zPPPKPNzU01m00lk0llMhk9//zzSiaTeuyxxyxlQ5KlE5KSt7u7q9u3b2t8fFytVkuvvPKK1tbWjLJOQdc7d+4om80qGAyqXC5bh51EIqEnnnjCOnCNjY0pFoup2+0qEolY15FsNmsR1UajodnZWUUiEVv7drtt3XZIRaPzT6/X04MHD9Tv9xWLxXTlyhWNjY3Z2vqisaQJ+mLlFIakEOfJyYnNt6/tcXx8bCl2Dx48UKlUsqgtaV3xeNzG1G631Wg09JnPfEZ/7s/9OR0cHKhWq6lSqSgcDuvSpUvKZrOWtnh8fKyNjQ19/etf1+npqaXdLS4u2jwQ4SaS1Wg0tL29bSktrVbLUgqZ3263q3g8rmq1qkgkoscee0xXrlxRKBQyRlm327WUC6jtFM0sFouSzlJG6MbS6/W0v7+vTqejb3/723rssceUTCY1GAx0cHBgaS77+/u6c+eOpfPQ7Y/5fuONN3TlyhUdHx/rr//1v673ve99isfjCoVCmpiY0M7Ojmq1mjqdjg4ODiw1bGpqSrdv31YoFFK9Xtf6+rr29vb02GOPqdPp6MUXX9T+/r5KpdJQ9HBubk4/8RM/oY9+9KMKBM46cCUSCfv39va2zdPc3JxmZ2et82axWDQK/tjYmObm5iwNijTH1157zVLsbty4oY2NDW1vb+v1119XIHBW9PQb3/iGwuGwotGojo+PjdlBiuanP/1pZTIZvfjii8rlctYdM51OWzfPWCymVCple5Z0TtICDg8PNT8/b2nP09PTKhaLmpubU7PZtLQqCt1C1yfyOhgMLJ2l2WxqbGxM2Wx2KE2TbnCkzxSLRdVqNYvEXrp0SU8++aTp4bm5OQ0GA129etW6fJ6cnFja4d27d5VOp7W0tKTj42NLr5RkxXV7vZ5yuZz29vb0Z//sn9Xp6anu3r2r8fFxLS8v23x84xvfsHPk5OSs26aPal+7dk2f//znTRdQVBh5CYVCWlpa0vz8vHXSvHfvnukg0mwODg60t7endrutS5cuDRXu/eAHP6hr165paWlJ3W5XrVZLjUZDpVJJf/RHf2QdoKLRqNbX1+0cODo6UiaT0d7enl5++WVdunRJ3W5XX/va1/Sxj31MgUBAf/iHf6jFxUXF43Hdv3/fzsVMJqMnnnjC0uWQX1LiJBlLodPpDKXt0M3p4ODAUv3QYXTMSiQSpndIo52bm9OlS5ckyd49Ho8rHo8PFU8+PT219B5SQnd2dpRMJlWv1xUOhy0lt9FoWNpyo9FQvV5XqVTS4eGhFQfnXVjD09NTRaNRTUxMmOyQpsV5wllP6g6fJ21Fkl5//XWlUikr1A57gf8zl81mU+12W9lsVp/73Oe0urqqsbExS/mdmJiw/Qdzjevk5GEjEdLoDg4O1Gq1bP5nZ2ftLCWV5+mnn7b38uk4+Xze0sfT6bQVbT4+Pra54u+DgwPr0tVsNrWzs2NzRKoZTRvowlur1XR8fKzNzU1dv35dpVLJOu8OBmfNJRYWFox56hko6L3FxUVdunTJZOSZZ57R/Py8pZwiW+jte/fuqdls6uDgwNJJ6ejobYVEIiHpzEkuFot6+umn9dRTT2llZcX2VzQa1fT0tJ11h4eHKpfL2tjYsG57/ow/OjrS2tqa6WQ+Pz4+bvZFoVBQtVpVo9FQNBrVU089paWlJZs7z9q8c+eOvcfU1JSda5zxTzzxhN7//vfbPmb/IWeLi4sKh8PKZDLWxe/NN9/U0tKS2XsLCwtaWFhQOp3W+vq6yQ0633d2u379ugqFgsljIpEwxg4pnIHAWbdV9i9poHQk7Xa7Zs9Q/sDvQUlmb9ORr9s96xyJTE1NTWlvb0/Ly8smP51OR2+++aaxf3zXRLr6zc3NDcmaT0et1Woql8tm+6D7u92HHYOR69PTUz355JNaWVnR4uKiMelbrZby+bzeeOONoW6EMNvotH1wcGCptbOzs/rc5z6nWq2m5557bqgQPh2IsanZr8jX1NSUDg8P7Qzu9/uqVqsaDAa6d++erl69qt3dXX3hC1/Q8vKyNjY21Gw2h0pRzMzMmE6fm5tTPB7X5cuXtb+/ry9/+cvKZDJ66aWXtLS0ZL7C/v6+arWapdnOzMxYd+O5uTk7P6vVqjKZjOmd84pvv5euC6bUxfWjdl2AUu/ihaNHzQ9P4yY1BVCK2kbSmXEVDoe/C5SiztDBwYGlbAFKYRy3Wi17tgelcIYwhKFHA8B4UOrg4ECNRsMMJ2rk4EABSnU6HTUaDQOl9vf3jerrQSnotOTDUwcLhwb6OO/F/Y+Pj+1wAqzwFG3yzLn35OSkGo2GgsGzNvO+A4sHpXg/7yCQr99oNKz+FOvVarWGUiu73bN0JD4LKMU4MSToeELXJmqL0IEHUIqxMN79/X1Jsu8AIPFupLgBSOFc0ilqtLsPzg3GLsYldH8OcdrVA8qMjY0ZMOnTBn19iFqtZrXR6vW6ut2uGVbMC/XJGo2GgVJ0qsEwwsBjjpkT0j4ApWirzOcDgYDVOEG2PSUdg421PT4+NlCK1sb1el2Hh4e2Jrw/dcvYp8gq+wtjXDrr3sKepuMU8l6r1VSr1YbSZfjZycmJgVJ0k2o0Gjo5OVG9XjdHFmeX9WEuffpEvV5XrVYzAxtnsd1u2/yT6uDTgXDkAKUAaABWWFv2Mf9nXBifGM+SzGkcGxuzucUB5R2oI0fNjWazKUnmJI+CUgBK09PTtl+mpqZML7I/eEdSl+jYhUwAUgJKIY+Tk5NDoBQA+f7+vulhxoDskA4yGAxMr5KWQ7CBn1PnCmeC/YS+8XOKzgXUR4fx3qOgFHLAnvR1jqampmxfAHYAWADQIY/sbfZ0u93W3Nyc6eXT01OTM9bcAywEKZBJgHpAqYmJCdvb0WjUdFy9XlcgELC6cezrg4MDAzrQBz7lzaeBeFAKUIPxAUqxtxgzQAK6EB0tnTlEc3NzJgeAH5x96Dfkvtlsmo5hrOw55IWfI0ONRkOHh4cGMPsL3cNzAaUYc7PZtHNxFJSSZLoIuWevoed4Jk4m50yz2bQzGlDNd1CcnJxUrVYzQMsXFu52u0NBMvYAoBRgIXuC+UC/eFAKeQbwwHF+FCiFzDYaDTvP2bs+RQ9Qiv3EvKGX6NTKvZvNpu1rn84GKEU9IPZlvV63bmrM9WAwsGBfrVazcxXwHlCKFEl/5qLv2XehUMjmCh1IihNz5/+gj1lXzjsCBuiZer1u9gdzwfnIMz0ohZx7UMrvWX8mtdttW3fmjnpo2EOMl9pBzBvBt/HxcQOG6vW62QmAXLVabeiduUihw6aUZLVGR0EpxoccAa5ix/uuhT6dkDUDPJqenrZ5oy4c7+9BKWzE09OHHZl9GQxsnaOjI9PRPO/4+HgoLW4UlOL5dCkcGxtTq9Wy+7DvCUCi/zgbmSt/5iMj6EQCa+g+9B/1ZLEDvY5FrryN1Pj/64jxfJ+a2+l0zIYD3KrX61Yrk/qc4XB4SNbR775GoE/3xe7FB8J2eS9fF6DUxfWjdl2k770Ll0/fg43i/36ri+k/73PvxtKMdtF41LhG6ypQs8L/f3Q872R8b/WZ0Xue10XDf8aPyf/e5+r75z5qvL4GwOjvznvP8579qLF/r9d54xxdo0eNZ/S572RNz/v9O11XALJH/X70/p7pNjp/593jvHH47583T9/vvnnU+o/Ou3/2O92Pvg3x9zKu89YIJ/y87/pi94/SNeftJf/Z88b4VnsSZ++t5J3PAtz6e34vunH0vc5bM/8e72R+H/XZt5NN35XsvGe+1R59q+vtnsv6n/cZgObR1taj8jq61vzu7fag/95bnQWP0tfn/f+tnuf/f55ef9R8vtV43u49z9vr/r6PGvOj5uGtZPtRY3yra3T/fb/nzNtdjNnL0juZ/7eTobfa9+fdz4OOb/ccfv5WeuHtvsuz3s4OGR3TqHy+layM/v1O5pHPndfJ9VH3lvS2utl//jzdzruc133trfQG13n6cVTvvNXa+Pc+b4zn7a/R/7/Tc8V/d3RPj+q88+49Ovbz5v7tbLe3O0ffTnZH7zsYDL7rPBg9s9+JHjrvTDlvXKPn01v5Cf752Eh+Hd7KJngrHT/6rEftL7+2/vvvxRQ1fNJf/MVf/L7T9/73//1/f0/OzcX1w31dMKXexevq1asaDM6ih9Fo1BgRdIEiKkZHMEkqFosKh8Oan583NB/mwP3799Xtdq3zkAcFYCdRMBH6PYcEEdSf/MmfVDgcVrfbVSKRUCaTUT6f1+zsrHV6odsfkZSbN29qaWlJ2WxW4+PjOjw8VCgUUqlUss5ZR0dHev311y2l5uDgQIPBwAoYZ7NZlUoli8SPj48rl8tZmtLi4qKmp6ct6kNHQRgDdAXLZrPGhJmfn7fUBTrNXb16VfPz81pcXDRaN5GeSqVikddOp6OtrS2bq42NDevAMjk5qc3NTcXjceuGEwqFLIUIBsAzzzyjUCikXq9nqU71el2ZTEaZTMaKmdL9CgYN7B9JFi0jekQaXblcViaTsTSi+/fv6/HHH1cgENCbb76p+fl5HR0dqdvtKhaLKZlMWmewcDhsDC2eB3WeKGe5XFYymbRiqY1GQ+VyWe122xhiklSpVFQsFnV8fKxwOKx6va6ZmRkdHh7qIx/5iD7zmc+oUChYt6hEImFRWFLA6OjzrW99S7lcTplMRqurq1paWpL0sMikL6RZrVaNCk7EsF6va2dnR5cvXzZ2GCyasbExzc/P64knnrDIFxG8SqVi0TfmZXp6Wnt7e1pdXVW9Xte9e/eUyWQUCARszYlm0xmMLm+Li4va29vTvXv3lEwmjUFEGhdsOfbFf/wf/8d64okndPnyZWPZ7e7uGiPHd9AKhUIql8sWCQ2Hw5Zetr+/rz/4gz/QYDDQ9va2rdPJyYkikYg+/OEP6y/+xb+oXq+nzc1NLS0tWYSfPU0qw/7+vuLxuA4ODlQoFDQ5OalsNqtkMmnMCNIZtra2VCqVNDY2pqWlJev8VyqVdP/+fX3lK1/R4uKidbOh09BoAe9PfOITSqVSevnll/XgwQNNTk5qY2NDq6urajabmpqaUjgcNkYP7AyM6MFgYB0QJycnlcvltLy8bEwsOnqyP3d2diwNF3bQyclZ98vBYGBdz5LJpO131ocIsyRtbm4ag+zk5ESpVEqPP/64VlZWFAqFtLy8rEQiYawgUuE8U3VsbEyXLl2y1Lh+vz/USRMGC8/t9Xp68803ravU2NiYcrmcXn31VdPNsEVhIjabTT333HP6whe+YLo0Ho8rmUwqn8+rUqno8PBQ0WhU8XhcqVTKUsvu3r2rra0t09sw+GCrHB8f6+rVqzo9PdUHP/hB3bhxQ9Vq1TpWoqMHg4HpC1I/SOFKp9OKx+OmUzjXfHHv3d1dY+C0Wi2TTVKCFxcXrZso3SNh5jBPPqUO5gWMna2tLRUKBU1NTalUKikQCCgSiVgXK2SgWq0qkUjomWee0cnJiRKJhKXtMV6YKbVazbq2wRbIZrO6f/++dTmcmZmxMwLGE2wPn3ZPqvTh4aFSqZSOjo5UqVSUSCQsvRfmNWcDjhXsYwrZkxZKN9/BYGBdBGHmcPV6PesISZr02tqaPvWpT2l5eVnHx8daXFxUr9fTk08+aTrUO5aeuSY9TCcrlUra29tTOBzWzs6OZmZmtLm5aYxRUtzi8bidF6enp6pUKrp586a63a5WV1fNrqCzHkwyugUis9/+9re1trZmLJxSqaSZmRnNz8+r2+1qb2/PdAZny2Aw0K1bt5RIJDQ5OalyuWw6jO6isEKRM5hQpBNdunRJExMTSiQSVhYhFApZ8XJYiXt7ezo4OLDOraTZ+uLeyAOMpGKxqOeee07PPfecrl+/bixpzxqH3VOtVtXr9VQqlfTVr35Vy8vLNoZgMKhMJmPdADnvC4WCHn/8cc3MzGhvb0/ValWVSkXRaFQf+tCH9Pjjj1sqGzZtpVLRl7/8ZWO/R6NRk3903tWrV/XhD39YgUDA3i8cDmswOGOO3bp1y/RCu93W7u6ufRabN5FI6Kd/+qe1tLRk+3xnZ0eZTMbS90l9ZW9NT09bt2L0HHoiEAgYywzWJJkIdIUsFovWfbVUKuny5cuKRCLG2oFZG4/HTS45X4vFonq9nm7fvm2dVDlPYUhiA1PKIx6Pa319XfPz8yZjjJ8sinq9buUcTk5OVCqVjIWPvQAbCHm/d++efvmXf9nsi36/r42NDf3xH/+xlcvI5XJm6xeLRZXLZVsD0vB+4zd+w3wOuhySakq3x2q1qtu3bw8VDGc96Fx4dHSkXC6nQqGg5eVl0wW/+qu/qoWFBe3u7mowGNgZGo/HlUgk7N2499NPP23dh0m35Iwh9VA6Y5tio3POkjFBJ170Min0F9fFdXH98FwXoNS7eGFgU7cCeiiUb+i6tASmBgpUZ7qdkcdOqlCz2bRUl7e6zlOwW1tbBkrR6jqfz2tmZsYo2oyHg4qDAnr50dGRZmdnLfecfG3+Pz4+bil9OAi0bmcOiE5gGOdyOXP8+P3MzIzR9fkZ6QuBwBkVmzpMgFLj4+NGa6adLGlr5XLZHKzj42NbH5wf5pTW37QkxjGDCizJHH9adc/NzVkKAAAA4wTM8S2s+R2GmgeldnZ2rPYCqR+bm5tmFGxvbw+1kYYyT4tqKOPIjQelkKlKpWKODbT7arU6lE4pndVbYmzMD3K4u7urzc1NFYtFM7SgsAcCZ7WMcDJqtZq2tra0u7tr60lahZd15IIW9YCp3JsW8bTTBnAhTZRURRww6OrNZtMct4mJCc3MzCiXyxmdfHt7257lQSnSTgaDgTlyvn6Ep3yTojN6bW9vG4WeCGUulzOaPXuIdcJZARDDCG78/3W2+v3+ECjV7XYVDoe1urqqzc1N9ft9bW1tDXXWIkXFpxOTelEqlTQ9PW0GOjW52u228vm8ySNgqgeltra21G63tbe3p1arZaASazMYDAy03draUqvV0sbGhjY3NzU1NWVAQavVMlAGUIrUZB+JBVyYmppSsVi01Knx8XEzUAHddnd31ev1rN4aoBSpgPv7+woEApYaSuqzJEu/kc7SgtBLklStVrW1taV+v69wOGzpbqQSAwAByEsyXUqqzmAwMIAUR4v3B0wAuES/ARByViAjpCQfHBwoHo9ra2vL1nN/f9+cvVqtpqOjI83NzZnOQDdtbGzYOvh0B592jd5Kp9NWBxBQiv3Q7/fNoY9EIgbmk3qL00wdm7cCpZBNv59xaqemptRutw2U8nX0OFd5HqBUs9nU9va2AV04X+Fw2EBE9DwgG0Ajjiv7lPECfO3t7WliYsL21dHRkba3t02/z8zMaHZ21vakT8UElMJprFarkqSdnR2TuVqtZulEgALoJHSKr3MTCAQsLXR8fHwotQXgiXtID1MVAazQ0VtbW6ab0TcExQBTpO8GpRgjNYsApXZ3dzU9Pa3t7W1LGSPdhjpVtJ2vVCoWOCJYhDyTjh8MBi0tEZll3kKhkIEn1KXpdrume3GuGTf6HMCXa3d318Af3s8DyegRznPOUFJRAadJDwOUop4V5RdI8QoGg5aaCdhQLBbNQUc3Mf/YNwCwgJ3FYlFbW1sGUgK4A7YVi0XTbZVKxXRPLpezfdNut7W1tWXnaiQSsbO7Wq1qZ2fHQMxoNGopk36OVldXFQgEDDgMhUIWYNjd3TXdiZ4CoBsMBtrZ2bExYE8S1CFltlqtWgo2Opf9Rk0jD0oh76Sxe1CqWCxqdnZWxWJR+XxeY2NjqlQqGhsbs7ONcxS7aWZmxubg9PRUxWLRzmDsbOb98PDQAniAUpFIxALWnJtjY2M25wCHtVpNm5ubQ4FFD0r5+pTI+9bWljY3N4fSeDc3N7W5uWm2S6FQsO6jxWJRlUrFZJl0eexP9Az6hffb2tqy/fooUIr9lc/nFQgETK5arZa2trZ0cnJivgbjIEWPdeLekUjEUmEJOh8cHNhaYku2220DLJHH4+Njdbtdkw3sgn9frnfKyr24Lq4fhusClHoXLxwh6n5wgJBnTRE/H7ELhUKKRqNmCHIAhcNhO9ipkYLxhEHDwSTJHHCM3n6/b0p5enramFGBQEDxeNyMMhhJRFEGg4E+/OEPKxaLWSQT46JUKllBzP39fSWTSXPkpqen1Ww21Wq17OehUMgOOaI9OCSj9UGgCwOuULDYR2JbrZay2ax9jqK+vV5Ph4eHFp2kZkehUNDe3p5FryORiDnD0WhUh4eHxkoZGxtTu93W7OzsUF0I/viIaTAYVDQa1fj4uNXjITpN/QQiQisrK1YDBOcqEAgokUhY8dJwOKynn37aIu9Ex/heLBazKDlFy5EVijmmUikrKD8YnBWx3dra0urqqkqlkkV9t7a2tLy8rLm5Oc3Pz2tvb0/FYlGTk5PG5sNwB6CTztKXVldXLcrUarWGDD5k3s9FOBy2QtWsGwUsg8Gg9vb2rEA6rADq60xOTlpB93K5bFF9ajUhL6VSyaJfGJgTExNKpVIaDAbGkpmentbKyorN4/z8vNXOwaCDHRCLxSyaSPQSh2ZyctIMx7m5OQP0MIr8d05OTrS0tKRisahsNmtOoKfZHx0d6fj4WIVCQf/oH/0j/dzP/ZyxumAKVqtVxWIxA2z7/b5CodBQgeFMJmP7Lx6PG7sEZwJHpF6va2lpSSsrK4rH42ag1Wo17e7uGvgVCoU0NzenWCxmeiIYDCqRSGh1dVWSjNnkxwMAxFxIskgmzQyQKWprwDRjztgrRMJhlFHQHHCFd0fmL126ZA4CoBJ1STyY6MFQmB8zMzM6ODgwWUeu/XuGw2EtLCxodXXVGCt7e3vGzrtx44YVE6YAO47t3NycEomEIpGIBShIYZAeFozudDrK5/Oanp5WOp22wudHR0fG9EGPUDAXmSToEI/H9e1vf9v0MPp7d3fXmKaHh4fmNAF0AXJMT08rEomoXC4by4G6QoDh7IlOp6P19XWTMQoNY/TjIGezWWPHDQYDA1JisZiB3tVqVdFoVMlk0hgDu7u7mp2dNVAPkGp6etoYfp7BkslkDBTb3t42hxVAi6DEjRs3VCqV1Gw2FQ6H9eSTTyocDhszkPOFc7nVamlvb8+KKgeDQRUKBWuEEI/H1Wq11Gw2rUnBYDBQLBYzvQhwCCOSfRcKhXRwcGD1CmdmZox5BniFTmZf+TkkmAMAiaN86dIlTU9PG0OQ5yAv0WjUwM6TkxObU5ojTE1NaW5uTru7u3r66afNqQds93XHWHPWnTHxdyqVMgAmnU5bPaBUKqX5+XkLksGWDgaDyufzunXrlnZ3d5VOpxUOh9VutxWLxRQMBlUqldTpdPTss88agNfv95XJZExXT01NKZ1OG1gOY2JnZ8f2I/PFfHrgFJAP9iU6rVar6f3vf7/C4bA1WGm1WsbS3d3d1enpqZLJpF577TWbf9YN2eW8SiQSBjhSv4umL4BhgJKVSkW5XM5kZW5uzuadwBRgJGw/wNN8Pm9NGFKplAHtBG6YHwAwztlAIGCNDF5++WUFAgELPnB2YkNwVs7NzQ3dq9vtKpVK6fd///ftbEK/StLs7Kze9773KRaLKZFIKBqNGriXTqdN7wCyA0g9/vjjikQiCofDQw0JkFPklrO2Xq8bQ8vXVr1+/boVsSfwAHttdnbW9ixjIcCFDUjzgtnZWZNtQHbqTiFz2WxW8XjcAG+A8Wq1qnA4bEG14+Nj7ezsWGACewYQHrYWBdTn5+cNrOn3+0qn03YuA/ICdBLsQdax5ePxuIGfNLMplUpmNzK/nOnML+fm8fGxZR0AiM7NzZmMBAIBW6epqSlJMhasDxYBDJI+Rj0udCW6iKYz4+Pj2t/fN8DNrz9psB4sZXzv5evt0m3f6nsX18X1p3FdgFLv4kXXLtKLUOzhcNhSOHBmMHgGg4fdIYisDgYDo6ACIGGMQg2ORCJDoBQAB0q4UCgok8lYGoAkhcPhoS6A3umjJhYGmT/giezBahgMBkokEkYpl2RG1Pj4uNGnpbN0MLpdFAoFMxBrtZqxyXwBb0AmCnv6qDL0bUkWxZmbmzNHD0MEAygajVqxXcBADHIOalLaMDyItg4GDzv2nJ6eKhQKmYEnnUVuMNgw5GdmZiyFD4OQucexJsWOItcYBACIyFGr1VIikRg6YHFGkR//HQqCwjIgZQegDHALNgBGFakRFGZGHli3XC6nXq+ndDqtWCxmzsPc3JwVDQUkxXhGfuisBpsLYI/xHB4eam5uzkBLAA6MPJxh5M3XA4BKj2MFAIC8Mq+MD4eUex8dHRnrhfQpgN1oNGrOYyqVMsMLZhpzNQpKYcTjNGPwYfgyN1zICeMEyCDdl31JugnGM+wFAAmfuoNxSaoHwDfywhzBIGOeYXPipOGsEPnHqGVfSDJ5QyZJsWT/xGIxhcNhJRIJ7e7uWpc9iq2nUikzvA8ODqyLnySlUqmhQtNeR7KXPIuG/c8coLNw6Ekp9d0CSZMiRY/0vWAwaOml/X5f0WjU9Gg4HLb5GwwGtg6kMgKwA6IBUrOuo40JfF0RdCl6lwACbBIcJHTH9PS0pZMwBxSKx0lhXZAfQHHfxQ1mB6AUjnin07H3oFAwskcABAcU9iPAIXqJC+MY/QeQAQjGGcZeZ9/yHoFAwJgdvC9zybnDM5BLUugIOvhzCvYwexkdRTql3z8wxnCsCFL4+aRLFCAoIAE2ACwYzmzfCQ+wIxKJWEH4TqdjDqBPP2Jc2A7sQxiY6XTa/p1MJofOQ/YvMkw3TlJZksmkyRDyCKNvtNYQTp6vF4NNAwAnPQSnJNm9aACA7uU8Ru8hR5whOLmcn5w9pF7iREciEbNPSNP048SuIM2auUDP0LmPccJImpycVDKZNGecZ6EfAX6ZB84KQBsCCqFQyBgcAFmcicgU+/Tk5MTSYZkf6WF3MtIE2RsE2tLptBKJhMk5NkAwGLTUc1K2sRdpmoCj789rdCI2KGc6eoB3BtQkkBkMBofSqDkbZ2dnbUwEJPg94DL2HDLk01WREwqhY6+yLufVfEJuPcPep6JiW3mQBN2E3kAPoduQdwJn6BRsGXS0b9iDbYEdjh5jbllb35UzEolYhzlf56nb7RqI3e/37ZzgfOcsJCDN+cVcoF99AX0CjrFYzNY2HA4bWMx6YhvEYrGhNHfmE5uEjrPtdlvpdFrHx8d2hsCqjUajdi4gCwSUmN9IJGK+Auc7esaDXezbUVCKvU4GRyqVsjPfs1Pfi9cFKHVx/ahdF4XO34XLFzq/uC6ui+viurgurovr4rq4Lq6L6+K6uH54r/diMW980s985jPfFSB6J1e329X/+X/+n+/Jubm4frivC6bUu3hBTQXphzYKcu/TRbiIrBMt4Tt83qP+0nd3IfHpZaNRS1gSsDOIktDK2EcRGQd/zos6wVwiiuTrU/jaErwzUXc/TiKuRDx8F47RqCZj5r5+XDybiA7jIXrG+3NfSfbuRJppg+1/5ud1dI2IyPEzxsYaeUYbqXc8d3Tco+/mx8wc83vmYnSNR//mXfkc0VIKT/u0JMbj0z35HfNPBN6z56jlwPiYU/++o/LKmGgb7MfMGP28EtXyhfz5PeldrIev20T6BePiXozNtzTnZ8gu9QhgmrAWjN2nJHHI+2czd6Q5MD6iwF5e/D72+4o6PuydwWBgkVa/v7hIl2C+Yffw/qP7iHWEReT1BGvq95mP3B8fHw+tDff27zU6Z0SjSTFgXpExvnueTuS56C7Wiv0AI2ZUfrz8Mg+stWde+T3Md3hfz/pg7Ujhg5nDfUfrzpynT/17jr7reXKAnDJmnyblP88cwO4kSky03+trH332KSNerpg39jFzBEuKz/uz4Ty55t48j5/DzOV3Xs969rBfI6/z0e3UbGLNeG8/bt6FP486N0ffw7OBuAfj8joOPUStEnSpH6vfE/4cHJ0rfufnlrWHjTa6Lv5d/PxzFkky/emfh2xLMv3p7YF4PD6UYuxtB1LGqZMFe0WSvaM/s/yZ5GWA1C3S+f0+8axQX6uGezIezje/7pwnnA9eB3pbxZ/V/uzw7DNpWOeMptvCMmW9WGd/pvFZGID+rOQM8bbBqNySCu510+h7+HfwtflI7WMNYbLwfeQWGfZ2JKwTdAq/4z6je4rneyaSZyf5/YUMwNDx4+cP9/D11Pz90K3+/6N2EHPpbStkinvCqOUd0OusAXPm5QlZGF0zL1ej+5118uuHfeBtOr9vGK+/l7cJvX0bCASMHerPWD8/Pr3OPwP2JrLI/MPq492RKz5H3cvz7HWvJ5EVGFXotVgsZsXgR/0Qz1LjXIdxygWz1+u+0fUYvfzZ4m2mi+viurh+eK4LUOpdvOgYUyqVJMnqRZAuAv3eHzDj4+NKJpOWj049EajmFD6GRk3tD+pr+PQyDhdyzxuNhn78x39ci4uLdrgkEgkVi0XVajWrF4UBMz8/r3g8bl3UfKoZRXbz+bzK5bKKxaIZW3TI4YALh8PW5Y/6CHQJgsJNkW1f6BR6MIUSpYf1Bk5OToZqpHAgf/SjH1UgELBaOAsLC+r1zjq3UVQ1EolYSkGj0VAkElGz2dQf//Ef69q1a6pWq4pEItrf37e6H6RFDgYDq0uxtLRkVHho5IHAWX2ofr9vNVOy2axarZYBgjMzM/ae3iDmWaR0UCR2d3dX5XLZ6M/FYtFSggAHcMRmZmasmCiF4Pn33t6eFhYWdOfOHZs7wCHS0IrFonUnks7q/1BkM5PJqF6vq9PpKJFI6NOf/rR+7Md+TLlczmo6hEIh1Wo1q8cFCEHaCTVAotGo/p//5/9RJpMxY3NmZkb379/X8vKyksmkGSfdblc7OzsqFApaWFjQ1taWdSa8c+eOwuGw0um0dRmiLkwul7N1hm5PkftwOKwHDx5ofX19qKAnnRDHxsb0la98RU8++aQSiYR1FYKmXi6XdefOHY2NjWllZcUAgWazafOK/PzKr/yKstmsstms1tfXFY1GLfXAOzA4Zu12W4VCQS+++KJSqZQymYwViH/zzTetRoRPtQkGg3riiSf0yU9+UoeHh5qdndXu7q42NjaM1t7pdEwXIWurq6u6du2adWRqt9sql8vK5XIqlUpWFygWi1kx/4ODA33zm9+0NC0KxlMbDFmkeDGpN3/mz/wZTU9P6w//8A9Vr9eVSCTUbretqC/FWAE8cHxIHTs6OrL6MKRABwIB29crKyvK5XJWHywYfFgwuF6vW22kVqul6elpVSoVc/ZwCCiYTPoKKQONRsNSUiYnJ7W4uKhnn31WKysr1oWv2Wxqc3PT0gOoAYVjnM1mrSMXqSk8V9KQo3RycqJWq6VcLqeNjQ2trKxYbTOKOZNKi1NHl7JPfOIT2t7e1tramjKZjJ5++mlbj52dHSs0Lp0V589kMlYjifOD+1G/zTsDTz31lD7ykY8on89b/TbSe7xzJcm6RiFLBwcHlja6t7en5eVl61ZFUWf2IzWZpIepjKT6hEIhZbNZdTodvfbaa/rQhz5kqSrXr1+31DOcsqOjI9VqNZXLZSt87oFMzjR0DmmBpEZx1lJDkW5b6LU333xTsVhMGxsbeuqpp6xbGyngS0tLVjCdxgvHx8c2DgqMU6iXNHXOqrm5ORWLRVWrVSWTyaGuUqMONH+TFoYDmc/ntbi4aLJ2eHg4lFKUyWSszgx16379139dly9ftuADHXjHxsb0+uuvK5fL6fXXX9fKyoqmp6f11FNPaXx8XOVy2eoMBgIBFYtFuwcpyNQ1e/rpp7Wzs6ObN29qYWFB6XRaqVTK9ihn4cbGhjmmg8FZMeSVlRVzdO/evWu1aLCttra2FAqFlMlkzCbifKLuU6fTUa1Ws7pls7Oz2t7eNj0ASEBNxEAgoFQqpXg8bmlPKysrunHjhqVH7e/v25l97949LS4uGmj1+uuvW42wcrmsZrOp1dVVBYPBobTRXq9n3R3Zpx/+8IctxZVUu8FgYHrO1wZ68803devWLa2uruqll17S888/b6n3d+7csfIL3W5X29vbeu6556wIPfs/Eono+vXrWlpa0r1793Tt2jVrJLO4uKibN2+qXC6bXRAMBu35kUhEi4uLeuyxxyyNlfQ9/nS7Xe3u7ur1119Xq9Wy8QcCASstkclk9NRTT2ltbU2np6e6d++e2cmkZC4sLFjn51Hdin2NXkO3NBoNlUoldbtd3b59W+12W08++aR6vZ7a7bYWFxcVDodNd7z55pu2vj4tktqapGdjY1DugYLy/JwzBz0fDJ7VWFpcXLQ0RoAcan8yBvbmYDCwLqKBQED7+/vWYGFy8qwL9dWrV5XJZNRoNMzuIuX129/+thWtbzabZrvcv3/futaGQiFNTU1pfn5en/zkJ5XL5TQ3N6dUKqWbN2/q2rVrlvr3ne98x+peoic5T7G3er2eyXI8HlepVFIoFFKlUtFnP/tZLSws6Mtf/rLVCuMsoFsrHWPRa6+//rrpuTfeeEMLCwsGhEqyUgh0hxwNANNwhNppFPl/L1+jgZDv5XsX18X1p3FdgFLv4kX3HWquSLKuR49SDoFAwAxWjCR/YbASJSbqAJuCCEWtVjt3THfu3FGtVjMHYm5uzg47agihoPP5vBXkpbaCJDOG2u22KpWKGo2GdcEYDM6KSXP4np6eamZmRrVazbppjEYtfATSdzBrNBoWUeG9/IUR4wuRv/rqq5LOOor0emfFnPv9szbsGG68C47A7OysdfbY2NgwxwEja3S8HGgATT4yFQgErGB2u93W5OSkEomEtSnmudSG8KAUdWIw2CnCSfFuDJBaraZAIGAAlCQDArgHv4PN5AvTb21tqVQqWWT06OjIiprXajUrGEtEjWtvb8/+XSqV9Nprr1nxS7ouUuAeGZLOoliMneK7GOvVanWojhGdiaLRqEU8T0/P2npTNLZQKKjRaGgwGNg70S0RkI1ugwC2gIYAjLOzs9rb2zNQ9+joyIBdGFy9Xs+6ytDdDICFQu6BwFkXGQAU39WJ37/yyiuKx+NKJpO6f//+UCcg5AsZ73a7Ojo6UrVa1auvvmpFk8vlsnXToXi/rwHBPEUiEZt730EIh4x5Q06KxaIKhYISiYTJAp0q6/W6+v3+UJ02jPo333xT0hn7olwuq9/vq9FomCFKxB2nino+k5OTBtwADnChJwESPMMIvQMYx54NBAIGoOLII8+AoIDgU1NTqlarZrj7YudcrPuj9BPfwZkANJ6dnVWr1VI+nzdHlsK1RJCp3ULdHObJM0c8QHl4eKhKpaK9vT3l83nrEnd4eKhSqWTdNPk8jQ7i8bitazweVz6ft31RLBbNgZFkHfuOjo5ULpdNb5+cnOj09FT1et0AJ/Yjer5SqZj+BJzxLBfWhE5jg8HA1g+5KZfLqtVqBsYR8UbOkAl0JbqD7pndbld37941wGNqasqANFiOg8FgqMMbLcElmXPIOyNr6At0NXpsf3/fwCP0mnTWpS4SiSiXy9l5QAHemZkZK5xNgIXv++6MnJteLnn/2dlZ+3mxWBySxbe6fJHsk5MTbW5umqzxvsg7OoWui8FgUN/4xje0t7enyclJK9QN0PTgwQOVy2Xdv3/fzpNaraaxsTFzkJnPWq1mwSNq91FQvNVqqVgsamNjw5zPWCxmjT5w9HO5nNktg8HAiqOzZwBccYAnJyetszBF6L2OGBs7ayxBN1UYRdPT06rX6981l/4szOVyqtfrVi+HTq3UBQL0mJmZse6lsMnu379vZzNdK+n8in4AdKK+Hs0TaAbBfkB+0HPotYmJCeuyRr28N998U/1+X6VSyTrCojeazaYePHigYPCsYD86kwBBpVLR9va2yQZ1Sh88eKB6vW4/x2YgGERTC2orAuJhr3C2P3jwwLroAvxhpxUKBQPiT09PtbOzo/HxcdMFwWDQQGj2ra8rNco6ZY/RmZdznr3Z650VwE+n09b0hIAD9asIrHW7Xd27d89qXgE0Uez9+PjYup4C9HmmEAGLUChkACoBGQIJzCk2TrPZ1GAwMNuJc465hn1KHVIAdEC7iYkJ3b171/QaAG273bbOi5JUr9dNH3zzm9+0Do3RaFQbGxt23k9OTuru3bvWGZnaawBEBJwISpycnKjZbFpXa0l69dVXtbe3p9u3bxtwxlmAf1GpVOwZoVBI9+/flySbJ1/HE3uMPQLwLg0zonnPf1+uC1Dq4vpRuy5qSr0LF/m7FOHFsORAHk1RwLHg95KMRYQS8UUWJQ05vRxMXuFAeyW6j5NAIUYi2gBbUKJxKkg18tEmT3vGaYTdASuLe3nqPg4Yn8WpwTEGlPCpKp5+7VP7mBMMm9F0B4on+3QRnFvPSCAa5TvBYAz5dEtfEHc0dYTvMk7facavFZ/zlPRRarFPVfH/95RtDEj/PW94IRf+3r5wKI45RTL9wYz8sJYAjz7lAmYM6YjZbFahUMg6uwwGA2MJ+TQh1s3T7nlPGG4Y2j7qjwNLSiWf9XRsOgxSIJh1w0D3KTg+nQrZ9ekdtHvGMGTNfVrE6GdJWfGpJBTaZA/Mz8+bswL4BvV9dF+xh3AUkDOYHNDkR9Pw+v2+RXD5OYw7n2LD2sLA8MXWMaj9/UeLG/t7YuBT1Jp9zHv7tAgi5cFgcMjp9fvT71PmxafdwWzB4PRyDEDgQR7eaZTSPzo2GAak0yDnOBnch/FRNJs15f7It6Qh/elTS/x1XjoJf7gP8g2bi7ROnGnmiLFNTU0pk8kYSHl6eqpEIjGUloLc4yBRZNqfHX5vMibS5Ii44/zyjueBrJwH6DDWzL83a8j5ANg6KuMAnug59Cp6nHOhVqsZIDjKRBtNNRpdD5/uw7qj79gbXh6Re/Q9+8QDmYydcwfgz88teht2DGMGoIXBx7ry7uhoP25kjTH6FB/GBgjPs5k75kiSdXyE8co7sn7VatWY1RQkjkQido74lCHmHeYhsstzYC2wjwAXPGvEyxPz2e/37cxBlvya897ME+cQa3d8fGw6HTn15yJr5ucPefV7mkYnrJX0MM2eDnaMG93px8e7864+rRz9Njk5aUEHnyKKTsKe49n1el21Wk2pVMpYcd1u15jTpM8yZs4xWD3eRqQbs0+1o0D9qE3iL3QlMsqZSVCNs8efK6P7kXvApPWyhW2BDHhd788QdCH7zssP9oe32/wakqKILvC6nbPIp5b5fT2q273u8TauZ/jwc59G6xv9+PfgHJMeZhEwJkB1dL6XWx8Y92mRPi2ccYyNjZld7c9fzjtsemwU3tPbeoBwMDRnZ2dtT56enmpxcdFAaObCr4mfO/YdDXmQCfQO32fvnDce1tzbT1NTUxYse6/VTcIn/dSnPvV915T6vd/7vffk3FxcP9zXBVPqXbxI33v99dfNOaXLD4fU8fGxWq2Wjo6OlM1mzair1+tGve/1eqpWq6YMBoOzbnzFYlHB4FlbdqIjHOpEnGg/z4G5urqqq1evKhqNWhexg4MDVSoVoxHTnSOTyVjEUpKxOA4PDy3qU6lUlM/nValUNBgMLOrpQZz5+Xml02kVi0WVSiVrj7y4uKhqtWptw+v1uvb3960jIYDb0dGR2u22dR86PT21lC0YW0Thf/EXf1H9ft8iXr69NdHHTqdjKT+ZTEYzMzOqVCq6deuWRbgHg4Gl9kmy9B8AvUQioYWFBYsAjY+P67nnnjNKP90GA4GAPQMwwhswnlJOKgfgAylL0MCh+mOcwDqCAUT6Hgfv6empcrmcRfyq1aoWFxcteuwdHZxCGBjHx8fK5/NmfMCiy+VyikQi6nQ6+sxnPqOnn35ar776qnVZu3LlirWjbzabOjw8VCgUUjgcVrlcNgOSKHWz2TQGz/z8vKWozszM6LXXXtPMzIxWVlbUaDSGUouIEH/nO9/RysqKUqmUHnvsMfV6PUudIGWCqCuOAwZmuVxWqVSytK5CoaDbt29bS/FKpWLt5zEMafFcKBR09+5dTU1NaWFhwboYBgIBbWxsaHFxUa1WSxMTE/rVX/1Vra+va2lpSf1+fyg9kT2LDEhnBsT+/r5efPFFJRIJzc/PW6T43r17ajabarVaQ8Zrp9PRE088oV/8xV80o6xQKGh3d1f7+/va3t5WMplUtVpVp9PRBz7wAWWzWSUSCXPga7WaCoWCqtWq7YG1tTVjeUGl39zctPnZ3NzU7u6udfdiLAALlUrFOkf91E/9lKampvTtb39buVzOoqHe6YRxiEHearWMGQXAAntrb2/POr9tbW1ZChFOEGwKHDgMcOa9Wq3q+PhYxWLRIu2NRkOhUEi7u7taXFzU/v6+MS0BqTOZjK5evapLly5pdXXVDP9KpWJOXjQa1fz8vHW2pJvoKEDi158Ivu9s+Prrr2txcVGpVMpSiu/fv6+7d+8aC8aPbXV1VX/tr/01jY+PG0PpL/yFv2BA1fHxsbEOYTo9ePBgCIwG8IPNA/i4sbGh69ev68/9uT+np556Sjdv3rQ0Jroqootgkh4cHJjeOjk50fb2tukPD3SNj4+rXq8bI2xnZ8fSeFi7yclJ69YaCoW0uLho+ol03nA4rC996Uv6mZ/5GevsBcjM/DJfHgzyACiOIOcw6fb5fN6YC3SdarVatjb9/lnLdWQYkAMgGubr1taWRec5T9HHzWZTN2/eNCc7EolY2ipMjUajoVQqpcnJSZVKpSGGLAETGDcAITAKCUrduXNHCwsLBnYwd7CGvCzduHHDOuEBaPf7fX3xi1/UwsKC7t+/r3Q6rVarpR/7sR/TYHCWWgQQEgqFdHBwoP39fR0fH2t1dVXlctnGtr6+rm9961sG4lQqFc3Pz2t5ednSwmZmZnRwcKBGo6F6vW7BFe5H5zFkkdp6kixNkLFUKhVLpXzw4IFmZmYsPZKUQ9LiDw8Pba0IyNDpzndz/OAHP2jdbAFwCEZubm7q6aefVqlU0uzsrLGRAQJh3QIWzs7OWpoSwO/e3p4WFxf1gQ98QBsbG1pdXTVbZWxszHQ5euXo6Ehf+tKX9KUvfUk/9VM/pVu3bimbzapareqZZ57R5uamddQ9OjpSKpXSysqKDg4O9O1vf1tbW1uamZmxbqSf/exn7YzY2dnR4eGhnnnmGd29e9fYLugxbLdAIKBsNqvr168baPbmm29asOjxxx+3DnAwsRqNxlAgkvS9xx57TFevXtXU1JQKhYLJBJ3r1tbWhjous59h5cAOxX4CTEW/NZvNoVTdTCZjNiX7Hl2QSqWsi/BgcNbZmO5xgCywpGC8o3soa+GDZcgU3VphIrbbbWPb5XI5K8HRaDQssHNycqJqtapAIGD2R6fTUSwW0/r6urLZrDHlwuGwlcv42te+ZjqQ7nPVatWyJqjvFgicda38S3/pL2kwGCibzerk5ESJRMKem8/nlc/nLcWWswPm/GBw1nm30Wio0+no7t27WltbUz6f18TEhPb39/ULv/ALWlhY0B/8wR8YE61er9v6tttttVotW7vp6Wm9+uqrymazNj/YuwROAL3QsbD3AK8ajcZQsHxxcdHYV+/V64IpdXH9qF0XoNS7eFUqFXNY+v2+6vW6jo6OLBJBBAPgCaAEcIfIbL/fNzaKdKYgAC0kGWXeRzlxCnHMiG7i/JGGhAHTbDYVDAYNPKF2Duwfxgs1mTFzWFP7g/QfDHvADj5H+mK/37e0K+an3W4bxddHJYkskhaG48vPec/j42O98cYbGgzOUgg9uwhWCBGhVqtlfwOiVKtVS+XiXZhzQCCMR5xJ1hdjiDoIpK4FAmeFrs9r/S49ZC4wp57Bg2yw1qQ7MV/QogEkYQ9g8ABmkjoBXR2j3rOXpDNwA8MNYw4QxwMNjPHmzZtqt9va2toyWaU+AQYYjBPS+jzD4eTkxNr6UlsI52hyclI7OztDtVZwZJmbQCCgg4MDlUolS8eBaUCKDIYVtHsfsdvf39f+/r4ZOdDESeGkPhT75uTkZOizrBfgBoDw4eGh/Wx8fFzf+ta3lMvllEwmzQjEAGXPIgPI3eHhoW7duqVIJGLpVQDApPmMytD4+Lj+4A/+wCKJAEcAmsVi0UBAjFhamRM9JRUDgKxQKCgcDhug12w2VS6XbX6oc8PeADBlvqhJ1u/3dffuXQPLGo2GRUN9RJPoPFFmKPmjBXUx2En5oBaWb5cuaaiuDXqRvQE4AQANAAxLh9ozo4y+/f197e7uGrgNEAWzbTA4q1MBIOLbynsWI3IIOMVeZy0Hg4G2t7eVz+etHgv1xvL5vA4ODkx/eyDlj/7oj6y2B+nfOCwAwIDGnU7H0nV4R/QCDhtj4zx76aWXVCwWtbOzo7m5OUsRRvehK2F0AU4DBBNYQG4B61qtloH/lUrF9DBzhl7p989apdfrdZOhvb099Xo9S5d6+eWX7RyDEcTZxXyxr1kPL4c8k/REamPBpkXvUz8FkCoajQ6x2jg/SGNpt9sqlUoWSGFMOO1HR0fGgvPMFMbCuQdwBDjvCw2zfq1Wy+RCkrElqSNVr9fN+YQ1dHp6akytQqGgb37zmwYgw/TkXb/zne8MySf15iQZmIRjik47OTmxWmToiXw+rwcPHthckapG2hbMKe5xcHBgIBwM54mJiaF0dfQ2ZzdnO+cQ71soFCxFs9FoGEOIeWXN0LOwVACQkCVqGx4dHalQKBg4MBgMDIAiBb/Vaml/f9/AG85OAh98ht+NjY2pWq3aWhWLRZP9o6MjBYNB7ezsWFoksr61taV+v2/plQDYd+/eValUsnOed2y325bGi/3JHn311Vdtj1Lni7VjfjjHPCjl9dnY2Jh2d3dNHx8fHxsLz58rzDWMnFqtZjXvJiYmVK/XTSYIQlAPzTPUWS/SgHk/gHeAeGwG7hcIBCwATL0x0v0Aj8iEGAwGlr7Md5kH1pXnUKOMfcqfsbGzZhTMBXYz8k7aua+HxV4lqBwInNWVks6Cx9Ro3dnZMVuOgOXU1JQePHhgOrBWq9l9qAfrswQODw/1rW99y8Clbves1pjf6+x30pTZRwRXsOGw2cvlsgGq2O25XE5bW1sGHtNoZnp62gBo1g5AHpuMFHBScz3TFh3LeJgj7ENsgEeVPHkvXReg1MX1o3b9SKfvffnLX9bf+Tt/Ry+//LLy+by++MUv6lOf+pT9fjAY6G/9rb+lf/SP/pEajYY+9KEP6X/6n/4nXbt2zT5Tq9X067/+6/oX/+JfKBgM6jOf+Yx+67d+y5gv7+SCKknXLYwmX/sIRSjJ0H+MQ0CPg4MDhcNhO6jIJYetgyEjyQ5XaMVEiwBoYPxQZJeD1KdScEASvfHgBocsB6skGycGmPQwdYooeK/XswPcR94lDdXy4T0wBkdT0nwawOnp6dAhjoMsSU888YQ5GxzcRKI8lZn3kWQRUXLmGaNPV2DMOCzMH/Ti2dlZK2Dt0/yYS/8zL484pRgcvsaJp1D7dBfmZDSFwN8Tp5drVC78PfksBg9gCw45TCkYHEQpKfTuWV0AHcikN7jr9bq9z+zsrAED1L/C6Sbt1VPOGRPgE6kd1E+amJgw0AeDCoCDe3gQCGMcmfVpMKwH7wuDwu8Pb+hIsjRFnwKGbF++fNlAYF/TDKPSU/upoUBEn4i/T+nD2WH8yHAymdTy8rIxggAhAP889R3mDuMnuunZIxQ65V6ADTiKAKn9ft+cI4x91okxTExMKJ1OG7AFaOHTd6empow1gqPudSZyT00w1igajdqae2dUeghKMYfIBGAOTSRYM4AidCX/R3YwimHewZqAcQiry3fm87rYA+VE0pEt5gvmCvuGNAzWndoi6Fm/lyORiBXeR3/A1AIs4fxhDQALfIod4LsHbWArxWIxY4OQKsUfHGJ0AnuLPUS6FIBjp9Ox4Aj7jvlCDwIqIwuSDEjgXsgP36VmkK8zwj7lzOJePkiAnDO+ycnJoRQvv88lWeF7HwxgnT2YyRnKvuHZPmWM8wXni7lBJx4cHNhexNkD+OEc5/3QG6wZYAHjRO5IBfNBJMYGS5UmGD4A0+/3DZj3NVwA8Fg7ziCeT20bAMupqSnFYjGTG94BW4a18OlC7EHSldhjo2esP9t4Ps9hjOgW9BS1eRiTT5NChtCRzMPMzIySyaTZWvF43HQG+whZASxEX/I+3rbh3TnLYFdFo1Elk0mTN2Rh9JyDYUo9QRgnzAO2LHuD2pcw4ACBcP4nJiaswD3A/2AwsMYgfo2xt9j3gPPIHuwUzlAKohMUYb39vSj8Trr06elZrTuaxaDb0AU+xc3rFXQUthz6inMLO8czC70u41k+7d3bC9j7PuCATkH3sPeRJ+TI39PrXK8/qCvl9xdy5t8dEDAej1udLS5Abupcwe4iWC7JAkwEq8bGxrSwsKDBYGBNL3hPzhEaZ6DPOKt4DzIKTk9PLe2OGmzHx8d67LHHNDMzo/39fTWbTbM9fAdi6vkR6GFtYISyX0mXJeDo0yqZT2wAgqboEwLn77UUNXzSn/u5n/u+0/f+r//r/3pPzs3F9cN9/Ugzpdrttp599ll94Qtf0F/6S3/pu37/P/wP/4N++7d/W//b//a/aX19XX/zb/5N/czP/IzR5SXps5/9rPL5vP7Vv/pX6na7+vznP69f+7Vf0+/+7u9+z+NZWlrS1NSUcrmcwuGwOU/Uo/HRdyjA1GfAOEqlUmYQUqiSNDZYAkRJMGJ916F+/yyHO5vNajAYaH19XZlMRsvLyzY+72z56BOHGSwdCiDT/WNyctKKQpfLZYt4EcmpVCp24CwvL2t7e1uVSsXAiVAopHw+b2kfgUDAKMGAAZLs/XFa2+220um0FhcXNTY2pp2dHQOlfvZnf9ac8kKhoHa7rUgkotXVVcXjcUstgRXDobu9va0XX3xRKysrlm5CCgUdYSRZtHJhYUHz8/OWDrG6uqrHH3/cUuU4DCcmJiyVAoPDOy5EeiuVinZ3dxWJRCxdD4MJo9iDJxyi3jj1Tgmplr7mBUYG8+odv6OjI+3u7ur+/fva399Xt3vWkYcCwQsLC9rb21M8Hjfa/yc/+UnduHHD0uDy+byeeeYZXb16VZIsfYiC9N/61rfMMFxcXNTJyYlu376tpaUl1Wo1LSwsaHt72+TSr0G9Xlev17PucaSLFAoFzc/PKxKJ6Pnnnzejhwib73TmgRXqbUiyYtwYP7CScrmcYrGYGUYecKjX6yqXywaC+DQkakrl83klk0n95b/8l7W8vKzLly9rf39fS0tLFmlstVq2rqQ6vvbaa1pfX9cf//Efa21tzQDDdrut27dvD3XzxPAbGxvTCy+8oE9/+tM6PT0143F/f1/1el17e3vG7JuYmFAqlVI6nbbobqVSMcYbe/HSpUvKZDLWyQ5HhxRC9vLJyYlyuZzpjXq9bsWYJyYm1Gg0FI1G9ZM/+ZOanZ3VzZs3lc/nrRkBqXnJZFKdTkfJZNKcsLm5OTPCpTMwolwua3V1VdVqVblcTisrK2bgZrNZc7D7/b42NjaM2YER7rtR0sGNSDmOSCAQ0OLiogE0sCcAFVdWVnT9+nWtr68bsycQOOvatry8bOkdFOL1BjO6HcaDr90yNjamWCxmAPHk5FmjhEQiYSnSt27d0p07dwygxLHtdru6fv26fuEXfmEInL169arS6bQikchQ2lmhULAUz1qtZiBZtVpVtVq1feON+Wg0qmeffVYf+tCHNDEx8V0AHOlfpIGSOkMR7WKxaA53pVJRtVrV2tqaRber1aoFXGBbjo+PK5FImCwEAgHF43EtLy8bgEfqHHNBZyrYXcg5haNZT9bMByBg7FarVeuQNj4+bl2aAAkHg4EWFhYUi8WUTCaHQGlkhcAILCK6Z+FEwUxg/bvds+YDMNN8t1H0KPPR7Z51kiNAgnwdHh5qfn7e1i0WixkzJx6Pmz4NBs8K9ScSCSuQDKg8GAy0vLysT3/603rqqac0Nzdn5ydBhFdffVWNRsPS4mdnZ7W6umqgKaCxJGPB5nI5Xb9+XcVi0dijzz33nDG3fCpzNBo11jSNBACPAIQlGcgPQOjBI85BWBqwG/f39604OODvwcGBNjc3dXBwoNXVVbPTALTQi7CZaCCytLSkD37wg+r3+9rZ2dFzzz1nwADpw5KUSqXUbrd19+5d5fN5ux9sDwIDpOXDNF1dXdXLL7+sJ598Us8//7wVgoeVR2olQcZOp6P79+/rS1/6kqanp/XKK6/o2rVrVi/nypUrxvAdHx/Xzs6OYrGYrl27pk6no1deeUUPHjwwmzUWi+mjH/2oQqGQvvzlLxvIlM1mlc/njbXLPicAWavVtLy8bPORSCT02muvGXizv7+vdDqta9euaXx8XPfv3zc7jqyCUCikS5cuaW1tTdls1jpPvvrqq7p27Zrtvbm5uSHGKs0M2A/UPyOtGVANsAkQg7TIYDCovb09VatVa6YSjUatuyP2FEHnSqWiJ5980vahZ77D/KXoOdkQ3tb2mQnYKthl2PDValVvvvmmzTNnFexzH7AIh8N67rnntLy8rEQiYT4JrGkC9ysrKxofH1culzO9mMvlVKvVdOXKFQOaf+Znfkb9fl/Xr1+3ou7or3w+r6985Stm89GohX3V6/XsnD04ONDOzo7ZuQDUn/jEJ7S0tKQ33nhDN2/e1Pr6uhKJhNlYMzMzeuONN3Tv3j2tr69rZWVF9XpdhUJBS0tLajQapmeLxaIuXbqkmzdvKhaLDTHYCM5RE9H7XrOzs+/5oucXTKmL60ft+pEGpT7xiU/oE5/4xLm/GwwG+vt//+/rv/wv/0v9/M//vCTpn/7Tf6psNqvf+73f01/9q39Vt27d0pe+9CW99NJL+sAHPiBJ+gf/4B/ok5/8pP7u3/271k75nV4Ys7BPOGAADXz0HGcadggsCDrQATJBhYXNA8hBVJp74AihTOr1ujElqtWqCoWC7t27N8SUImLkCzlKGqrHAQ1X0pBhj8FIVImI4OnpqdUHITWIYpcY7qSJEZ3ifXwkm3HBUPEsLd+x76WXXrLv+DbJdMjyLBi6d2GkdzodoxXzfMYCE4zIG44Fc1WtVq0eCoaxp2aTuuej6T6KC1BGrQxPg0d+ebZnSI0CXT5K56O0MGNGmVJ8FmeyXC6bnHLQ46geHx9bvYF6va6XX35Zu7u7VjsGQPLu3buSHrJviObv7u7a+wNI0FmQTo5QwQF3MNAwJqjpAgiLY04tG96bdfFpk5KGgEDuyf99uikpFrB5+B1rC0jkO78BAgIGAH69+OKLisViSqVSxiZjnZEz5hkQ++bNm3rw4IE2NzeHUjxLpZIBpL7NcTB41mqcfQ+YBwiyv79vTKyxsTGr80XUDKOXz0hSIpGwjj3sA9IsfMtr0omI9pJiwz5Ent544w1NTExYBziAef4m7RcZo1OPjzrDriQFqt/vW7dIUnjYt4PBwJ7DOnc6HdNLOAk+DRhmH0CdZ9aw/5CHbrerQqFgUV/AYtL2SK0FWGadWXcYY+gJ9jtRYJh4AGmk4hUKBUtZBazj/oFAQF/60pcs0BAMBvXKK68MjYc9AmDkHXRSaYlm+/MBR65arWpzc9OcIc8EBfwbdQw5J3B8OMeQO8ABmhsA7DDXgGTov9nZWW1ublrEezAYDLGZSaVstVoWHGBvj54fnp0AE4/xzczMDN0DnQ+ItLm5abVofEQetoZPU4QdxJ6RZHPD82GPInekbXF+czYA0nvWpLctAKxxhgGHADH5P+ctdgdzjyx+5Stf0f37942ZDIun1+tpb2/Pgmiwvek069PrGTd7Gwd4f39foVDIzgICMZ5l4x14xt7r9ew8kx52nmVdRlmxvkQCz4EN4tkm1PySzrrL8l3mgznjHsyDDx6R4gkwDuAonTEvT05OLHWOsY6yi05OTkxfM2+tVktbW1t2H1/4m+AULLjT01PrtjcxMWFBDM/6gdWF7YMuIsXW2ztHR0d66aWXNDk5aZ17B4OB1VryrDsANp/2yH1mZ2et5g9M4kKhoGKxaAFJGLYALgSAqEUHk31vb88CDgSe0CuMwzPiAcU5E5EbzmoYkdRXxMYggNButw08IlXPlyEAbPQMN+TGs5gARwlAcGayv84DVTm7qNfK+3kGKt9B38IyisVillHAfQCGYCUBEMII5czM5XI2N1/5ylc0GAx0586doSLvnGPUYsJeOq/cCLoX0B8dK8mA0FwuZzXDADex5UjnzeVyZr/DGPblOugyS7YJZyx6knlgb8P8xmZ5L18XoNTF9aN2/UiDUm91bWxsqFAo6GMf+5j9LBqN6oUXXtBXv/pV/dW/+lf11a9+VbFYzAApSfrYxz6mYDCor3/96/r0pz997r09aCHJoj2jtHxYOvz8/2PvS2MsTa/ynrvv+1brrbW7unqd6Z7xLIxn7Bl7bBNjgu0ElD+QOAmKQpCBgEUCGCJLgBSRKD8cFAmRKIqDghwpMoTFxoz3sT27e++uveru+37rbvlRek6f+0312B638UznvlKru2/d+r53Oe95z3vOeZ7DA8mYDsuD0uv1iuImeSeNP2KsdSq3PpC9Xq9EKsjHwNRtEqoSBqedHOwL+08HDtOGtSHICxxwp9Ib+8XPaeTzcNCwHvKx8Dks4625RPQBzksjjVMahby8sRoMIYOxWGwM2sboNKERxWJRyuIeHBwAwBiEgITJnEdCF4zPopHPg53GpnYc0TDlXPFQ1kZ4q9USY5TRPA2d0DATnfrNP0bogn4no+i6aUcX101nZdFoYsYcM610Jp/FYhEnHgAh4+RlUc8PL5jMPHK73ZienobJZBKYKo1IGrSUI14wyGvCSx7fw+ihrojG52nohs4ko3FOhyv3EB0sFssRsauGaLEPXDM6o8gvUa/XEQ6H5cJLhxDLjPNyQ1mhY5fZjMwGpLHH9w2HQ3EWsB8ayskLczabHYMDU764nzh+OtWov7QBTcgEAFln6q56vT7mxOWau1wu1Gq1scwVGoJ0aPHSQ/ngOtEoZyo+5YHrpS+svJDR8ej3+6XfdIAR0km9Ua/XxfFA3dTr9UTXMCLPCySzYrhWvV5PZEDLI79P2WCUm44A6hLqdDrEONfMCCEkzGQ64vkiz16lUpHsMTprarUa9vf35ULJMfJS2+l0pIIRs78ImXE6nfD7/WOXV152mJHCvUWdwcscLwmZTAZ+vx+5XE7gn9oJwL4SUk2HDp0/hKAzMwGAZMjQwVEoFOQyRD3EjCyedxxfMBgUPcW90O/3pRw9ncY8K0jArnUJz+NqtYpAICB9YsEPPpdQU2Zhamc35ZP7S0MXAciFh84fDb/hv6nvmAHNim1+v18ybnj2ce55HmvdxAIWGqrCLDYjpIjnL/+vnbp0QHNvORwO+P1+2U8MBminKomqeWnWvDg8X8gFYzabkc1mRS7dbrfMBy+93B/6cs3+89+cP+pzreu1vqfO597kGchziftwampK9kCz2RSHMM9Bnuu0TbjfecmtVqviAA6Hw2MBQq6fz+eTuda8ozzb6aSlXiWXD7mBtM1De4OOGHIqcm1isRiazSYCgYBkB9FWGAwGss/oLGAmHvvj9Xqxvb2NWCwmc0R9zvOSWfP63CcsivZcr9cThxXPBmZoM1uW+oKywkAYHa3MiKIuJJxcZ1XSIUg50TQADIAwq5kZdjyH6DRqNBqCCKDe4nlPXajhvIPBALdv3xbHOyu5mUwmccLpYBrXnXqE8EkGk3SgkXJMvladMahtPjpRaYvz3GZmGs8tBgzolCNcmHqJZxjXk+eDxWJBLpcT/cs9T/hnrVZDqVSSe42GXzebTXGi0X5gdVs6n2gL0bGknW0MVLGSLLO+A4GA9I9nsdfrRavVEpgZgwtG1AEA0Tmcm/u9TZxSk/Z2a/etUyqTyQAAEonE2OeJREJ+lslkEI/Hx37OA5rfOa797u/+Ln7nd37ndZ8T3kUD3uv14uDgQA5lOpoACEEnjTpm3/BSMTU1JY6hQCAgZI8kXmTkW+PJabgQ2tJut3HixAnMzs4iGo0ikUhImXadWaINXcJ0dnd3pQIeLxU0gJjJwuo4xKvTyFlcXEQ8Hsf+/j4ymYwcgLzM8iKeSCQkyqejWjx8GPk4PDyEz+fD4uKiOJcODw8RCoXw3ve+F51OB8vLywJh0o0OH5LhssoKYWaJREJSx4PBoET0aNwCR0ZpJBLB6uqqVKgJBAJYW1sTw09HbomP18YDD2jCC+r1OorFIjY3N9HtdrG3t4fRaISFhQX4fD74fD4xxuho1OtFQ8DIRwBADnfOqZ4LOneq1SoODg6ws7Mjc5HNZuXy4XQ6xejL5/MYjUZ48sknsbS0hP39fZFbDWliNg3l6IUXXhDcPiFFRk6anZ0duSgDEFmks4rzZrVaJZodCATQbDbxoQ99SC4BHK/RYGO0WJPNlkol5PN5yQTY3t4WHg/CA1n9iReoQqEgcnx4eCjGMmWIl57hcIhnn30Wly5dEggtcOQkZ/YHM9QuXbqEYDCIGzduwOl04pVXXkE8HkcoFJKsnMuXL4u8E8pktR5V27p48SKeeOIJuciSK0bDV/RcxONxDIfD1xnKkUgEiUQCwWBQjMtarYZ0Oo3d3V3YbDaBjwFHWQUulws7OztyaWVlUBqrZrMZDz/8MLxeL774xS/C5XIhl8sJkTQzGwm51FFsrnm/3xejlA63bveoWiN5JMjJRYhJsViUiy+NbafTKYY0nVjUL3RmRaNRccI0m01EIhHJyvT5fFhaWhqrvler1TA1NYWpqSnE43EZE3CHuJ4OJToHKpWKZHmRV291dVUuqLdv35YKVbxY7O7u4rnnnpOqa4QVcSyJREKq7+VyOalu5fF4EAwGsbCwIJ8x4+y1117D7u6uXMRJhM7KSPoM2t/fx0c+8hE89thjUplVX3Cr1SrS6TSy2Sy2t7elwhIvf7u7uxgOh0gkEtja2gIA+P1+gcx6vV5cvnxZzkvyDp04cQJLS0tCrM6+rayswGKxiDNTX5h3d3cl2KAzLNLptFzWqItNJhO2t7extLQEALh9+zZisRhOnjwJ4Aj+zGyPcDgs3Hk6s4HPYoYkM15MJhP29/fFkcnzjvqIZxrP3P39fblEcVzkWeFFlJB3OrsYsKHTkQ6x0Wgkjn/SAQAQZx0d5TpbhA51r9eLZ555BpcuXYLD4UAgEMDCwgL29vakYq2uMkt9zf7yTMtkMlJNi1xfvOTu7e3h6aefxsLCwhhJPh3yN27cQK/Xw/LysjiG6YTWF3KdKWx0QjEzigECVhjjOUnHK4MhXB9e7lnll4ETu90+Riq+uLiId7zjHVKpb3l5GdFoVOBYmiNuZ2dn7Iyjo5P/Z8Yi1ygSiUhfXS4XLl68iAceeAAejwfRaFTg1dRthGfdvn1byMkzmQwKhQIWFhZELuiA0Vl4hCxub29LNuloNMKFCxdQq9Vw/vx5vPrqqwJDD4VCqNfruHLlCrxeLzKZjFSyZQBibm4OCwsLsjf5TjrRqLsSiQTa7TY2Nzdhs9lQKpUkK0/r1IWFBank6/f7xf5lZWdmmVI2tP0LQLIyI5GIZDxNTU2JncOMr4ODA1y9elWyQ2/duiWVcAl9Z3Y2HW3VahVms1kqFBeLRZjN5jE7Z3t7W5zwhMSSj3R2dhahUOh1XITc24VCAS+99BLS6bQ45XUwkvJLZ+b58+fh9/uxvLw8Zkfdvn0b3/rWtwBAoLv1el2yrEjVAUA44n7yJ39SeCGpf2lfpNNpXL9+HTs7O7hx44ac38yYZKYjHUt0ihFG7/V68dRTTyGZTOLatWt46aWXMD8/j+npaRlfLpfD1taWcBqy8mGr1UImkxGdxGxa3n1og7FCeblcFjuH9gXPe5Kn389t4pSatLdbu2+dUj/M9uu//uv45V/+Zfl/rVbD/Py8XOp5eDCiw+gBI2yEJRGyxCwbGnCdzlHZcl4cmS3ESDYjEjRsmY3ADB9GeHggZbNZSXvWWSU66wa4e6bUaDQSI4gXY33h19kIw+EQOzs7Aotj1SFGLfR3c7mcGFY8aPkzZl/Q0GY6Oy/dHPPf/M3foN/v49VXX5ULk258Rr1el8MMgFwMCIthBFBna+lISrFYFB4uRs6vXr0qnB86U0pD93goGDOlOM+sSsRMKVY+0pc/rtV3y5TSBwn7opsxU4oQPEaSNZSGkXYaQ6PRUZWvy5cvi0FjMplw69Yt4brQzrdutytp+qx6pElF+adarcoaARgzLBiBJVyC2Qnk9vizP/sziXpy/vVYv5dMKTppbDabOK+Gw6FkHzDDh44G7mNmEDETgDCm0WiEL3zhC/jOd74jDmjKFjMieHG6du2awBUYlSR/A2FVrErGsXCs5EMi3M+YKaWzJDiHzBJkdiEvp1o3cEzM8mG6f6lUkjVi1JXVpSg72klgMpnwwgsvwG63j+lFDdEiNIkwAq6zzoLg3GhIBLOZuEfIg8a1pY7h79AhwMgw9S+jxtzfNJ4ZpQcgGTDD4REn0q1bt0THEmbndrvHYHs6U0pnJGkoA7MaNzY2ZO+Wy2Xs7OyMQW/r9boECDTkjGMpFov4zGc+A7PZLBdsAGOZUvyMGXOEhNKJzcxfrh3PoN3dXdTrdXz2s5/FN77xDYnq60wpZtTRAcB+so/Ua263Wy7bDodDnPPkDGOQhBeHarWK27dvj+nCbrcrVQUJz6NzjHAMOm2YKcUzSGcg6kwprn+5XJYgCwDhbGEWHS/T2vFNfUo5otxy3ZiVY8yUoo7UZy77pKEn1LvD4VAgzkZYOR3A+oxJp9NyadVZK9z7wJ3ABfcD5eCLX/wirl69KplSgUBgrMKqJlEGIHLMizSdQQxS0OFFxwGzK8hbxzniOc9z9pVXXpE1Zn/5b/6f+8aYKUX7QWdKcd6MmVJGvdDtdlEoFCR7g/uNa8Hf15DgjY0NuSBTD3DPEzKloYEWi0XkgJ9xf7LqGue20WgILM/tdo9BvtgXOkVzuZxkqbTbbalQyXfyXZSBbDYrjmVmcfG84DyQO5KBKjpL6OQilJA6slqtYm9vbyxzmbLNfjDjazAYSJYns3fM5qPKgtSpdMBRV9A5oiHH+lzUmVL6rNOZUuT9o2wyU6pQKMi8l0olORddLtexmVLc6+R+ox1rzJTi2MhL9v1kSjFI8kaZUrRLmdXEbFKuZblcRjqdBgCphMo7goaXa735uc99TmwDY6YUqzrT4UuZ14FcnWmuM6yZvfrlL38ZgUBAnNjVahVbW1tyxjFLjHqIwSPuS/Jz0uahDPB3yR+rM/CYxc25M9rH92ObOKUm7e3W7lun1NTUFICjg3d6elo+z2azeOCBB+Q7Rk95v99HqVSS3z+uaX4D3ei04SHHFGWdUq+dFYRvMSJIMkEa+lT0NOL5M/4+DU0qXRp+NHJ0mj6VDA1XHj4AxnDyNE54eNNoYDW2Xq+HQqGAQCAgKdSEHwGQFF06XDgfPNT4PWbB0MnGw4VzxT5r6Euv10MoFBInCICxqlg0mLXjis6Kfr+PUCgkxhONOxoMjFbRgOTzdZaS2WwWbgE6IJh+Xq1WxYHBteQFS6clM5uIacxcF2bmMKLMKmN05PD97JfOzDrucKWhTkONh5M2mDm/lC3+Dg0ZXv6Y4s01JJyE8qU/p6ODBiqNGqfTiVgsNkbSzkwVEuXT6cQLoXZKmkxH8E8+j44ZXS2Oa6+j5pQ3bTz2+31kMhmJSrN6kt1uF6gY156XbzpPaFQzpR64U7qdEVSLxQKfzyfZOzrLiQbz/Py8jKVcLsuYCJmhI6VcLkvFHJ2GTl2leU7IyUXZADCW3cgx9Ho9BINBiexr7iE6ozQHEo1cVvWiI5ZOLDqnaVzzcsE1stvtAq3SsEFmfVHX0bnLfa0NXa4JIX8cX6FQEMgbswf5u3QUEvrHCwW5Xmj86wIPukIfDfbhcAiv1yt7jTqH5LeEHjF4QO4mDS8izILzqB3ozMrh2cLx0xlIp5zmNqK+JwyKfaPxTngDM490Jg4vptSP3MOdTgc7OztIJpMyX6FQCF6vd+zMo46gDqf+4M81jCwSiUiQxuv1ypmlne68bHFcdPq73W7R6zw7uWf4GeVAQ8cYcNC6hFlPvMST04XnE7OYPR6PVFXVUHnKpQ4qUGf1ej3JkmBGBDNxtAOO+lg7J3j2sUodeQbpJNcOSO41ZiJoomd9ceOZxHewDzpzluunob50ijHwQkLgUCiEdrsthUa0c4iywD2q4ZzMqKaeYkVSp9M5VgyEjgHaH4RL8Xyk7tPvo01A5xOzo6jDDg8PRYY4ZtojJFzOZrMIhUIChdUZgAzK8HNeYilvJMtmNTlCsbVjmrJOuTjugkhnJZ2RtAc7nY7MF7OjCGmlLaHtJ5vNBo/HI+ugz0XC3pmtTnuCZyEdI9STbrcbs7OzGA6HWF9fHwt2FAoF+a6WQdpRtKsot8FgcCyjjTLHPpGiQgefmHlO2C3ljnqMOpB6W0PRhsMhgsHgWPEZnZlN24h9oS329a9/XQjaAUg1Ru0UoZxwPmgbct2Hw6GgL3RAk99jIJX2Pp0qPBv4LOpPk8kksswgDOWbZ7oO9HEtdKOebLfbYv9qu5h2EmWx0WggEonIeOmMbbfbUgnS7/eLLtOOb21zUg/o/UIbiPY2s6c17yHvJtwXJPMn7E5n6PJ9hDkT8sw9Qv3Psx2AwPSpDyZt0ibtrdXuW6fU0tISpqam8Dd/8zfihKrVavjmN7+Jf/Ev/gUA4LHHHkOlUsGLL76IS5cuAQC++MUvYjgc4pFHHvm+38kyuqwSwVTZwWAgac66rDWNKCp7OqXosOCBFQ6Hxyok8RLNLJvR6KjKDg+BbrcLv9+PRqOBlZUVMWpisZgY6Tz4eTjorAwe2IQfkneBUb/bt29jdnZWKprxDwBEIhFMT0/LBYUXBRowNL6z2SxisRgqlQoqlcrYJZTGBy8pLAc8OzsrqeF0kpw7d06qtJCDgqnVNOoJFdnb2xNDlvNEo+Tw8FCgDjQIAciBGAqFMDU1hXA4LOW6z507J/BJZjgxskeIJQ1DcqCQu6DdbgtMlIZ4LpeTSFqlUsHc3ByCwaBE6+kIYOSORqrmkmKjHNE41BfJZrMpkVVW4mJ2CC8IrIpIGJ/T6cSlS5ewsLAgld1arRYWFxcxPz8vTjhedpl1wmooy8vLWF9fl8wmrm21WhUiWDrCaIA0Go3XVUcJBoOIx+Po9Xp4+umnEQqFxKjm5Z+XRXLcAEeG4cHBAbxer2SHLS4uIpPJYH5+Xi6alBvyuzGqmc1m0Wg04PP5BK5CHptQKIRyuSx8Bz/2Yz+Gxx57DAsLCxgOj7gatre3ZU663S7m5uakWtu3v/1tBINBvPrqq5ibm8PMzIxADMvlsnBW0UCl8+rMmTN497vfLYZ0r9cT+I+OGnJenU6nOJpYjTMSiSAUComzotFoIJfLIZvNYmtrS+Rwa2tLLte81KfTaVitVqTTaYGXkbPGarXi/PnzAoPLZDLCj0GZNpmOYGaManIdgTtkxnS0cx3T6TSSyeTYZXVhYQHNZlOCAJrrhBmkNM55QWQk1mY7qpYZCoXEEcVLDXWPy+XC4uIiTp48iWg0ikgkApvtqGw6dSpwlEFGYtZUKoVGoyGGM3U9nVK6glgkEpELXzAYBACBCX7rW9/CzZs3paocs33o5Dtx4gQ+9KEPwel0olQqwefzSfZeIBBAKBTCzMyMQDMbjQZu3ryJV199VSC4zKxgBHp9fV1kzOv14oknnsDq6qrwL9HxyyIWOstMO4ToCCuXywI905k6zMpqtVpyNjKL5sEHH8Ti4iLC4bAUk7DZbAgEAq8jH6bzg0UTstnsGCn+xsaGBDQYLCEMjU5LQqdmZ2cxMzMz5qTSpMp06JHXhNB1EsEfHh7KWcnsjnb7qIQ6HRvMxuN5yMzkeDyOarUqF3k6EKjzPR4PUqkUgCN+TF70RqOj0u3BYFD0hLYdPB6PUANw/ulo52WNztYHH3wQ73rXu+D3+6XiLG0aQo109hIvuZxDZk/QXiF8ymQyCW9RPB7H4uKiFICgLBQKBbzyyitoNBpYWFgQp74x45iXdh3MYIU97n9SD4TDYRweHkphEtoCU1NTErAMBAICxSoUCgJH45h4njObb35+Hg8//LBk/01PT2N9fX0MbkgHN4m9eeGm85mN5yUvyOl0WnilwuEwzp49i0cffRTT09PiIKYNx4yQ/f19ga5yP3I9AQjnEYMchKWz2ij3CzPc1tfXkUwmJZBH51W328Xt27dx+fJl0cvMvOE6Ly0tYW1tTQIEhD3qDGU6WRjYIncW7bJEIiFVXQOBAM6fPy/yR3uCcFnOKZ24dEoxoEfHFJ1ywJ0gbrPZRLFYRL1ex8svv4zHH39cnD0MWgSDQcRiMdHzhF7TGcwqkbQvrl69ipMnT8o6U6/qQifhcFicmHNzcwKtpROegZB6vY5vfOMbqFQqEozhWcgzk9U1bTYbzp8/j9FohMXFRbE37XY7tra2MBgMkEwmxT5iEKVYLIqDh3ZzMpnEe97zHsni5v5YWloSuOTBwQFSqRRu3rwp2cy0/6gH6SSizakdeY8++igWFxdFLzHAMxodwdMrlQrS6bTAJqenpyXzlZA8BtO8Xq/YVeSppT3DDCqexYQBOhwOZLNZySC7X9skU2rS3m7NNHobS1+j0cDt27cBAA8++CD+4A/+AO9+97sRDoeRTCbx+7//+/i93/s9/Lf/9t+wtLSE3/zN38Rrr72Gq1evCub8Ax/4ALLZLP7wD/8QvV4P//gf/2M89NBD+MxnPvM996NWq0kpXZ115PF4xrKRmI3DRjgeIy08NBlBYfRFE50zXRq4Q1JKJxMjIMx06vf7iEaj4ujgewBIxFNHYjWhMp/BCJ7T6ZQMlHq9PlYxin+PRiOpEqMjXXSO0OnE1G+W/KYRTccCI5L6EsALEiFRHAeNFO2cocHNA4ljYyYODQr2jRdHGu06U4pZTsyi4eWW2SY0mtvt9usymngI6/7qedaZWhwnI3uHh4diVGn4HteLRhbXUUeT+W9jppSeG+28oRwxHd0Ip2PG1+zsLDwezxicjPAlfWmjc+jg4ECMQq/X+zrOL15umb3Dd3LtdYYMcGRc82I+Gh1xpxghNUbIns4E4AWDmQ06Ik25oNzoTDnCN5hppWE5hHExU6rX6+HUqVOIxWLweDwyDk38yawNylKxWBRHJB2ONGDp7OTcMhJqsVgQCASQSCTkM2bi6EZIJWWIfdBOTQ0HoWHJizflkEYl55bZfJR9Y6aUyWRCPB6H3W6Xi7u+jHA/WK3WMVnjOuosNe4b4MjxE4vFZHytVksyBLTcUOZ5cdGwM84lnSLUqXQEcF24J61Wq2SN6CpMzOjRe5sOL11xTe8L6lw65RiJ5/6jbifEhA4fkhVr2M5gMIDP50MymZS1JXm/LoqhswsJFealTjsWBoMBCoUCwuGw9JO8IuS443jo9OY8asiUllGeU9Qjej9SPxMOxECBzWYbu4BrHjpedjWEWcs5I/ecbw3JtdvtonO4v5ldoYMhvOxoHcuziWvJsXI/MXNyOBzKWUknFOWI68938mfsk8PhQLVaFWeCzmhgVhgzkCiDlBs6z6nH2Beei5Qf2iN6LFwPq9WKWCyGRCIhwSqdRXMcPN7oLOJ5TpuAF2z2mbYKM+A0zIhO4H6/P5b5bHwXzzLKH88JOugoZ3pO6CSivDqdThQKBXG00XFGW4S6lrYLnXF09kQiEdFdLpdLglH67GUGFM943Xf9PZ47AITCgfIQCAQQjUbHbA8t8xwXK6NqWBn1qc5E5Dwx65Cyqe00Bku4Z3RQixBXrql2wjGjlNBMBuM4Zr6Dz9LPpd7QmVKUuWAwOJaZxZ/pc4/yrrMIOVfU+zrDzyg3ly9fRjKZlP2gn6Wzb5h9SB1MW5D2Ra1Wk8CAfg/3KvUM9xVhjNSXlD3Kdz6fH8us5HpSd3OPmM1mCWjw7ODnzWZT6BP0ntdZhfx/r3fEW7u4uDi27xmkZv+0M12jN6jT+WzOGfUxx5lMJuH1erGzsyP6jbLC9WXWMp2fnHPyVPEM5V2n0WiMnQ1GXQFAzjBmBhN2TpL0+6XxTvq+971Pxvz9tF6vh7/6q7+6L+dm0t7a7W3tlHruuefw7ne/+3Wf/+zP/iz+63/9rxiNRvjkJz+J//Jf/gsqlQqeeOIJfPrTnxYyUwAolUr4hV/4BXzuc5+D2WzGRz7yEfyn//SfxspNf7dGBTBpkzZpkzZpkzZpkzZpkzZpkzZpb+12PzpeeCd99tln37RT6q//+q/vy7mZtLd2e1s7pd4qjQpgcXERw+EQ+XxeMgwIUdE8GIwK8W+SgjLLplQqCVeFyWQSfiuWUdXp1Iy2uVwu6U+v1xP43urq6lh1KEYH2C9GNXSmAMvcM6pLyAshC8x0yGQy0ldGsq1WK2ZmZuB0OpHP55HP5yUdPRAIjOG8mU1kMpnGUpQJ8WKUjpkbc3NzktrN6HU4HB4bH7N8CLdilIfRHWZ8sLoiIWuMkjPyyKg0eQ9YMYWkt4x2sfxsKBQCAImoVSoViQqbzWaJJOroHbnDqtWqRJNIHAlA5srlcqFarcLn80m2BLM0jJwrjPAxymuxWKS6ISNQrVZLsl92dnZweHhUybDVakk6dzQaxWh0RAhNCNa5c+cwMzMjxKiEmugsPUbmLRYLDg4ORMaj0SiWl5cl2seMHMKASDLP7DHKKNOyNR9EpVJBPB7HqVOn0O12RY4Jx2SEntkMo9FIIFLb29tIJpPCc8PMP3I+kJifa8DsG0JXAQjXASGGwWBQuJhMJhN+6qd+CidOnJBMLuoDrhn3HKN5zFa7fPkyhsMhlpeXZV+9+OKLAoHQmV+dTgfxeBw/9mM/JhFjVlFiVo/ZfFSC3ePxSOYWMyA8Hg/8fr/A/Rh9LJfLkuFIXeByuVAsFgFA9BKzQxhNJSSVGajdbhcPPvgg/H4/XnvtNamARp4Rwpp8Pp/ICPsxGo0EosV9y+hup9ORtSQBfSQSkQwNZoNwL5RKJdFZrPhJgn/O/8zMjGQLUJdST5PfZnp6WuYwHo/D5XJJ5Fjz5wHA/v6+wDxzuZzwdhFOysp43LfMQNGwyLNnz6Lf7+PatWu4efMm8vk8otEofD6fZE65XC5MT0/j4sWLqFariMfjkmVCIlquM7OPWOlqb28P165dQ7VaFYgcYVDMytnb28PS0hIeffRRWW9WJKOu1jqHhPOMkDNbmJF4niXUu4SmEZJGbiC/349kMolgMCjV5axWq/AREZ6hs0e4L5n90Ol0UKlUsL+/j2KxKHp3MBggm80KfJIyyTMtHA4jFovJecIMAMoC4VG3bt2SKm3MiGJFT81dNRodEdgza4fZFMzC0DrAbrcjlUrJWcS9rHmvuAcIKydHEqtJaohnp9NBu92WCrqEakUiETmTmAUMHFUEXl9fF5hOPB5Hu92WqsJvlHHCDAZmppXLZdHhzKRgFkW328Xs7OxYRUPgqArklStX0Ov1MD09LTLFTAhm+FKeNJclyfK5l5iRQjgxiw6MRiNks1nMzc2NZUkwS4cZGtQ51AX8ObOilpeXBVpESCmzYZj9y+xQVk7WWTs6y5kZHYT5cv7C4TDW1tZkrnRfNAx/Z2cHW1tbiEajcg5puWY2qeagKpfLSCaTApNjtqPFYsHS0pJUq9NwzU6ng9u3b4vdR2QAzyqv14vZ2VnE43GYTCa4XC7hkQQgWT6tVgs7OzsCa6Ou5fsJKdfIAbvdLpWyCUVk5qPX65WxMuNGZ5DTbuDasPpxq9VCKpWCy+VCOp2Wc6NSqUi2FSv+0RYg3xxtcFIVeL1eyfhkdtxoNEKz2UQ2m0Wv1xvTX+FwWKgHuG94lvAZhJ6Xy2VUKhXJhGWWNc9ZZoCfOXNG5np/fx+DwQAnTpxAu93G5z73OVy6dEkQFxaLRYpdEL4dDAZlHZ966inZM7pgC6tPE+afy+UEvlcoFOSMrdVqYs/pbLG9vT1Eo1E8/fTTiMfj2NnZkbESejkajWSvMnssEAig0+kgn8/D6XTi8uXLmJubQz6fx9zcHEajkdi55PNldjA5qoiKoL3aarVQKBTuS8cL71vvfe9737RT6vOf//x9OTeT9tZu9y2n1I+i8aIKQIwYKmZtRNNBwYsz0/V5qPLyS2OF/Ew8uGggaiJzY+q42+2WC9zc3JxAp1hRy2w2y2fkouElu1QqCTk8nQ39/hEBPIkweahpskAaWzzIOQ5e7OlI0jxLNOh5WWE6Li8sTBcmXjyRSEgpeELKksmkwEv43c3NTYFDkaCd/eU4gSNIGOGJuioLnSPkc/L5fAiHw/D5fHKpd7vdUjJ+ampKnDI2mw3ZbFYu1+RNIXSR88DDmCnahCPwMNVcZCaTSUhZCYfj5ZbwTM4VZYDcPrw80tip1Wrw+/2oVCooFovodDpS1YprRiclx2Q2mzE7O4sTJ04gm80KITGhPXQIsGoOjWdCFefn53Hu3LkxpxSN51KpJJVvyG9GuSJXDWWIhmUkEsHKygparZb0nfNJI4sXydFohNnZWSHDpGONFfbo5NNEnNxjhH/wEsB9SWOLc6XT0xcXF3H+/Hmsrq7C6XRif39fjD06qofDoaSrk3+GRuLZs2eRSqVQr9dx48YN4ZBjqj3XJRwO4/Tp02Pp/pVKBbFYDOFwWByYwWAQc3Nzwg9CMudoNCpQC1620+m0lOdmpSwNmyWBN+Fy2tFNyAlwdFmdnp5GJBLBxsbG2EWW+pAwQg3x4fySTJxOOBqUdLr0+31xqIVCIXEYaBgb4SbUQbxUksODzhTqPl52ebHnHnQ4HAiHw8LNlEwmhcOHzutCoSAX5OFwKBd/AOJcyefzqFQqwovGS58m9uXF8/z58zg8PKoayjUh9xXPFq/Xi0QigTNnziCfzwtnSCAQQDqdRj6fRyAQED4UOhfS6bQEDQAgFotJuXcNf8nlcojFYjh79iwODw+l74SEsFQ4nXmal9BqtaJarcplAoDw0GgdT+e4hloGAgHMzMxgampKSHdtNpvw+ZF/hJc86ktebBl8oENWw4jpOAwEAsJDo3XkzMwM5ufnx+BYlA06lFKpFKrVKubm5sSZSUeIz+dDMBgcgw1qaCAdYbwcacgp7QCekbQJaAfQ4Ut4MftMB2Wv1xNyb/aJ+4X7i+cqHSjkNQOOnFLz8/M4ffo0/H4/FhcXUa/Xsby8PFZRzAiDpdNHO6Sy2SzK5bLAZLiXgCOI2smTJ5FIJBAKhQRWxIrDnU4HKysrcqmnU4pV9LjPqtWq7GU6qbmXqB8cDoc4iAhhK5fLIsfkD+Se4npq0mXqd8prIBBAMpnE/Pw83G73mL4lHI4O/Xa7LePSjhKekUa4H+fPbDZjZmYGZ86cwYkTJ5BIJGS/0eFYqVSQyWTEOT8/P49msykBPsoIL6jkTCRkbWpqShzrrVZLAqMLCwuYnZ2VAgfUYzxX6bhjAQyetXTYJ5NJmEwmgRZTlwKQPvCs0jYx7ZWZmRlMT0/L3qhUKnA6nUgmkwAgcHkWpKAepiPCCPnVEFPqVHJJkTeOzkvSXJASIhqNCgrCbreLw5r0FQzIBINBpFIp4e1j8LNSqYhNSkgygxycf+or/q7D4UCj0RBnloZksxAKg9B0SJG3U59b/X4fJ0+eFFjb9PS00BBQt2mYKveBz+fDyZMn0Wq1xPmoz+WZmRlZO35OGRoMBvD7/XI3YeEY7h/g6K6yuLgocEkG80ajkZDE0+6ikzEWiwkFAoOQXq9XOAjpyGIwhGtI+5UyPxwO4fF4JLA2aZM2aW+tNsmUugeNh77OEtD8LpoPSEfG+EfzsNC41pdcXvQ0xwQNGeD1XDK88NIg1RVbaPywX+yPfib5GPhsNkYbOA5mumheCjp4aCxrPhEaGdoBpZ9Nw1Dj4fXBSSNTG8c0IoxRR31Z4OVTY9t1FUDOKaP+jOjyb0Y1dQU69pPZSIxc6TXkHHPe9Zh52dERHEbk9eWc7+N7+Hx+zr7oiwJ/l84LjpHvZESQ2TA0vmm06fWngw6AkEjycNeOCb5X94VcGgCE3NkYuWR/dKUiLaNcM/177BOrlmkuMX5fc3jwos2MBDpEOF9GzofjZJSRer3fKFO8KNCBMj09LQTJnH9mRmlOFn2xowNlNBqNVYdjVUcdTedYHQ6HZOgBGKvExAuPzobQPEaMQFI+OQ9cf84954Zj13OrOew0hw77xyqZzJ6hjuM+4tpxTHqfaI45vo/v51ryGUYuHco995NeX2bEaYOUmSWcY61LuG6aV0ST5+oLgNY9lEly1NAhwr3HOeBe5th5MWb2RqPREOct11DrSlZJ455g/+mgYdaTnnedLaDlhfuQ+7fdbkuRB8op50b/W68N+6a/Y+R+MepdOq34Dl6mjbww/Df3kdZ9WudpnhpemPV3uCaUXb0GvNRqXaufSx3ZbDZF7th41mmuHMqgPi+4v7Qu4N7RvIJcGz5HZ4RxH+s5457Q+8aoH3nx5v/12C0WixDOU+bpUNPzrJvWsVr/6qxOfSbxvXTQaY4kBo50IE7vaZ0FbNRF2uGpbRrue+pnfpcODc0vxvfpc4BywMZ9Tz4+ZocbHUx8BuWQY9fnv3E+uZY8a+x2uzhetb5gP9l/VkCmPPK9XFu9DzkuBiKpK7T+1BX0tIzS8Uy7jo4NnlV0cHLtqCv1WNkHFtTRa0T9QKe4Ph/NZvMYf5K2WTn3RqfpcfOr55gORAZW+H6d1cYgIteM66CdXZQh6jSj/WLMkqf+57P13GtOJsqN5kvjvtdnBueHwUsAMh7y2mazWUEq8F3cD9yztAGZraZtPM4f+85x0TGn7y08Y/Vase90fEajUcmW1vYfHXCUU23nU/eazWbJ4KZDnusAQPqsbTj2QfeJ770fs4F4J33Pe97zpjOlvvCFL7xt5mZxcREf//jH8fGPf/xH3ZVJ+wHbJFPqHrZwOAyr1SpVqbrdLiKRiETBeYns9/sSLTo8PJRsl3Q6jUAgINksjK5S0bdaLTE+efGhUcAIic/nkwM+m81icXERHo8Ha2trMJlMAjPhBYvKmhEJwk2YGUEDfGpqCo1GA5cvX0a9XkckEkG1WkWxWBw7zDkP8Xgc+/v7qNVqAkVgHwkJs1qtUpkJgBgqOhtrMBigXC7L5cjv98Pv98tFklVpGCnRFx9CFHK5nJAyv/zyy3j44YdRr9el6pvP50M+n0c4HJYsMkZTAMDpdMLv94/xhjFzand3VyJ4rALm8/mkcokmE6VBw8wYv98/BjehcUmiUho2fr9fUuyZ+UKHB2EDFotFMsh4oNNYYeROX9Jp2PO9NDhLpZJkKzHCxMjaqVOnsLy8LPNms9kkY4wXaGZqeDweiZxZLBaBOLIKiq5GRucYyZlZSSyTyUhlOzrmaKR4vV6JyNZqNSkYwPdy3OVyGZFIRLIF6CxlNkKr1UI6nR7LTrNYLFKRkM5mPYfMABkOj+BhlItKpYJer4dHH30U58+fBwDMzc0JhFNfsPVFnhlcf/u3f4toNIrp6WmpmMNCDtVqVSLozOw6deoUHnzwQTE6bt++LRCrfr+PVCol2ZIrKytYXFxEJBKRiDsvA1z3fD4vMDwabHb7UUVJVt+jfLZaLZkPRrN11UqTyYQLFy7A5/Phm9/8psg5dZg2gAeDIwgG94G+jA2HQ9n/uVwOACQyTsOLBjSdcjS6h8OhQKjcbrdEpLmvdDYTy1pTbkhWy+wqEkAz44jZksxmm5+fFwcSsyOZkaGhBLycMEOAUW7tLNjf30c8Hke328Urr7yCGzduSKacvnBZrVbMz8/jmWeegdPpRLPZRDqdxtraGgqFAgaDAW7evIlEIgEAAt8DgJ2dHWxsbMg5wssK9zCzKmdnZ/H0008jEonghRdewGAwkOIZhAWZTCbU63WJVLPKo9frHavsRN3MTNJ8Po+ZmRm8+uqrElEHgHg8jkQiIXqFFeT4PsI5otGoVKxihiZ1f6/Xk8pkhUJB+sBgDeePa66dUoRlUV/qjFbqvmg0KvPEM240Oqp6aLVa4fP5pKIZz1tmuDBbgZd2Zi/t7+9jenoa5XJZHJM6CMQ9S2e/zsSz2+2o1+swm81SYYr7kJfPWq0mECntCGJGg8fjwUMPPYSlpSWBTdIeYaU2XtiBO04UXbaee1g7oel0JAR6bW1N1tLtdgs0rdFo4MaNG+j3+/D5fKjX6+KoYgCClRO9Xi/S6TQcDgdqtRoymQy8Xi8CgcCYY5qOOP4xm83y7larJTB7Om/MZrPocZ79vAxT9giVYjXeqakpycaiPVQoFBAIBOD3+3H9+nXU6/UxSDjHznNcO+qZ9elyubCysiIZ0RaLRarUNRoNOec4T+VyGalUSvYzs8EByHlFYmqXy4X5+XmYTCapvkfHxIULF0T/MnhHW/H69euSjcxqp4QMWixHBNaUFZfLJWe0dkAeHh5ib28PpVIJ2WxWsuWKxSIGgwGmpqakOq3ZbBYomN/vlwzNmZkZsWG1o4hyqZ2DdPDQli0Wi6ITeGaVSqUxCgLSbzDTjg7/TqeDhx56SOxTvpfOfsJpqTO4D7iurH4bj8clAzWXy6FUKolM0mHbbDaRz+dl32rHL8dJqGAkEsG5c+fEXqrX69jZ2cHy8jJGoxE2NjYEGkfdwKzETqeDer0uwfRut4tnnnlGMtQASEU8q9Uqlb6ZudRoNISUnZBjQuN49uzu7o7ZYU8++SSmpqbw5S9/GaFQCFtbW7BYLELPUSwWsbe3B6vViqWlJbHfec9gZT9dSZC6nHY8+01dwHsU4XuE3d/vjev9o2jXrl3DJz7xCXzpS19Cv9/H6dOn8dnPflbuTJ1OB7/yK7+CP/mTP0G328X73vc+fPrTnxa5ebNtcXEROzs7AI5kIpFI4AMf+AD+/b//92OB3El767WJU+oetkgkIs4jm80mhglhaG63G9FoVBwvNOBYXaXVaiEajQpMiBXnmJrOSwwvW4zgNJtN2WgsHz8ajZDP5zE1NQW/34/V1VWYTCaUSiUxSmi8MFOGsBqfzyeGLVPy5+bmUK1WUSgU4HK5pKQtD0oaGyaTCbFYDLOzsxKFojFHA4xzxaiIPvgYxfT5fALFIbwsFoshGAwiHA6Ls4cXbV6MdZYLDXimQ5tMJmxubmJ2dlbSqi0Wi0BMyKPFiDEvUnSIRSIRAEeGPiE4vd5RGeTRaIS1tTXUajVxGuXzeYlUsTy4xWJBsVhEo9FAOBwWiBkvKtrY5IWB3AOcT17GTCaTGG68CLECHDNZNMySBofOFOF7abACkEs030lDY35+Hqurq8JDwWwlpn3T4UnHB7mJzOYjqFEsFpN+NJtNyQSgkU1OIlagG41GAj1iRJcRUb/fj6WlJZhMR3xkLHPt9/vlclar1WC325FIJMTJwKgoL4SEzBmhMZRnQoaq1arwSHDt6Gwk/xYdVktLSzhz5gwAyKWCa2TMLqFxlMvlsLm5ienpaal8Q94DALJ3dKQ+mUxifX19DOLDyBYN7Ha7jUQigbW1NZw8eRLT09Pi1OUliA7aVCqFTCYja0OnFEu506hvNpvCL8f9z3exrLPZbMb8/DyCwSA2NjaEZ4WZKJxLOqX8fr9c7Jj9ozPa6LQaDo/4yZhFQwgbM80o27yQEkZBJwH3g8lkEq406lDKVr/fl8utxWIRuMXc3BwcDgfm5+fh9Xrh8/lQqVTQarVw4sQJVCoVgcZarVYUCgUxxAk1pGFMLjgGHgiHBY4grISGlUollEol0fk6+mu32zE7O4vTp0/D7XbL5f3cuXPIZDLiCJydnYXJZEI0GpUAAPlLmGHBaDnhPQ6HA81mEzMzMzh9+jQSiYRcGmdmZsSJwChqpVJBpVIRfU/YR7FYFNnhOaEz+ebm5nDt2jUEAgHRSfF4HLOzsxJgicfjwpHo8/lgtVoRjUYF/kInuK4Ox8ue3+8X/kAGBuiY4V6ko5cXUnIiapkvFouSKUp4O7PXCK2k3JO/i3qX5y0dp6yuyzNXO/J4xrRaLcmA032jU4VzyUAUYeO8lAF3Mm2ZCcO58Xg8YjuQW4+8SEtLS1hbW5MzllyDi4uLAt3S2Q+E1XU6HYHxUa6o+3meFQoFlMtlrK2tSfVdr9cre4TQenIc8lJP2Cj5dciZR4cuS8TTNqCznXpW989kMokc0ZHC/US7zGQySQZxMBhEs9mE2WxGKBQSGyyZTCKZTCIajSKZTMrFPpvNyhyTG4mQOmb6kKuIvHnMAqI+5vy53W6cOXMGPp8P0WgUFotFHGaVSkU4/cg3RDguM6Z41gIQu5PZJR6PBwsLC6LjqDsdDgdWVlbg9/uFAgK445RqNptwuVyo1+vwer3itGV2/OzsLBYXF+Udq6urY9lBPH9pO5jNZsTjcZmLfr+P+fl5rKysSNCgXC7DZDKJs4FnPzPINCUC5V47pBhgYXZoJpMRnUAHZS6XG3PQdjodqbZKrj+On047fZ4zCE0eJgZ6uFd5zpNrbXZ2FufPn5cKu5lMRnQc4YS1Wk0oIugc1LYb+8Og8erqKmKxmDjOe72eOKVarRZisdhYRrCusstxUketrq6iUChIBWGXy4V8Pi9O+1qtJg5O6jieSZFIRBxVrJRbqVTEjhgOj3gz5+fnhZuPZ7OGjTKANTs7i1arNZZlS53J+WXAixlj1FG0I7m/HQ6HcPG1Wq373imlnZDf7+/9oG1jYwNPPPEEPvaxj+F3fud34Pf7ceXKFbFzAOCXfumX8Od//uf40z/9UwQCAfzCL/wCPvzhD+NrX/vaD/z+f/fv/h3+2T/7ZxKc++f//J/jF3/xF/Hf//t//4GfPWk/vDaB792Dxoi9hkfwAqJhcDrl/ji4CA1QnWKr0735GYDX/ZvGlT6YmaKtU591mrQxvZl9MEadGN1ntJ7v0+ng+qJNg9+YtWDsr05X5rv4LGM01gjb4O/oNF0NpWDj7/Nn5CKgoUBj3Qg14aHGeeF72fh/RssBiMOQlwX2W4+L/eQc8GdaJrRBzXdpmdDroy+pek31ttbPNv5Mf8711JFmXjzM5jt8UXpdjZACLc/6PZR9zq+eEz1+PpMp9nRaGBsvf3o++bta5riuGoag15VyoPcC146XOvaR46MzjbJlhA/SEU2Z0Hv4uMb+0zAjvwUA+VtHSLnOdBxqY01fPumcpANOG++6L3y2hj5ynjinOlKr18soX/q5zBBjNFMbSMa54D45Tq64j7gmGjan96WWZT02Pl/vLwBjsB39e5QZ3TcN19NwEepE7n3j/tcwMC1fxj967ggH4cVBy4Bx3pitqOVdc5zRgDfOKaP6+pnGdeRc04nBbDLKkJY1jp3j48+MekevKZ0ADLDoM5JzfLf38YyhLjTOMfem8RJ3XDOuDZ9r1M18lobLaTkExiH2nBPqEf086lmtGzgfWvfoOTvunKR8avnQuk6P+zi7wrjfCJvk/9kHDSE2njF6XMY/x72fThOdZaL3Esek96vWD/y+hg9ru8V49uj+GGVT2wx6PY1nrz7XAIgThrLKvmnYFvWGkTOPz9X70Si77AszLLWO4/P1vGp512ur36e/azKZxiD6eu/S+cmx6/5xLHpNtE6lw5nyq6FDWm64l7TTlXPHrCrjmLUOuNu5alx7o/zpeeLP9Nmin6FlSc8pAwzHvVfrUP1M488Ij+X3KC96f1Ke7ma76THxebSXhsOhBJWAO3x+xnlhn4zvYGaiti+ps4zwZK4P5UjfDXjGMhDA5zObmIEWZibSnqcjkXJq3M/aTtVjoZxoW0k3fd6yj28XiNr303gnffrpp8fsnO+19ft9fPGLX/yB5uZnfuZnYLPZ7uoEqlariMVi+MxnPoOPfvSjAIDr169jfX0d3/jGN/Doo48e+3u5XA4f+9jH8IUvfAFTU1P41Kc+hX/7b//tGHzvODjfpz71KfzP//k/ceXKlTc1nkn7u2mTTKl72KhY3+iz476jL93HXcC/l8ZD1th4kWD21d9Fu1tfdDvOgaSbcR54cN+LZpwLPlf36V69635pw+E4HOD/96b3sXFP/11F3xiVfau2H5a80Enzg7bjdDHb96LD3gpNE/D/sJ7PbL0fRtPk8GxvtC73e9Oy/d3OyHvZeN7dq711vzS9Blon3A8yStvwe/38e2n/P8hPpVL5UXfh2Hacnn6zurtcLr/pfui9oe1ovZfuNoc8D3T7/0GmflhNO+u+39/7QdpwOMSf//mf49d+7dfwvve9Dy+//DKWlpbw67/+6/j7f//vAwBefPFF9Ho9vOc975HfO3XqFJLJ5Bs6pX7u534OqVQKf/u3fwubzYZf/MVfFGqHu7WDgwN87nOfwyOPPPIDjWvSfvht4pS6h+3UqVPweDxCBtlutzE9PS0ZNeTvCAaDkqbN1GdyGYXDYbz44osYjUaCq+90OqhWq1IthOmPrB5UKBQQDAbhcDjg8/nGUtXX19el6lI8Hpfoj5F8kVAC4Cj1nBW3GOlqt9soFArY3t7G/v4+er0e9vb2BBZH2Fi325WqSel0GrlcDl6vV3gm7HY7Dg8PhZRxf39fCMzJ/8LICCMaJNKcmZmBz+fDlStXsLa2Brvdjne+851wu91IpVLCrcFISr1eFzgg+ZpYXpj8ORaLBVtbW5ibm8Pu7i7C4TCazaak7TNN2OfzYWZmRiKRTqcTDzzwgBCt6xLvrIJUq9UwHB5VYGEKOFPCGXmy2+0Cc2u1WgK7Ie9UoVDA/Py8RKxsNpv0i1APZsGEw2HhziAh8mg0Ej4kRp44BsLwUqkUTCaTwA9isRgajQYKhQI6nQ5mZmaQSqXwoQ99CGtrazg4OEA+n8doNBK+C0bJGGFzu924fv26QH2YQfTCCy8gEokgEokIz4DP5wNwZPQz7dxut6NcLo+VjgcgFbDW19eRTCZlXX0+Hw4ODhAOh1EoFGC1WpFIJCSizss7I2y3bt3C+vo60uk0bt++LbwFrG7GtWP0kRWHjJlC7XZb+Nf29vYQDAbx/ve/H+fOncPc3BwsFgtCoZBksxiz0gAIHwgP6ZWVFeG9uHz5svBeEd5CyMv6+joee+wxuFwugfkSBplOp2EymWQfBwIBLCwsCGx2MLhT6SmfzyOTyQg0hPA54IiHyGQy4fOf/zy63S5u3bolnBFms1lgCoRPEj5ssVjw6KOPwuPx4E/+5E8wPT0tGQ3kKtH8e+TxYQSda0591Wg0JGpHnr7bt29LdSSTySSVumw2G6rVKjKZDIbDoZQlr1QqMJvNwps3NTUlWUXpdFoi4MzmIBwuFoshGo0KNCgYDAp5O+eYmQWJREIyMQllCwaDYxArnd1JWWLmUqvVkjkeDAZ4/vnnkc/nUa1WMRgMZH/w+WfOnMFP/MRPiF7NZDJ46KGHsL+/j36/Lw6rTCYjkGiTyYStrS2pskj4MPcdYWmEUT377LOYn5/HjRs3xrjb8vk8zGYzpqam5PwxmUwoFArY2NiAy+VCoVAQnUw+IOpEwjMuX74scmE2m6Ua4OHhIaanp6WincvlQiaTwcLCwljWooZ7svKr2XwE393Z2UE2mx2L9OuMQb2fCUWbnZ3FcDhEsViU+dPnSSwWEy4XcqjVarWxrBnq4Gq1Kk7qZrMpsJdqtSrrUa1WMTU1hVqtJhCbWq0m/HvU5YSmuN1uIb9nVqbdbkez2cStW7dw+vRpOJ1OHBwcyHONGarkguHZ0el0EIvF8OSTT2JlZUUgcsPhnUq+xWJRYEqU32AwKGTBJJXn3rXb7ahWqwLZ6na7SKfTeOihhwSaymwswsuq1aqco+VyWWwBVtmy2+3Y2trC0tKSwIuofy0WCw4ODsT+oS7QfI2ci3A4jGw2i2q1Kucmub8IayqXy2NQR3KcjUYjnDx5ErFYDIeHh3j3u9+N3d1d3Lx5EysrK2g2myLLwWAQ169fRy6Xg9lslvOZfFKUq9nZWXkXq9F5PB6pfEjdcfnyZQwGA+GHY8XLmZkZFAoFvPzyy5KJksvlBK5UKBTEBmVl5HPnzsHn82F3dxfFYhHdbhfxeByPP/444vG42B/5fB7NZhPJZBKZTAYbGxtotVpSEZBnCe3dkydPot1ui86jvrXb7VIBttFo4Pbt28hmswgGg/B6vchms7BarUgmk2L7mkwmgZixwqTVasW5c+dkjtmYXcO15h8W5OH5TSgas93IUeT3+6X6G7N7GQwljxlwVK2UVT9J7M6iALQxyBNJva2zkYfDoVS3JN0Hubl0kZF6vY5XX311DJ6vM8t6vR4ODg5w+/ZtLC4u4vHHH8f09LRAhU2mI77ZVCqFF154QSr9UfdxPxA2Tx47q9WK97znPVJhlnuL72dVPtJNED5br9dx+/ZtHB4e4uTJkwLzJxTcarXCbrcjlUrhZ3/2ZzE7O4tvf/vbsFqtqFQqQnPCitm7u7uyVwOBAHq9HnZ2dgS2SR3Z7/fH+AtJmcFsO3LZ0T4xm83Y29vD1NQUNjc339Rd7/+XRkoPNsr6d2u5XA6NRgO/93u/h0996lP4/d//ffzlX/4lPvzhD+Nv//Zv8dRTTyGTycBut4uMsSUSCYHXGtvNmzfxF3/xF/jWt76Fhx9+GADwR3/0R1hfX3/ddz/xiU/gN37jN4Rm45FHHsEf/MEffI8jn7QfVZs4pe5ho2NHVyPhJQS4w1fDyxf/8DuE7vDySiOXRjRTZzWOXcP2+F2myjIVmwYQU2ZpmNMpxfdQ2fh8PjHu6ZQiGS8JMGk8aacWx0huKvJlGHk89Dg1NIYHH/8GxiudcX61E42XbrfbDa/XO+aU4vicTudYui5/V3MCGCvr6b5yXnlocj40rwV5egi90uVyCePhpYk/GwzuVDbid2q1GgaDOyWpOZdcZ8I7yCtEhyA5GrRTSlf94UVEO6V42eBlklxLnBcNleGYWdKYF2/yP9EpxXLkrPpIPh39GZ0oLF/OiyrT6nkpJt+NdkoR4sK+MD2bzlr2TZPlU/Y0XIPrRjlgxRgSEtNZQRmmQaafwTXjxYlyw7LhJOQmxxbXARiHSjISyPULBALCpcaLCyENWq+4XC65jPt8Ppkbu90uTm6fzyeX+kgkIg6awWAgzlEa8tRHlG1eqgAIDJh7h3NqhIdxf1DeKaOEffKSTacKnTkcE9Pr+S4t9/yjnQocL+eR/eN+5lrr/c3+6c/13ucc8zPKCueAnBT8PbfbLf+m05m6x+fzIRQKyee6CiIb9yYr6LGoAp271Cta1jh/lAGHw4Fut4tms4lwOCzkx5Rd8ujoPpP3RztsuM8YoHA4HAgEAnIx4F70+XwCveDlhbqM5wTJ5Xk28DLOS99wOBw7H7kW1BHsp8fjEWdMvV6XEuDcQ06nUwjlyY1E2aDzS49RVxYzOqWsVqtUPqS+5F6nXGgnJLmkONc8fyirJBMGIFBvypaGKfFz47mszz+e+fyu1gV0ZHCv6UqRfKYRPqjPOO43j8cj60mnlMfjkeIHGm4JQJyH3KOaLFo7Z9lnrhHPSe51BjN4JpJzUxNM87zlmUE+IJ4DlBetizRtAfcXZYa6ne+gDOqLP+eHa0pIFmXUYrEIpxnPNQatTCaTcDNpSBz3FQmXuS94XlFHMJigzzQ6gfx+/xhHE/cj9y8v7uSt4zxwDnh+aP3CIAxlgGvNoBl5n6g3tTOGldecTqcEYHjGs/gD9Qad/xwX+0GeU6/XKzJoMpkkAKKdUpFI5K5OKTqKOE7qRq4f9ZJ2SnW7XXkvbU3OV7/fFw4w4Ii3lfPLMVCuyIulq/lp2C/PQOpUziF/R1fEozxr+5WyST3LvUL+Wcob5ZnZ1JxnyjGDLwxOs4+UPXImErpFm4F6g/YpA3PaEU87imvFva/1HWWM80hbh2cazyDqA8oGbV19zutAgz5H9N1Gn+Xadrjf2w+aKTU/Pz/2+Sc/+Un89m//9thn/+N//A/8/M//vPz/L/7iL7CysgIA+Mmf/En80i/9EgDggQcewNe//nX84R/+IZ566qnvu0/AEXG61WrFpUuX5LNTp069zrEFAL/6q7+Kn/u5n8NoNMLe3h7+zb/5N/h7f+/v4ctf/vIYPcOkvbXahFPqHjTidzXOXOPTje2NcO88LPhvI276uOfpz43P1nwbxt+92/OO+y6/r7Hn+t963LrfOuPpuKb7cLc5059rTggAYjwe14/jnsH3aW4FRpV0X41cAsfNiVZsxrU3rpv+3t2aPkD0BcLIBXC3Z93t2Xc7mDS2Xn9Xr53+Hg9347ofN/8AxtaJP9NcKkZ+E77/uH7rueVFzTjfeh2B8ZLrxvEbeUr0Oh/3feN83u1zo+NYz9EbPU+vg55/fqYzHbTjhjJo7LdR5t5IB+j36OfrdhzEVf++fhebjui+kWzqPt7tWcd9fpz8HNev76ZP9LOM3ztu7t6on8ftSaNsvVEzyiMvwcetK3AnGKFlhg5Y3Yzj0/rFOF7j3/oSo8d13Dwax3Dc8/X7qRP0/GhZ0JwmRt1vnGdjX4zn1XG/cze9yN/XfTeOQbe7nYPHrZ0eu/GZxvkx9vO77RM9P9/v2asds8bnGufjuLky/vy49ad8Gsd3XD/vZhto3X3c+O82VuNzjrNPjju3j1tvzQfF8RynQ7Stcdy49PeOe5dxLY7bg3oMx53lxvHzu5rjR9sa2qY6Tg6NPFPG9xn7fJye0HvzOBtCz+9xcqd/buzDcX8b+3GcPjT2z9judp5/L/bLcX14I/uEn9FeulvT/F5ct+P0vOZgutue1T+jw+aNzu3jzhCu6d10EOdeV5s0vls/i79jlH+jbj1Ofxx31ug+sN3PnFJPPfXUm+aU+tKXvoS9vb2xuTkuU0oXeACA2dlZcTx+8pOfxG/8xm/Izz7xiU/gq1/9Kr72ta/hi1/8Ip555hmpUsy2sLCAj3/84+LM0u3//J//g49+9KNj2brAUXDkk5/85BtySj3//PN47LHH8PnPf34MMjhpb612/7uK/w7bGx1C388z3szz7nZp+bviRjru8L/b/9/od9/o+3o+jJf1N9vuZsS8kXHD9nc1t3+X3CLA3dfjzfDs/LDm6Hvpy3d7t9GAvxdtNBpJdPWH1bgPGOF8KzU9j7pv34sO+H513d1+742+/0bvvNvF4F7Jxg+j3UuuvTd6x99F+1Hq2B9FO0727iaD+t/fbZ98P3rNeKH8uzhr3so667vNP5uWy7faeL5be6Pz/F7ok/t5z75V2706BygbPyiP0910EP99rznZvpd9+0Y69n5tb9Z+4e/4/f7v6rBjNr6xPfzww7hx48bYZzdv3sTCwgIA4NKlS7DZbPibv/kbfOQjHwEA3LhxA7u7u3jssceOfdepU6fQ7/fx4osvCnzvxo0b3xPPG53wPwhn3qT98NvEKXUP2/nz5wXawpTgmZkZSQkn3tztdktqOrH3rERhMpmQy+WQyWQwGAwwPT2NaDSKzc1NKbnOdF2Hw4FarSZRAq/XK9xKo9FRivnq6iqmpqbw2GOPYWpqSiAepVJJYFuDwQALCwsCgSAcBoDAGMhdsL29jevXr6NYLGJnZwf9fl+4WuLxOHq9Hg4PD7G6uopcLofd3V14PB5JE2aJekZviL9ndIWwDUIR+v0+UqkUotEo1tbWMBqNcOvWLSwvLyMSieAd73gHgCNui4ODA/T7fcTjcYEeNJtNlMtltFotNJtN4Sc4ODgQboNGowGbzSblsZkGT+XldrsRDocRjUYlRXl5eRkPP/ywwEUikYhAHkajkXAumUx3MmeYvq+z14i7J66/Xq+jXq/LvwuFwlgJXHKWkP8iFArJvDGVmfCoXq+HUCiE7e1tFAoFWCwW4Y4hfKBcLmN/fx/NZhP5fB57e3uYn58X/i3yTAwGA/zYj/0Y1tbWsLOzg0qlglKphJMnT8pBQd4HyvXXv/51DAYDzM7OYn5+Xri1gCN+FabIk5+GctfpdDAYDFAqlZDL5RCLxYQbyuv1YmdnB6dOncL6+joKhcJYijnLkjM9nFxd5F/IZrNYXFyUEtCMuHNdgTscT6PRCE6nE71eTxxN2WxWYEyNRgO5XA7RaFT4tA4PD/HOd74Tly5dQjKZRLFYxNTUlMClCJMDjgw/crI4nU585zvfQTweh8l0xKGUyWTw/PPPo9FoSBlwlrmfm5vDqVOn8MQTTwj/i9frFV4K7jfgKKpst9sxPT0t/G6VSgXlchl7e3sol8sCL6OcJRIJiV6lUik899xzODg4EB4izRVDGAAAgS+4XC6cPn0aoVAIn/3sZwV2wspbugqmyXQEqep0OqjVarDZbMJlRXkfDAY4ODgQviFyWLAseTQalbLr1Ke9Xg/1el04UQgfCAQCspaxWAyj0VEWYL1eR7fbhc/nE+6fWCyGQCCAWCyG1dVViXAPh0NEIhGBpBCmEI1GBepBGImGCbNpuCrPilarhXK5LPxWg8EA3/zmN1EqlZDP54VLinDLTqeDU6dO4Z/8k38i/DIm0xGPICGG1WoV2WxWdMloNEKtVkO9Xkej0RBdQ3mzWCw4ceIEisUizOajcuz/8l/+S6yuruKrX/0qwuGwwC74b0JMqF92dnZw9epVge6NRiPs7u6i1+sJtKdSqch5UKvVUC6Xhe8mmUzKnieUMRaLweVyCedfsVhEtVpFo9FAJBJBqVRCLBaDyXQE5YhEIhgOh7h+/Tq2t7cFqkyYFWWOXHGczwsXLki/KpWKnA2EVIdCIckc83g8iEajAhEymUwCmeaY8vm86FHyS9XrdSmjnkgkBDqTy+Xk/wCwtbUlz9cQL+rJVquFbreLQCAAp9OJYrGIzc1NGQP1PPUcMxapD4E71a44tve85z1IJpNy0eh0OsKvuL29jVqtJvp2OBxiYWFB9GWr1RJeKafTienpaRQKBeEbisViKJfLePTRR7GzsyO8UdwnPp8P6XQanU4H09PTAmuijUJahMPDQ1lzcv1QlzD7gjYLz1PaVKVSCZFIBIPBUZlwQseY7ZTL5QQKSc4zQoe4Z61WK6LRKDweD1ZWVvDQQw/h9u3b8gxC1Xh2Xr9+HalUSs5twu/6/T62t7cxNzcnMHpmmgyHQzz44INYWloSvsper4d8Pi86mNC+w8NDeDwebGxs4Fvf+pbwUFarVbEJCF8rl8sCWzxx4gQcDgf29/eFF8jpdOL8+fPCo5fNZpHJZFAoFLC6uipcnDqDolarCZXC1NQUVlZWMBgMxEaYmpqSvVcqlQRyXqvVkEqlUKlUEIlEZE/SXuCeNZvNSKVSiEQiAjckxNZsNgtUuVaroVgsCoSTXFKkctDZUITv8XnM7KBtUiqVUCwWRS6DwaBwIY5GI2QyGSQSCeHT45mzt7eHUCgk/Gi7u7tjziKeaeFwGMlkUiBq7CNwxyFQqVSEv4t2jW60uVqtFiKRiNj61M9c962tLeEa63Q6sNvtyGaz6Ha7wlE4Go3QarUQCARQr9fxsY99TPT7aDQao9yo1WooFArCLXrjxg2BMjOzlzqnVCoJ9JewwnQ6jY997GNYWFjAtWvXUC6XhR9yfn5e+KEODg5kbZPJJHq9Hvb397G3t4ezZ89ie3sbo9EIW1tbuHjxothNPHPJMUXdSvoC2m6cm/u5/aBOqR+k/eqv/ip++qd/Gk8++STe/e534y//8i/xuc99Ds899xwAIBAI4GMf+xh++Zd/WWTtX/2rf4XHHnvsriTna2treP/734+f//mfx3/+z/8ZVqsVH//4xwXyqVu9Xkcmk8FodATf+7Vf+zXEYjE8/vjjP/DYJu2H1yZOqXvYaOhppxSx1+QOoFFDPgU6cSwWy9hllZdKcgTxM2L/ebgyjZEXa/1OPl9fqnkRMpbi1bh3nTKsCRr1JYr95rho2PJz/k1jiOXqORYeFvx9GhhMQ+b88JDrdrtyKdNzQgw++6W5umiYH/dH95n9oWOC7+bn7A/HpY1L47zRAGG/j0tx1+nN+nJqXB+ORxMb83d46JMAl8Y7/xz3HPabv8uL+93mh7JEudVrb/w3/8+07Lt9jxcjzdei+0SZ5Rj5fvZVyxY5JIxVkfT7+B09Lv1/7h3Nv8XvAZCx8DmcE46B/6ejxTgnRj4JnUV1t5/TGXvcXuJ3+blR9vQzdTYhL2vG7xj7pZ3FlOHj1p5rwrFz/qjHtGxpGeIe4P7TEVWOUf+cFzS97zluvZb8GddP91nPHddJ/z73IL9HZ4WWa35XO6X0HuS+O04faCc0x2/Uq+wvs9/0HtDvN+4Lrofuh36m0fmldcBxe17vMwYHtHwYz5Lj9J7+HqESev9T73KdtYzTAcPvHSevxrNI90+vg55L/UfzGR73c/6e3qtaj2hdw3fSUaXPo+Oerc+u4+SZcsd3cn9pOeQYtf6hnuKccs6pT7VTSus3nlF8jh63cc71/qdeOU4ujH+O04lGHUi9ob/HzyjTWt8dd15qPXdcH/Scc2552aau47xonaH5CPkeyqrurz4/2Hc9fu49PU4t+xoar+fWOObjZPS484KySllhvwHIPtdnNefvbvv9OBmmPOn9YFwb45h7vZ5wD+k9wL4an6Pnst/vjzkI9flk1APG+WPjmDV/GPcsZVLbB9qW4DrrPuoMQ+N6cV7ZtH1m1PnGTB7jmus5MvbT2B/a8MZ+6DHp89NoV+sxsz9aZ/KP0T7jmaPfwzNdv+e4fWmUNf257i/PJJ4h3K/artTv4ztpn2l9N2k/vPZTP/VT+MM//EP87u/+Ln7xF38Ra2tr+OxnP4snnnhCvvMf/sN/gNlsxkc+8hF0u128733vw6c//ek3fO4f//Ef45/+03+Kp556ColEAp/61Kfwm7/5m6/73m/91m/ht37rtwAcFSd4+OGH8dd//ddSIGrS3pptwil1Dxrxu5M2aZM2aZM2aZM2aZM2aZM2aZP21m73M6fUE0888aY5pb761a/el3MzaW/tNsmUmrRJm7RJm7RJm7RJm7RJm7RJm7RJuw/ajxK+N2mT9mbaxCl1D9uDDz6IarUqvCn1eh3z8/OSMqqhYVarVcqgkg+mWq1iZ2dH+GfK5TLi8Tii0Sh2d3dRq9WkBK/ZbEYoFBKoSSqVgtvtBnAnPdnn8+HSpUsIBoN49tlncfLkSSmrrLmNgDspwRqmxHLW5MKpVqsoFot48cUXUa/XUS6XJWW33W4LlNDtdsPn82FnZwfdbhfhcBi3bt1CIpGQSgvklur3j/hvyDXk8XiEJ6HZbMLj8SCdTsPhcODhhx9GpVIRjL/b7cbZs2dx8eJF2Gw24UyxWCzCc9Lr9VAsFnHz5k1cvnwZfr8f1WpV+HQcDgdGoxGq1SqAo1LK29vbSCQSAplzuVzCZ2KxWOD1erG4uIjHH38cCwsL8Pv9sobENjPFWB8Kml+KKcTFYhG1Wk14A5iqrNO7yXmjy+DyDz/nM8mbw9RtclYxRfzw8IhDpdls4uDgANeuXUMqlRIOCHIy3LhxA8lkEsPhUEpwX7hwASsrKygUCrh+/TpsNhvW19fxwAMPYH5+XjhA2u02CoUCvvSlL2EwGCCVSuGZZ56B1+tFqVSSNPlAIIB2u41qtYparTaW2t3pdIQLi3LOMtjtdhvxeBwPP/zwGI8MSwZrmKPmUNvZ2cF3vvMdLCwsoFwuo1wuw2QyIRQKYWdnR3iMRqMRdnZ2YLPZEAwGhTup3W4LZ0o+n0c8Hke/30cul0M4HBbOjMceewzveMc7sLy8LP0oFApoNpsYDoeo1WoAgBMnTsDlcqFYLMLr9eLatWu4ePEiOp0OvvzlL8Pr9eLmzZvI5XKyhoSG+P1+4TMxmUxIp9P4wAc+ILxohKToNPXFxUWR/UqlIrxObrcbVqsVwWAQkUgEHo9HIE6NRgO3bt3CF77wBaTTaVQqFeHMKJVKqNVqUmq73W5LWetkMom1tTUEg0H82Z/9meyzdrsNs9mM3d1dzM3NSTlyciINBgPhcCG0iKXTa7UaBoOBlIOfmppCtVoV3g/y07DMNOeA/BGaW4Q6jn/HYjH0+30UCgWZj263C5fLhVAohJmZGczNzUnZdwDC3xGPx+H3++HxeI7lkDLCOQgloN5rNpvo9/soFosoFosAjri5HA4HLl++LFxsrVYL+XxexmCxWPDAAw/ggx/8IBwOh3CgJJNJzMzMyJxzz3N/cy9Uq1XhjuMZRV6bg4MD0e8f//jH8dBDD2E0Gh1b3ltXbGu1WtjY2MBLL70knzebTezu7kqlQEJMyG3U6/Wwvb2NwWCAmZkZLCwsIJlMYmpqCk6nE4FAAIlEQnTyt7/9bTSbTRweHgqPHcvXc72pF2u1mvCnEHrCuaLs8/2zs7N48sknMRgMUK/Xxzj6qFtCoRC8Xq/wEGmYO/Vrq9VCqVRCKpXCwcEBqtWqcEo1m01UKhXhfuT7yQl1eHjEHUWIo8vlEthOOBwGAIEeWSwWgfl7PB4cHBzA7/cLTx3PG7vdjkKhILx93AfhcBher1c4tLxeL97//vdjampKYJRnzpwR7q58Po9UKoVwOCy8dA888AD6/T62trZgsVgQCASE14U8T9VqFYFAAIPBEb/fM888g0AggNFohGw2i2w2C6fTCb/fj83NTVgsFqyvr49F+DW0iWvicDjGqnwR+kObhbx55FPLZrNwOBzodDoYjUZIpVLC1bS3twe3241sNivjAI5Ica1WK7xe71jJeavVisXFRYRCIcRiMZw+fRrZbFZ4jygvnU4HL774IqrVKobDITqdjvDskFuTvHxutxvNZhN7e3vwer148skn8dhjjyEejyOXyyGdTmMwOOKSIi8T+ZDq9Tqef/55vPrqq7IG5AkinxMAlEolgbyRCzKVSuHw8BC1Wg1msxkPPfQQ3vGOd8BkMiGVSqFer8NisSCfz2NmZgZXr15FuVyG2WyGzWZDvV4XPqrp6WnE43GkUiksLy9LpS7Ks9VqRaVSwc2bN7G0tIR8Pi+cVCaTCS6XC7Ozszh58iRisZjwr+3v72N9fV24i/b391GtVlEqleB0OtFoNETeyPGmYXWNRkN0xurqKjweD8xms3Dh0WbO5XJoNpvY2trCcDhEKBRCKBRCNBqF3W5Hq9WCzWYTvkvyCIbDYeH87Ha7KJVKmJ2dxe3btwUuSnvb5XIhmUwiEomgXq+L/NK+oz4YDAZ49dVXhROQn2uY+HA4FI6zZDIJr9eLcDgMl8slZ8T+/j6ef/55gfU5nU6x1ykf3DNWqxVutxv/8B/+Q7Ej8vk8gsEggsGg7LdMJoPNzU3kcjnhaR0MjjgjqQ+BI16sZrOJbDaLUCiEjY0N9Ho9fOITn8DS0hJ2dnZQKBRQr9dht9vR7/fh8/nQ7/exv78vdCV2u124gYAjcu2NjQ34fD5kMhmsrKygXC4LX6SGKVPeLRYLYrGY2ITb29v3PYRv4pSatLdbmzil7mEjgSwVaaPRECJB7ZSicU5HBDkE+Ps03ur1uhBHk7CT3ycnEIlMW62W4OZ5wAJHqakmkwnVahWVSgWDwWDMKcVmdErx4sTLeLPZlGfQSGV/aAjS4cZLR71eR6fTgc1mQ6fTkTGQTNztdsvvdjodAK837vkcGk21Wm2ML6tSqaBSqcBms6FarWIwOOLs6vV6ckEmwSydAXxOrVaD0+nEaDQS44DjaTabwn2guUjI+8Bnck556ex0OkKyyXlg05xZwJHjikYzZYEXV32J5eXC6JTixUs7pTQhpXZKaS4irifXslarod/vy/rw3TQ26RjjmPk7nPNKpSLkrnRO8NmDwQC1Wk3+zfkCIAa5dkqRV4Ck15QXGjt0SjkcDiG25t4yzgXH22g0xmS3UqlIn7getVptrBQ2nS1cM+4DOnm4N3u93tier9fr8uxKpSKcOryQcj7MZvPYZbXf70v/OHZ+t1ariUOLTinKsd7ffAfngvuIRQPK5bL8Dt/N8dCRycsDZYj7nv0gwXmv15PPyPGhnVKcB7PZPLbPWMwBgDiL7HY7rFarjFHzfLA/dBRQFlutFtxutzjqOR/koaAscC9zb9FIMzql6FDlO6izqAM4Vu5NADImBiF6vd7rnFKaP4r7Wb+XBRh6vd6Yjjo8PCqEwc9IIs19Qn3CteRedDgcKJfLcmGlU4pOBMol9wALKlDP8GLHvcd+VSqVMacU9QwvdFwvFpaoVCqyfyhDFotlzClFZxx19HA4lOBMrVaDy+USBwILe+i9xL1NrsXjnFJa1im3TqdTZIVrovet0SnFfpPMnPtKO6XoFKGeMOpKkgpTH7darTFSbvaBzlPN0UgnPp005NWhU4qXLsoOx6mdUtTt2imliwi0222ZWxbN6Ha7IjNcQ13ggHLB9WP/6JSiw4wBH76HBMSj0WhM5w2HQ5Eb/q2bMbhDpxSfxT3GfWUklqfzgzLF+aAu4/7nupIQm/rN6JTiXHCfcg4oG5wD/oxOKe5np9MJ4MjxRfmhXTUYDCSAYLfbZZ60DqPe4vml9Uez2ZT9SJniuUYZ0ufz4eGhjIfrSv3SaDTkc7fbLe+hHVuv10XP0DHPZ9CJQr4fzpu2wbRT6vDwED6fT3Rao9EY01t0LOv91e12RQ8wgEdbhDLDPafPW3Lmcb05B7TbNc8pbS8WaOG7aY9xLzLYXK1W4fF4pKABnSLU7Zzrer0uNgKdaZo3Scsw9c5xTinKoNYdPD/5DO4R2oDapmHQg2cmbSM+l3qOYzhu/o9zSrGgBu0E3ku4pnp8HDvPy3q9LgEvnmWUX/aB76D+pt1HGec8UGc6HA4JeN/vDilg4pSatLdfm3BK3YM24ZSatEmbtEmbtEmbtEmbtEmbtEl7e7T7kTeJd9JHH330TXNKPf/88/fl3EzaW7tNMqXuYTNWWOJn+v/6M1bRAzBWaUp/R/+Ofobx+fpz/U5Gso1wvbs1nSavvexG3+VxP9fvZn91v41jMH7HOCbj3Bmzu/gdY7n1u/XT+IeN63C3OdXv0s9ldO+N+vzdmrEM8N3ed7fPj/uOsQ9vtHZvNC/GOaH86LXm51q2dOSa7bi1O64vur/GqjWMXDJqrSPax7Xjnqf33ButkXGMRvgI+2J8jt5zx+kDPZ86O5EVnvg5IVrGNdH/1ll3WqfwZ9Qn7Iuu7mTswxvNIeftuH18NxljH/RYjPtfz+fdmnHPvdF3j9M3xp/rv3WWhXFPGffBG/252+8d99677XOj/uNneg/dbQzMeDmuv3oe9D44Trbu9g5m5XyvjTKj59Yow8f1iePR8qrHY+zf3fr7Rj/XZ85xjTJx3L74bnrG+K67zbFR1323M/lucvXdfkc/X+tS43f0//VZqtfge+nncXJ+XL813NP4HS0Hx73vu83DcfN/t98/7rvHrfdxdoneo8wyfaP+3K3vx8ku10ufccbfPU636cygu73TeH7o8evP77bfmcVi7Mdx63bcGh531h837/p39ZnNn+szRY/rOHvge12bu8mDPsuPO8fv9mzqEmMz2sjHyYjRDjiuz8axGzM39fywGh9/Znw3/02ZsNlsY32mHWHcq3fru7GvxnlgFq3xnLjbvOhnGPW4UX7upiP4vbs9f9ImbdJ+9G3ilLqH7cEHH4TT6USz2RR4DxW5PhToud7a2kI0GgUArK6uIpPJYG9vD5VKBWtra2g2m/D7/RiNji66pVJJDMdGowEAiEajcmDU63U0m01EIhGB3r3rXe/C0tISHn74YZw8eRKhUEg4OLSTgXA3pukTM08OhOFwiHw+D7/fLzwdhUIBrVYLAHBwcIBKpYJ4PA6r1YpwOIzNzU1MTU0JXxTx9oQI+P1+dLtdgeEwNddut8PhcAi3BvkLHnjgAZw4cWIsDXd5eRmPPvqo8G1wrpjm3Wg0kM1msbm5iWw2i3a7jZ2dHYELttttXLlyBW63G41GA2azGR6PB16vF81mEwAEPpFIJGCz2eDxeLC/v4/f+I3fwNzcnHCMEGppLEutuQ0IezGbzWg0GtjY2BiDzZETSTtcePFkCjn5OvTfmt9Fw9coi7qsLjlPbt68iYODAzSbTeRyOeRyOUmJbjabmJ6eRqPRQKfTQSKRwNraGhYWFrC/v490Oo1gMIhEIoGHHnoI58+fh9/vl/T1zc1N/NVf/ZXwE83Pz+P06dPCdUCYBXnKUqkUGo0GyuWycJjt7OwIFCUcDuOll17C2bNnsbGxgSeffBLPPPMMksmkyLM2wAjL0VDFra0tfPWrX8Xc3JyknOvLEWVxNBphY2MD/X5fOELa7bZw7FgsFqRSKaytrQl3Cdc8lUrhQx/6EC5evIhYLAav14vR6AhGwbXgc8nv9vWvfx3vete7sLGxgVgshkgkgq985StotVooFovY3NwUGRoMBgIrW1tbw3ve8x74fD7MzMyg1WrhhRdeQDgcxtLSEur1Oq5evYrl5WUsLS1hbm4OV65cQblchtfrFR60YDCIQCAAp9Mp+oqQ4Gq1im9/+9t4+eWX0Ww2Rdbq9foYXI8QJUJWLBYLLly4gHg8jm9+85vI5XKIx+MCX+Ka5vN5gZo1m02YzWbJOu12u8KP4/V6kclk4PV6YTab4XK5hDOL8IlSqQSfzyfPjEajAl8k9IL6bTQa4cSJE8LTwr3L/dlut2XvBoNBLC4uYm5uDtFoFFNTUwiFQkgkEmMcMtSlhCByDhuNhsBHCNEymUzCTzYzM4NGo4FisYjhcCh9bzQa+MY3viHw2MPDQ+EmY4n5tbU1/NRP/ZRAoO12O2KxGKampoSziBdMwpR2d3extbWFUqmEYrGIRqMhsA2HwyF6nRCan/mZn8E73/lOOc+oZwkJJsSM+zqbzeL27dvCkeXxeARaZ7VahbeLcK1er4etrS2YzWYsLy/j1KlTOHnyJJLJJAKBAPx+P/x+PwKBAIbDIUql0ljJcM4xZVJDSZrNJorFopwjdrsd7XYbHo9HLimE+hweHuLSpUsC3eP+8Hg8wlPGueRYNdydEJhms4lMJoNyuYyDgwNks1mRLcLQS6USut3uGA9Ro9GA2+0WuAohU+Rw4iWOUHO32y0QQ55nJpMJdrsdLpdL4GiBQAD7+/sCH2P/Y7EYPB4POp2O8Hm9+93vRiwWg81mQywWw+rqqqyzhkbzXYTjkA+wVqshl8uJriQsmmdyvV7Hhz70IeEgpN1Be+XmzZuw2+04e/ascNgY9xT3JaE9nH8N3eMaFAoF+R3C5TmPhUIBDocD29vbyGazYpeQr9Pr9crzzGaz8N9FIhHMzs4KL9YHPvABzM7OCqyPdtVgMJDzlVArDaOnvUW6hkKhgGq1ilgshu3tbTz88MN43/veh1gshnQ6PdYHfdaPRiPk83l87WtfQyaTEV10eHiIdDotPH7kXSNUcnV1Vbg4qRvtdjtWV1fxgQ98QHQhZb3VauHmzZv4+te/LuMjBUMqlcJwOMTJkycxNTWFfr+PRx55ZIzfSUPyyZOUz+fR6XTkLGy1WmJTzM3NodFo4Nq1awgEAsIHFovF8Nprr6FWq2FlZQWDwQD5fF64RIPBIOx2+xi0TjtULBaL7F3Cu8mZRq5F2rczMzNYXV3F7OwsXC6XwFwLhQKAI26jbrcrnGnktspmszh9+rTw9plMR1xS5LDyeDxwuVzCF0m7hbBIp9OJeDyOra0t5PN5OSt6vZ7oz0gkIvrP6XTi0qVLiEajcLvdyGQyqNfrCIfDsNls+OxnP4v5+Xk4nU5kMhn4/X5kMhmhvsjlcjg4OMDKygpcLhc+9rGPwW63y1m+sbGBEydOoFKpwOFwiCykUikJqPGeEAqFZK0Jm9ve3kYsFkO1WoXT6cRHP/pRrKysYG9vD3t7eygWi8KHRy7AQqEgQYp+vy9rvLGxgYWFBeTzeQQCAbRaLTgcDtF5lGfSAlA/lUolJJNJgU2m02l0u93v/YL3Nmxv1vk2cdhN2o+qTZxS97ARQ09SRZKr0qhi4yHZarWEI6lYLArPB59Fg4W/Q8y0xWIRZxCj5HRykKyQHE+8FKRSKbhcLtTrdSFk1Bdy8mE0m03UajVUKhUUCgXhIhkOhygWi8INVSgUhLATgGDTeciZTCY5gMiZQPJU4uxpyNKYJb6eBgX5tzjuYrGIQCAgGHqSwu7u7oqhrueXBgdJQmkAcVzsN/vDSzG5PDjHmtODF9ZyuYxUKoXRaCQGBrk4aPRo3L92SnHuG40G9vf3xZmonVI6W4AGJd/vcDjEOcV/G3mlGGWjga75U0iin8lkkM/nxUlFziHgiLCY8kJ+m0KhAKfTiUKhgGKxKISSJO31+/3CrXBwcIBcLicXJ5LFkgieFwkS5mezWeGjIaF4qVQSpxQAucxVq1UUCgWkUikx9oxOAW34c59ls1khOCbZpd4DvFgCRynd5GXRPDHkomC/+WzO92AwQKlUQjabRb/fF6cU14EXZjpMeSlIp9PIZDLCJ0FDtFQqyf7jxYx8E8ViUeZtNDria8rn8+j3+3A6nbJPyfMxGo2ErNzj8aDRaMjf5PWgPqFDr1aryeWu3W6LfNJZyb5oOeG+pTOA/BF0EpA/jXv78PBQDF0d+ST3i+YdoszxIq2dUprfRnMIac4hOgapY8ndpcmjyZnDfQ8AxWJR+Hi4P6hftJNfX6B5kePa03lCXhA6vvg8GvU0rhuNBgqFgjj8Dg8PRea4J4rFohjXdErx8sLAiF7Ter2OVCqFbDaLcrmMUqkkPGTUP9Tr5AFJp9PY29uDy+Uai4JrLj1mafDSRKcMn8/LnMViQblcFpnlPiOHSalUQj6fh8/nk8uD1+uVYhKj0UicUsbCDY1GQ/5NjhbqOp5H5BTiRRCAXJpZMITzwXfTaap1LNeYXGLUNXRM0cHPc5K/yzWgM478M7xcclyawJqcdpQvyi/5zkwmk1yuTCaT8EH1ej2ZZ8q5tkMYrCDnEC/JdED1+30hGCbPGi95lAPKL+ePOofjIy+MDqbt7+9jNBqN8edQftPpNGw2GwKBgPDufDenFD/X68Bzv1AoyF6k7UGnFAsDUA8wYMBgkHY2kleItg2DYsPhUVEA9kc7pYbDociTDipQ31BeyLXFwhF0emQyGezu7qLdbiObzYptpIsMUCaKxSIymQxyuZy8nxd5yg7tQq43balSqSQ6ymazwe/3Y39/f8wpxfMgnU6jUCiM2Rf9fl90Fx0JdFQxkEbOQdrG2WwWjUZDnLPkYyLn4MHBAYAjLqhMJiOOBwZkMpmMOHH5XovlqChNq9USm4hBQp0BqZ1StIe0U5BE5aVSSQqsWCwWOJ1OOXcYIKZtxXVsNptwOp3I5XIIhULClwbcKV5B5xltKQbHeI7SKTUYDMRm4bh7vZ7oZ+qeTqcDh8Mh9gP3Mc9krjHfz4IKtKWsVisajYbwWup9yHM6l8vB6/UKlyhtjWKxKE6pcrksThDqWJ6r/D2eZdlsFh6PB9lsFvl8HuVyWexukueXSqUxWS6VSsJJxr7T2Um9zvOf/Fjaic4gKHkO73eHFDBxSk3a269NOKXuQZtwSk3apE3apE3apE3apE3apE3apL092v3Im8Q76cMPP/ymOaW+/e1v35dzM2lv7TbJlLqHTUdDNXaZEWIjXwWjy5o7A7iDoecfZmdo3D6/x8ZIi47ksnoG+6WriRmbzjDhvzWWX6fq8+eax0DjtHVkitEcRlyNuHAdeef7dKo1x2IyHVVYI8SIP+MY9Zj0POoIpY5U8vmMwDIaCGCMK8qI8WekjVlLx3EYGLkajuMo4HcY5eV7yC+keQyO47LQ0L678SjwnRr7z884D5wXndWln8150VFHLaOMpuoIMcdFmBL3hobY6TlhtFuvl+43+8NMHI5Nw6aMsqx/X/+fWSp673As3KfHcTlwTIyI67/5DGbRuN1uiWgz0q/XT8soxzccDiWzUld81HNh3Gs2mw0ul0vkhXLEzBhmMYxGI/kedZPm7jGuiXHPcO9zrKPRaGxtjTLHfxOmyowCrRP0XPP7xjnXnE80rLSO0frCuJ7GPaBhV1xLVkw06iItH3wXsxO474/jxTHKtN7zd+Pf0Fmd/I7miWJFKcJlOGb+2263w+v1Anj9ecI11lBg9o1VBI36gNkn3G+EK7Oqku6/USb1mcH1Nc6LXh/+W+9VZsHqOTbqQmP01/hv/R6tTzRcXa+NXnujTB4n20b9ctxZyLkx7i09fi1juj+s4KazP/l9Pc+UE649n6Wr6um9Ydxzxn4x+5bf4fOP01vHzTvfwTNNn4PMVgQgkFKjHcKsB2YiGX9u1OWak8ao67WeMb7D2G/KPoAxvaLHq+WTZx31mzEjw/i+486S4+bPaB8BEL1t/Py4f+vsTn12a52g9R3PUk01wExsbWfpsTB7zNgfvSaUSfZdzwv3BWWEWS7MtgEwpmsBSJU0PofnrnGNjrODjptv497VtiHhZvyeESbJDEwt27oPwB3+Jq2v9Pi17j/unDXaNLT/9TiOO+OYzal1EWWBGU9axrQtbJxDZqAx81mfoTorVuskvku/n/OmK1lbrVbJoNcZa0aOUOPeNe5z6jMtC/yecV3YJ9qseg7u52Y8K7+f35u0SftRtIlT6h62c+fOwefzYWNjQ3hPWHI7kUggEAjIBd9sNiOfz6PZbCIcDmM4HMLj8WA4HEpZYvIqHRwcIBgMolQqYTQawe/3Cw8BFb/H48Hu7i7i8TicTqd4uM+fP48zZ85gamoKKysr8Pl8AufRjdwbuVxOIBiEN5lMR6XCr1+/DuBIYRFmlclkpAQyjSKPx4NwOIx2u41KpYIbN27g9OnTAndh+Xen0wmXyyXOAsIr/H6/pNETn+92u5FMJvHMM8/A7/eLIRgKhXDu3DmEQqGxsvYAhO+H/Fi5XA6lUgnpdFqggo1GA7u7u8JnMRwOcfr0aeEK4MHIOXY4HJiamsL8/DzW19flwqYvYF6vVy515LRh2rLT6UQwGEQoFMJoNML+/j5u3bolKf6pVAqzs7Pw+XzCU8WLMB1DLpcLbrcbbrdboIN0gugL3Gg0EqghYVaEKRaLRezv7wv/RyqVQjqdljRvl8sFr9eLdruNjY0NrKys4OLFi5LKns/n4Xa7MT09jfX1dSwuLiIQCAhn1N7eHp5//nnhwVhZWcHi4qJwNjFtnvwSe3t7krJNOAHTz2kkv/baazh9+jQ8Hg/6/T5+4id+AvPz83LJGY1GMt9MH2eaNvl4rl27JunbdEKSB4L7lNBaQmCY7k++t2QyiUqlguXlZYHmlEolgRy8973vxQMPPICFhQXMzc3JfvZ6va/j/qKx2Gq18JWvfAWhUAhLS0u4du0arl+/Lmnt5XIZuVxO9tpoNMLKygp+/Md/HJFIBOFwGDdu3ECz2cSJEyfQaDRwcHAgBuXTTz+N6elp3Lp1CzabDeFwGH6/fwz6SAhvvV4X6AvhjuwL+/qtb31L4Fx00FksFjF0nU4n1tbWEA6H8cILL6Ddbgs3F/l/yKXDuSiXy2Kgj0YjhMNhgQQtLS2Jcd1oNBAMBgX2EAgEBNJEuCAA0b+dTgeRSET6bjKZsL+/jxMnTgh8xOPxCFed2WwWaF2v10MwGMTCwgJmZ2exvLyMM2fOjHGC8SJO2BChDYQpOhwO1Ot14abhBXI4HMq5sLW1JdA+t9uNEydOoF6v48UXX0Sj0RDYBeEH5XIZ5XIZFy5cwD/6R/8IFosFBwcHMlbKWywWQzgcFmgxOZ+uXr0qfDOdTgf5fB75fB4LCwsC3bh27RpWVlbw0z/903jggQfEYUVes0qlglwuJxc5QqAIiYpGowJJ6/V6AlctFouwWq3CRdbpdASisrCwgIsXL2J9fV3mhrrQ6XTKJYmXGaNjnc42QmEIyen1egiFQgAgUCTC5BjscDgcCIVC8tlxznZCRqlbOA+1Wg3lclkgscViUThQAAjsh/AyzgdhTZSdQCCA6elpXLt2DdPT0/B6vWi1WsIvRehwvV5HKBTC3NwcRqM7kMZut4tkMolOp4NUKoVwOIx6vY7hcCh8RV6vV/aYhgydPXsWjz/+OGKxGNxuN3w+H1ZWVuD1eo91vOhLPeelWq1ie3sbN2/eRCQSAXDkVPjmN7+J1dVVWCwWvP/97xcuRu0AKBaL+PKXvwyHw4Enn3xSss95oaRep01F6DH/T/6nRqMha1Sr1cYcZMViEe12W5wehCrlcjl0u12EQiHUajU4nU4AgMfjAQDk83n0ej0sLi5iaWkJwWAQy8vLCIVCOHv2LKampiRIpR1MhC5rmKN2+muHiIZvUk994AMfQCwWE7k2OlGAo4t3tVrF1772NWxvb8NsNsPr9aLf7+P69eui37j3ms0mfD6fcDyWSiVsb29jc3MT6+vreOSRR/Cud71L9gvfVa/XcfnyZbz66qs4PDyUfWYymcTWCofDWF5eRq/Xwwc/+EFEo1FxcFHW0uk0tra2cPPmTTz33HO4cOGC8FcOh0PMzs5ibW0Ns7OzGAwGuHLlisBLAWB+fl6oMgBIcIo2ktGRyvmmfqCcELJHu7BQKAhfEfd6NBrF3Nyc8CFWKhWxDzW1AB3Bo9EImUxG7Cc6YijD5O6y2WwIBoOo1WqiK5xOJzY3N5FMJsfmbGdnB6FQSIK7zWZT4INut1tguo8++ijOnDmDTqcjsE+ej1evXoXL5RLdZ7PZkM1msbu7i36/L2c5oYMf/ehHUa1Wsb6+jqtXr6JWq2Fubg5msxmZTAbNZhM3btwQio5KpSKQ0MPDQ+RyObRaLUxPT6PX6+HKlStIJpO4ceMGkskkPvzhD2N1dRW7u7vY39/H1tYWQqEQfD6fBLDJScW1JGUB7xn5fB5zc3NCUUJHPukfNB0BodkulwvxeBydTgdOpxPb29vf2+XubdomTqlJe7u1iVPqHjZymjSbTVGi3W5X+DloBPLQJDGrvtgMh0NxBpE0uNFoiAOFjVFFRsH4f15saNTkcjn4/X65IGknhm50IJVKJcHM62wIp9OJdDotRhedLBwzL4yMuAGQ/oxGR9wh5E6wWq1jlxUeGporRUfriZ8vl8vY3d0Vg8BsNktqKZ0lOsOn2+2iXq8LBr1YLKJWq8mF0WQyybjptBkOh3IY6kwVciVx3kajO5kqOiNmNDrK4GHf6Qgivt5ut8Pn8wlJKsntOcZ8Pi/PcDqdQoxJI1oTnZM4k7xSOtLEdaJDTHNK8SKVzWZRKpVQr9dlbshtRXw/LwLValV4IHgpdjqdIs/NZhNerxdOpxOj0QjZbBY7OzsSkaVByp/z2XSQ8dkkvKfs6Ogt+9lsNtHv97GxsSEOJR2Ro2OKlz06ByuVCvL5PEwmk1wMAQhfBS9/5HDhHNDZQt4IOhgqlYo4nEiKDwCFQkGMPfK8mc3msQwBRpSZudXpdLC3tycX6N3dXSHfJTcLZYjyXSqVsLOzI/xvOzs7wslBHhJmAd64cQPFYhG7u7uwWq0IBALiZNVOKTotyWVFYtNUKjXGb9NqtWSPMmLJeaKTOZ/Pi7OZDj5eCOicou4g34yOhNJxwcsA+0iuN+5hGvuUezqcKQc0Vtl3zne1WhVOEL3H+T1eusxms3ClcC9y/nRWGnVVp9NBuVwWGbPb7TJm6lNmj7XbbXi9Xuzv7485SihTLM5gs9lQrVZlDShXpVIJGxsbsFgscrHmdzweD0qlkpAE06lULBaxvb0t3HokgOaeJncHOd42Nzflsqc5ccjxxgwr7gu73S48ebxAcN2sVisqlcrY2tKZQQ7E/f192Gw24T4j0TgzATSv0HGZDuyj3qO80AAY41GiE5J6lZcirjPl2phlxvUkHyK5GNvtNlwulxRw4O8ywMF3cz6YIUl9xfmhc5h6h/JA2e33+8JzNxqNZC/p/cY9xrOF8kb7geMh51C5XMb+/r4EjDweD7rd7tgZZ8xE0XNP3XFwcID9/X2xVxgQYObMtWvXUC6X5bnsT7VaxebmJux2O4LBoGQA0vnF/Uwd4nQ6JXhA+4a6iXuR80LdwLNeBwUqlYroVso9M0o5T7RN6IjtdDriSCfnDjPBtFOKDng6kI7L0OG/KRdcc7PZjO985zsIhUKv46fUWYnAUWBle3sbBwcHMJlMErihDmYwkLJF3keHwyHcZySp39nZwZUrV8QpyP41m01sbGzg4OBgbJ9RJmk3kdfu6tWrCIVCkmFNmc3n8zg4OMDBwQGq1SoymYzsV77LbDaLzchCHwykck75f57/1FHHZdxQ1o/T0+VyWc66crksgTPu1+FwOOb8tNlscpbrjCCuPbk3Kd88g7mu3Od+vx+NRgPValWKMGSz2bHs/8FgIJxatIXIYwlA+Afb7Ta2t7fFpiDPIM+BVCol9lqn0xEuS9rv5L3ivWNzc1POke3tbTknTaYjbtdWq4V8Pi/rQBmnjUkbTj+ffWbAjA4u8htSBpjtpTl1ec5XKhVxiLJoCfc4kSLa5jNmd/E+RXtk0iZt0t5abcIpdQ/ahFNq0iZt0iZt0iZt0iZt0iZt0ibt7dHuR94k3kkvXbokjrnvpw0GA7z44ov35dxM2lu7TTKl7mHzeDwSNSLunVEUZiPozxjtotJgNIAYb0bmGZVjZIwRFEaUCC9gVIHRPh1h1twzhAyxj4TfMFp3HE6bURLgTnSUUScjvwDfwyjscDiE0+kcw58zus7PGEniXPF5hE4Ryuf3+yUKxnF7PJ4xiAX/Zv8458yaYLSbY2GEh7wXzOwBIM/Vz+e8st8cDzOk9HwY/xDTzn4yCsvIP6NZmhvAOC5jto2WAc0jwO/rKl+cb/6MsBG9jr1eTzgFGOVn5Jzl0/ldZmDoLBLKEteeHCFGeIOG3zDDSfPdUKb5O5qHxG63SxVJ4zM1l4jmFqB8MzOPc0k4lebR0PwFnDdmzfAdlAGO1WQyCQcPs9h0H+/GecFMG5aDdrlckinGCCblmHuE8F6v1wuLxQKfzyfrrjkfNA8Sf2bsB+eLmYs6skt9QhnVkBNmUlL+OA5GyxlNZuaBzqbiH2alcL/yfXoN+GzuS1Zqom5gxJxrzr2k38f9oGWDMD2uo9bNOlbDuaYuZYYUf4d6hpFaZrZQXhmx5pwb9yrHxTnR+pPZedyr7A+/6/F4xmBpnDPqGf1eZhIMh0fVqjiPzEBj1i11PTPulpaW5FzjWcGf6ywEPedah+k/HKfOXNBnAueX2WLUK9zDzEZhM+pG3TRnCr+j593YtJ7R/6ds6T7zD2WLMkXYiOaEYhYR94rOLOJaUi4IpWHGgcPhELlio37kvtbnBPvLjAltGxwnE1x3k+mIy4ol2ak32J/jLjb6nNMZQMxG4DmgoU2EwfPs0meZ1s/MFNE6WJ8VGpZDuaLccT659mazWTJe7HY7Go2GnFW635pPiOMycgexUcdzPDrjS8sb9bC2c4yyyv/rd/DdLpfrdWeS1p/avmS1TmbamEwmyazlXLIvw+EQwWAQbrdb5pTZfKFQCF6v93UcRMy00+cS15frR71vMpkE9qnPG64Vs9tob/Jd1C+kECA0kBk5tM+MEL3jmtEO0zA+Zt0x85L7lfuZOpuVoNk/Qn2NWenHraOm6jiuP9QlxrWlHNPu4u8b5UfrVMqXz+cby6Ljc5nhrnU2M8H1fFFHRSIRsV20vuafdrs9hiQwck5qDjPKCfUbAMRiMYEiAnf0EGVJnym6b8yu5Rlts9nkfmS0EY37i8+jXuNZdz83vX+/39+btEn7UbSJU+oetpMnT8JsNmNzcxOhUEhSRH0+H4LBIOx2uyhzn88n/AhutxsAREnzAkfowubmJrxerxixDodDIIE04jXnRDAYxOXLl7G6uoqVlRXMz89jeXkZPp9PysXabDbpY6fTgd/vR7PZxP7+Prxer1yyaYxmMpkxeAy5ipgertOuvV6vQFY2NjbQbrexsLAgacOaP4NjIiTC5XIJF0W324Xf75eytUtLS3j00UcFcuF0OmGz2XDu3LkxpxsPNULOmM5/cHAgpYRzuRyAo1Rilibe399HMBjE7OyslLMn6S55CwDg/PnzWFxchM1mkzTiVquF06dPy8GpnSA0Gmj0ut3usX5evnxZeJ+WlpaE+4Np0Lx0cy08Hg/cbrdwoLDUL0tsDwYDMSgsFgtu3LiBSqUisCSz2SyQ0Z2dHbz22mtSThgAcrkcVldXBda2u7uLxcVFnD9/HslkUqAOJpMJMzMziEajwnMVCoWE72dzc1MMv7m5OUSjUblMUAZYyp1p3IQEsZQ4ecb6/b6UZzebzYjH41haWhKuIM410+y1M5LGcrPZxO7urnAejEZHMMl+vy9jpCHc6XQEJkMuInKN8B1LS0uwWCyo1WrY3d2FyWRCLBbD+fPncerUKSwuLmJlZQV+v3+M80sbTTQay+UyvvKVr8Dr9WJ5eRnb29t46aWXsLOzg9FohIODA4EPeL1ehEIhzM7O4uLFi/B6vXjHO94hlxhCoQqFAiKRCILBoBiZhBKyL7yoNBoNlMtlZDIZgU3U63WMRiMEg0Fcv35duL6Ymk8oIHnVCA2rVCqIx+M4d+4cvF4vvvOd7yCTyQifHcfRbDaRSCTg8/kEFmAymRAIBOQi2el04Ha70el0MDc3h0KhgHQ6Db/fD4/Hg0qlgvn5edEXhN9Sv/B9dH5RNoAjh+rNmzcxPT0Nu90u0CCv1zvmEHO73Zifn8fq6ipmZ2dx/vx5BINB4aQhZ121WoXL5cLGxgY8Ho/I697envAhDYdDgXXQaZBIJARKWKvVhC+u1Wrh5s2bwgmk+WKq1Sra7TbOnj2L97znPTCZTCgUCjJnhIdowv1YLIZAIIB2u43//b//N/b29hAOh2EymcagN4R6WK1W3Lx5E//6X/9rgXR0Oh2BA/LSSxhuu92Gx+OB3+8XTinqPg2h1ZArQvmoB5LJJB544AHMzs7K+cdgD7nQqDd1cOI4viPKmQ7C6ACIfoYO9minI7/LSywhjSxJTkgy9c3t27cRj8eRyWQQDodhsVhQr9eRyWRgsRyVguc85HI5+Hw+ObdtNhvK5TJOnjyJarWKXC6H+fl5lMvlMX6lQqGAer2OYDCIaDQql04Nn41EIjg4OBAuMcKO6CzXvC0ktA8Gg3jmmWcQjUYRCoUQDodRqVSwuroql12j40RfbgmL2tvbw6uvvopAICD8b3R8eDweXLhwAU6nE4FAAH6/X86yRqMh+m5qakrKvNO2aLVaAosMBAIYDo84GPv9o3LxPp8PtVpNKAO4b8hL2W63MT09jZdffhl+vx/BYFBgeYRCBoPBMccheYy0gw8ATp8+jfX1dXi9Xpw5cwbBYBDAnUAYL9gaQqflU58B2mnB+eVePHnypPBaEZ5IPUFYqt/vh9/vx6uvvorPfvazcDqdSCQSsNvtKBQKAk0ld1u73Ua328W73vUurK+vC9R7d3cX3W4Xzz77LB566CG4XK4xXs1ut4vr16/jhRdewO7ursxxOBwWey+RSGB9fR02mw0PPvgg4vH4WOCh1+uhWq1id3cX169fx97eHrxerzhf2+02AoEATp06hZWVFdhsNly/fh3f/va3MTs7i2g0ipmZGdlbRqe1nkftwNPQ8Uqlgkwmg/39fUSjURQKBbH9ms0m3G43dnd34XQ6MTU1hZmZGbGtyJlFx7nRuUq7j1QMsVhM7DftiCIkn/Bb7cz1eDxCVbGysiI8ndR71HWExfEstdlsePjhh+VeQVur1WrhlVdekeALg3/7+/ty5nJ9rVYrvF4vPvjBD2JxcRHRaFT6yDOqXq/j9u3byOfzcp6WSiVxVNKZTjtqMBgIzQKf9Q/+wT/A/Pw8Xn75ZYxGR9xr5P2jTUa7Wj+zVCrhtddeg9frRa/Xw9TUFG7duoVAIIB+vy+0F5pOg2tDypFwOIxCoQCfz4e9vb1jbnL3T5s4pSbt7dYmTql72KrVqih9OpfoqAHuRC95KNGQ01Wz6MQg3wEJGRkRYRSHf3R0nZwlNKar1SpSqZT0h1xS1WpViHBpRNEAIfeDjuwCQLlcHouekyeJJJ48cBl9oPOJByAvB5wD9klnn9DRQew5oy+MjGSzWVy/fl0u1DR2KpWKRLN0FgINEM4pL8zEugMQ5wPnmPwmnEs6zbRRur29LfxDmhOEmSN0SjGCpCNNxOzr6OXu7u6YvPDiQ94RZgfw/eSQstlsYtAxak6DSJP0kidEZ0EwSpzP58XZoLOpyEtCx2qtVhPuK84nZZ6XXzpIPR4POp0OstmsRLX39vaEC4zzQm4L8nrxwkqnD7NsOK5GoyHrTKJhOjTo9KNsUiZ19gvlu9/vo1qtYjgcyribzaYY8Lxs8zncc8w44zvo6OMzGNVNp9PiJCZJ/3FcFzpq2Wg0hIw0n88Ltwc5xsiDwIsfOTRu3rwJp9MpEXFeDmj00hFErhzKqObJoXHbaDRkDRgNBY6coOSIocGruXEYseReYESdnFjc++QM4f7nRZPOATrCqXeoJ+kUKBaLqNfrcokcDofCC0J9MRqNJPOPnBQ0tin/lF06Yfl96mQ2RpsZ8TaZjjhpeHGhvibnFZ24JFTl5b9QKAgJL7M1SIBrMplwcHAg/Evtdlv2N8lZOVY6L3SWQTqdxmuvvQbgKGVfZ+BouTObzeLI63a72N3dFdJYyi2jyORGot575ZVXYLfbkU6nxbFAnUS9TV3vdDrhdrvRaDSQzWZFH/F7eq45d8wGps64efMmisWiZPjygkMHqHZKUS9qhwEAcZZwz+oAC9fW+AxeKHmp0d/V2RW8mPFspkN2OBwik8lIwIY6l/+n7qdeb7fb4qAHIFkb5XJZAin6LOK4eNEjTwv3mzH7utvtAoD0m1lEPId5RuoMoVu3bokD2ev1otlsCnEznRN6jo3ZY9SxOzs74hAmsXqv1xNdpTNKmQHT6XQkWECnAx081C3MmiHvDznNGo0GXC4XWq2WcG1yfsnHRnup0WjIPGjeR/I4ab3MOdS8VACwv78PAHLRpuOIc8EzZzAYiI2k5VM/y5iRpDOGUqmUODW0DFJ+mKHtdruxtbWFQqEAh8Mha1yr1cQ24DnOMW9sbMjzyLfY7/fx8ssvy1lLnUp9eXBwgM3NTRQKBZlj6lfqL2ZPMTBA3csxkI/o4OBA+ss9dHh4VOihXq9jb28PVqsVBwcHuH37NkqlEvx+P7a2tuDz+cb2vXHvG7OjtGOK+pok57VaTfiVOp0OHA6H6Gw6K2mDeL1eZDIZcdrTKab7QnuvWq0iEAiMcY3pbK12uy16V9tEDHwVCgVZB+2U0llImh9LZ33xDKAMb21tSdYW9QB5RHXWJLkdX3nlFaRSKQlW85yknk6n0yJLDGox2DMYDGTM3L+0GWhTbGxsoFqtilOIdwHy2VG/cf9RpsgfRX1G/Ud7grpRO6W4NjwLeAbR4XU/t4lTatLebm3CKXUP2oRTatImbdImbdImbdImbdImbdIm7e3R7kfeJN5JH3jggTfNKfXKK6/cl3MzaW/tNsmUuoeNjilG8oh1ZnbQaHSHK4GRG6bUms3msQgguSIY2WDWDiMzjHYwMsMILNPNmWETDocFxgJAIimMHjDyYbfbJXOK2QX8Hb5DZzYAkIwWzUlCPgGbzSYROVYkIs8Vf598LszyYMRLR56AO1wzxKETEuJyueDz+SQCpTMsdKSSEACm9etsrFqtBovFApfLJVwU7J/GtNvtdoGOBYNByQ5iRSlCEJnpwP9zrXWEi2PknDLbxufzye9Uq1Up98ssOJ1lpWEnmjvH4XBI1I3wN807omWQzyV0UHPtcPyUU4fDgXg8LllQnCdW+SH/gd/vlyg8ZWM0Gkn5ZsLydAVKncXCSBf7y/lkvxmZm5ubg9PpRLvdRqFQEBgS5UVD+ghlYuZBs9kUKFWlUkEsFpOoGTMGNF8CG+ddV5AkbxKj8l6vF16vV/g6NK+Useln9/t9iWZOTU1JxhUj+5RpRsCZmRYIBOB0OjE7O/u6alaUOcoJI8bcL8xEYkac5pWi3DFDaDAYSIUcyqiRH0hzOplMJkQiEYmgM4OB+klHffXe1TAs9o8VG/ksRm4J4WFUlPuXe8zIN8KMMz6v0+lIxJ2yx0qPzBBkdo7f7xf4sy7XzcyA4XAoEBnNIchxcE8CkMwHRn8JV2g0GrLnbTabVNhj5SxmhjF7q9frIRKJIJFISISfssEKhKxyRp0EHGXkEG7HddeZuNSXNpsNtVoNjzzyiOwVrpeGrbAxq8Jms4k+4JwWi0WEw2Hs7+8jHA5L1h/XitHuQCAwBlUbDoeSmcXnck6z2axAwDQHlT47KPPGLBUtEzpDhVm+OgNIZ9exT9T77IvL5UK9XofH4xF55nnD819n4VH+yeFG+edZyr4zS0LLks7aYR81NJjPpi71+/2v0+08H7lulPVkMvk6DkrKBiGeAARSSFgfszMId+UZAUCq1vKdfr9/DDoJAG63W+gNuI+p6/R4qXNY3p4ZOwDEltLZPfpv7jfOuYbpaa4cZo0TQscxEwpJu2g0Ggl0TmcIUZ6p95lRwiwZ/iEFAfUF11/D0dxuN4rFougszZfFveD1eiUz6eDgAIeHh2IX6XN+NDqCazLbcX5+HqFQSDJdqFfn5uaEWoE0EYSrMTOV2bRcx2azidFohHg8jkgkImehzg7W8kS6Bo0EoB5yOp1iYzEzlNWrOV7amXoPa7g+/6Zu1pl8lBFmnRNi6fP5hAuPe41ZfJxHQmCZuan3nN7DRl2jz3r2lX0zZnZpeTVCE41Nn+W0vzWPF+3eq1evim7lucpMJJ6hzFSjPUFqCJ0RyT3C6rLUDbRRqBO53rS5aCdRdy4vL0vFY64NAMlI0+tFWeZ5pc8c3Tc9/+SmM0I8Dw8PJQOQ37uf2yRTatLebm3ilLqHbWFhAQCwubmJmZkZSU32eDwoFosYDAaIRqOSFtxoNBCNRuWw29zcxOzsLAaDgRh7LAFrNpulbCzT1DXELBKJoNlsIh6PC2TL7/cLv00ymRSjhDw9NpsNuVwO+XweoVAIyWRSUlsLhQLm5uYA3IEd8qJMo4pl68mbcXh4iGQyKVAROgCy2Sympqawt7eHmZkZccSkUinEYjE0Go0xuBnJJXm40mHwyCOPCF8R8eTLy8tjkASr1SoGIi9FuVwOvV4POzs7cgDfvn0bo9EIt2/fFg4GHrJGIsjhcIhAICA8F+vr6zh58iSCwSD29/fh8/ngdDpRq9WQTqcRiUSEI0NDNmnc0NjUadcHBwdYWVkRbpAbN25gdnYWtVoNLpcL2WwWdrtdSizrSzw5OTqdDiKRiEB9PB4Pbty4IfAJciTxGeTaePXVV1EqlcT456WMDkvyRjz66KNIJpPI5/MAjgzjubk5tNttlEolxGIxLC8vy/tY3ngwGCASicBkMgk/GmE4W1tbAislRxkvxe12G7lcDpFIBIPBAMFgEOVyGfV6HR/4wAcQj8eRzWbxrW99CxcuXBhzhhFaVSgU4PV6sbq6imq1KjwWwWAQ3W4XN27cwIMPPohUKiVGHYAxOCUbL+HZbBYejwe7u7siE7lcDv1+H4uLi1hYWMDp06cxPT2NeDyOWCwmz2XTjlTCaP7X//pf8Pl8eOqpp5BKpfCFL3wBh4eHAhdlyr3X60U4HEY4HMapU6cQi8Xw7LPPYmpqSgxmXt7YZ8J5mObO/UwOL5Za5p4lPxIvFoeHh3jttdeE98JisQiEjLJFJwMhWadPn4bH40Eul0Mmk8He3h4SiYQ4Loyko9z3GlpUq9UQi8UwHA7hdruRz+exs7MDs9mMZDIpjljKCxvHrNtgMMDNmzcRj8fR7/dxcHCA2dlZ2O12ga/4/X6EQiGUSiWUy2X4/X4kk0msrKxgZWUFU1NTiMViopczmQw6nY44iPL5POx2u/D8UR77/b44isiZ1+l04PF4MD09jVarhe3tbdnzXq8Xe3t7SKVS2NvbE9hdLpeD1WpFvV5HrVbDhQsX8Pjjj6NQKCAUCsHn88Hv92NzcxNmsxlXrlxBIpFAOBwWx7DP58P+/j7S6bRAVjjfVqsV+XwevV4PgUAAN27cwM/+7M9iMBjg6tWrEhDhGHXxAsKi/H6/6ANe9l566SVcuHAB//f//l9cuHBBSrFTFgiHXV9fx9ramlx2er0e5ufnZVylUgmj0RFE86tf/SrW19exsrKCSCQiekQ7vXn50k58fcGjrufflUoFXq9X9ggh6hpmQ35Cco+1Wi3E43Fsb29jfn5eoDO7u7vo9Xrwer2it4A7hO3kP6PcMuDA/dXtdsccr3R08dzndxqNhjgmbDabFMvI5XJot9tIJpPiMKJupyONc1mtVuFwOPDss88iEolgenpanJzAUTBhY2ND+vbaa68Jbx5hYeVyWfgDs9mszDMdWHTcrqysjI3JbDZjenoawWAQ2WxWLorsEwMyWufE43HU63W88MILcvGKxWIwm80CBdKXfa4nnYc8IygfvPBmMhkkEgmUy2W02234/X6xP8h/Nz8/Lzp2dXUVJ06cQCaTQbfbFadAt9tFNBqF1+vFrVu3RL/SIUauRXI/accr95TFYsHs7Cxeeukl0YHcq+SyM5lMSCaT8Hg82Nvbw1//9V+jWq1icXFRnJoOh0OgtLdu3UKj0cDs7Cw++MEP4uzZs6jX69jZ2cHe3h5GoxHe//7349SpU6jVakilUtjc3MTc3BxCoRDy+TyuXLmCVCo1Bvnd29tDv9/HY489hosXL2I0GmFhYWHMgUObjnbowcEBUqmU2JQM3EajUZw+fRqrq6sCf97Y2JBgSDKZxMzMjOj347ijOMf8Q6hcoVAQ/WmxWBAOh9FoNPCtb30LS0tLaLfbY06QcDgMn88nBOc+nw/T09MSyOSYuPe0o4qOR+pH7XhiPzUfq3bOMJhqDELSduC/6ZzkGTQ/Pw+v1yvy0+v1sLe3h//4H/8jTp06hbW1NaFIyOVyKBaLos+pg6PRKJ599lmcP38eU1NTY875druNTCaDK1euIJfLiZNpa2sLrVZLdKLZfMRvWS6XcfPmTczMzAhE8+DgAE8//TQikQhSqdQYdxS5c/lZqVTC4uIiRqMR0uk0SqWSnGMcP/cF71FWq1XGRUcydV2lUhGuO0JD7+c2cUpN2tutTZxS97CR22Q0GgkJJf/Pw4cXNhon9Xp97BBjRIjRPrPZLF59HjxG/hNmU5BwkI6qRqOBra0tNJtNbGxsYDQayQHNw5MEsy6XC/v7++JAabVaSKVSAO5UBSJPDRUdeTOYPTIYDOT9xJ9z3MxMIvkoD1Xy3/CgZt81cSTn4saNG2Pkm6lUShxNjCpxvvSFt9FoYDgcyiWI3DD892AwGIsCM1pFQ4cGSqFQkItmPp+Hy+VCpVKRiCgdOJpvRmdE6agh8f+8kJPXgFVfaDDQeKURxYgT14XP4liZacfst3w+P5Y9xQwzHuD1eh25XE4MTOBORToaSbx4bWxsoFgsotFoyDyRN6rdbuPg4AC7u7uw2+2y1jTI6JRh1JeGd7lcFsdJu90WZxAAieDSEOdFodvt4tvf/jZ8Ph/q9ToODg7EAOTvUWbJ+UJSznw+L/w/lOnd3V3ZdxybziDhAc19SucLcIdngdl71AG80JDwmuNlMxoLh4eHuHbtGhwOhzgctra2hJOEBjuzc6rVquyL3d1d4Y/SmU3UH5rrQvO/MTuo3W7L/iVfFjPMaBT3+31kMhkx9rnP2Ac6wTi2wWCAdDot1a548WZUnDKmM6XoSOI6sh/lcll0J/WN2WxGpVKRfU75ZjNGrCmvlGXKOjMl6bg4PDyUzAb2gTqtWq0KRxcdddTzg8ERQTb1Ox3QnBud5cQof6/Xg91ulwzJcrmM27dvS2ZJtVpFrVYTzjzqMmYP9Pt97O/v45vf/KbwXLHgAfuczWZRLBbHCjU4HA55NmWXZxQ5RTTn0nPPPTfmZKZDQRMYc8+MRiOJgHM+HA6H7NFKpYJbt26JzFEWKHvb29uSsUG9vru7K9UPeXk5PDwUYua9vT1xBhzH78Jz5W7Zc/oP9SZlWF/4tIODDhPOWyqVQqlUEo4jBpHoGKDe4pxS/vls6gzKoN7D+nLLDD6dKcX5oD7TWTk865hJwPdqJ67mnHrttdfgdrsl45V7sdvtynlkNpuRyWRkj/MCTV4r8s8BkKCSznbc39+XeeAfv98vXDo8h0nYz/FS9/b7R0Uvut2ucDuNRiNkMhkZj8440bJEh5HOYua88eJdqVRexz8DQDKE6DQbjY54g3Z2dkQPUAb7/b5kFxUKBdGvOnOHc0WHDR1v+nz3+/1IpVKSYa7PRq7f5uam6ItsNotOpyOE8czCot1GGazVanjppZeQSqVEx5KE+vOf/zxeffVV4SwrlUq4efOmZLtnMhnJuKIOpy6+fv26vCsUCsl5pMfGflAH8eylvJPD8KWXXhJeSQZ1TSYTQqGQVGHWe1g7dzjHen3JaUf9SccJ96/mxeNcU6cyM9ThcEgGF53fWudoG0/bJEZZ1P1j3/mH32H2os6w53P4b82XxcAdM3Ep3yyqABzZX9QRzI7TmVLUy1/5yldw+/ZtcdBpp1+9Xkc2m5VM0MPDQ5TLZXEmsa8MvtP+Z7bvcDjElStXhDuM+5FnE/chs+noLKUz2cj7yDNW35UoAwzCUado/iv9nPu1TZxSk/Z2axNOqXvQJpxSkzZpkzZpkzZpkzZpkzZpkzZpb492P/Im8U569uzZN80pdfny5ftybibtrd0mmVKTNmmTNmmTNmmTNmmTNmmTNmmTNmn3QZtkSk3a261NnFL3sJFPifweTB1lKiu5TwhBIKkfIS3hcHgMikLiVJvNJimtGpKjU55JIkiMO8kp4/E4EomEcJLY7XYhC2YaMMn/AoGApPgbycKBO4TjhPC0Wi2Bz3EsLINOCAShRj6fT1Kn8/k8EonEGEEwySU19E4TkdpsNqytraHf76NUKiEYDAqun2nlTO+3Wq1jXEAkWC6Xy5JaXSgUMBgMkMvlhKg0GAyOQUcIQWCZ80AgALvdjnA4jEQiMZZ+zHnivDElGoCkdGuCYKZPk1uJYyfZvJYT4t6ZjUeCVKYrE0ZCXilyOFgsFoFEVKtV4ciJRqMCpSAEolQqAYDMXS6Xw8zMjERKyJfEFHVy+fj9foGjErZCOc/n87Ie7EsqlYLNZsPs7KzIDNOvSbxJuRgOh8K7wOeSM+zUqVPw+Xy4du2a9EHzn+h+WCwWIWgnqTthkYRZMaW90+kIrwvng2n23Fvc1zy4NbeF0+kU/rFQKCQRK+47TaBOjpfBYIBAIIBCoSBwgX6/j+3tbZTLZVQqFZEP4E7hgUAggMXFRTidTqysrMh7NFm4hhxpaC9hKITuaDgw9QLnhxCSfD6Pcrk8BjEhNx6hNm63W+Q5Ho8LLLPVagl0YHFxEQBkDgnZIYEtIZwk2+UzNUyBkBByCOk1q1arY+TnJJ/m3qMeOzw8FKL+fr8vsk64lSa2jUQiiMfjssf6/b5AUROJxFgpe0LzCO/QUDLuEUI+yLNB0l3yxe3v76PT6ch+IUyCfDmUoUgkgpWVFYFJzc/PC+SFcD/CbKhLyR9CCA25SwjholyTU+Ud73iH8MaQwJoQRvab68M9Q7gFidP5WaPRkD3e7XbhcDhE7vr9PqampjA3Nyc8hSyOAUD0PKGUXq8XuVxOeE/YHxLuksSefCMk7yffFPc957bT6WB6elp0CMuNayg5dZTf7xcSfhLTc8+xAAb/ppwXCgW0Wi0pmEEoLteTOiKfzwvvGWVQQ6sJ4yPh92AwEBgOCytkMhkhtCbflP49wrgJ2eE58sADD8Dj8SASicDpdArHVqPRQKPRQL1el/PYYrEgEAhIIQPOFWHMMzMzosdp54RCISQSCdRqNWQyGXi9XvR6PUxPTwtnEWGtjUZDeLSCwaCMn+ckbSSuD6F5nAfCtEimzXNxMBgIbJwFL27fvo1gMCiyo/UMdS71Wzwel6ISu7u7ePDBB8coCprNJkKhEEwmk/CJkTuSz2VfrVYryuUywuEwOp0OqtWq7AOv1ytzRSi8LnhCaLzVaoXL5UK1WhUuvFAoJMVuXC6X6H7yvpEbM5FICByrVqvB7Xbj/PnzCIVC6Ha7KJVKqNVqyOfzmJqaAgCUSiUUi0WB+2n7JpFI4NSpU6JracPw3Gu325ienhayaZ4L5CQlP+rS0pLYQoRm8mzzeDxj8Fb+Ht+lIbCUR8LhKKPUcaFQSOgvOC+UJepiTThOG7pSqUghE81jx9/j/wkL5f6l/Ul9zHnTTgCeHbQp9Pdoe1F/sVGfut1u0c3UWeVyGbdu3RKSfsJSq9XqWIEbrkm/38fp06cxPz8vUEZNaXF4eIhsNoubN2/KmAnfBSDnFdeBtAksTFQoFPDQQw/BYrFgY2NDdLTX60UgEBBIJfc/oeuVSgXValXI2ilPPp8PrVZL7FRNAaL3Mu8ZlA0ASKfTmLRJm7S3Tps4pe5hi8VisFqtaDQaUtGLGGeSBpM7hJ/pC0MsFoPT6ZQDZjAYIBwOC48SDU8eeJojgJcbHpTD4RCRSAQnTpzA+vq6GClut1uMDABi6LhcLszMzMhFie/nQaU5iXhgkCCZxvHh4SH8fr8cjCTcHgwGQkJqtVpf57Tzer1SlYtGOqvSkA/A6XTi0qVLwpcwNzcHm82GQCCAYDCIYrEoFWh4iPHiX61WEQqFhCCZhNskdg6FQjCbzYjH40KkSycJcHQZCofDmJ6ehtvtxuLioswpsfW86PF3SB4JYIznh1wsPKhZoQw44tuJxWLCm6E5sABgdnZWjJFAICDEr8T9ezweuQjSgUIjgITJJIcHIPxFNHiAO4YJ+9btdqVa1tramhghXOupqSnhDmDlKhqT5I6hQ9bn84lz6uLFi3A6ncL/0e12Ua/XBe9PBx95hMxmM3w+H+x2O2q1Gh5//HHE43EMBgNMTU0J34PJZEIul4PFYpF+2O12RCIR1Go17O7uygXL6XTK5aLT6cily2KxyP7Qldg8Hg+cTqc4TWgsagPS5/NhZmYGZ86cQTKZRCqVwuzsLNxut3Ar0aBin/v9PmZnZ3Hr1i2Ew2HhS/nmN7+J3d1dMWRp9PHiPTU1hQsXLiAQCOCd73wnZmdn4fF4xngo6Jgh0b/ZbBYCUXJKsF+UXTpOWGluamoK3/nOd3D79m0xEjlmEvjygqWdFXNzc3A4HEJqXalU0Ov1kEgkANy5qAAQOQsGgyiVSmi320gkEmi1WuKs5yWGfDC8oLDyGitxkduFF5ZIJCKXTeo2Oswp43T4sGoii0GwwuHKygpOnDgBn8+HWq2GbreLzc1N+P1+rK+v4+bNmxgMBlhcXJR9qSt2al4+OhrYf46HTjmz2YyXX34ZtVpNChKMRiPhVqHzaDgcIplM4vHHH5e1uHTpEmw2mziE6QihY4COOO6rg4MDIVanw4hrUq1WMTMzg6effhpOpxMvvfQSqtUqACASiYhDl/ua3Dt0krMIBgtZDIdDFAoF4emp1+vwer3CGXd4eIjTp0/jwQcfHCvCEY1GARw55YvF4liRjJs3b2J9fV32OR0vdrsdiUQCVqtV1pLOMTrR6DClLFQqFZw7d044A9PptMgS91S1WkW9XsfMzIzwxvH85D51u90olUrwer1CuDsYDLCxsYFSqYRQKCTOdfLF8Qyt1+vI5/PipOCe4nnGSzM5jOgc477lxY4cMk6nE6FQSHQj577f7yMQCMjZTgfK+fPnEY1GsbS0BL/fj/39fcRiMeE45JyQQJjE/OTSYgBtb28PZ8+eFUcseWfm5+exvr4uZMnxeBztdhtnz57F/Pw8bt26JQUAKD/5fH6s6Eq320UsFhPSZZ51PM/osKfslctllEolORd7vR729/dht9ul8uXu7i7C4TAODw+FXJ3BEO0AD4fDUuSEQY93v/vdwq8FAIVCAQsLCzCbzYhGo9jb25OCJXwuA1pOpxM7OztYXFwU8u9ut4v19XXE43GcOnUKmUxG+NwqlQqsViu8Xq8E7RgISaVS2N7exu7uLhYWFoRLLhAIYHt7WwKC5Ep66KGHsL6+jmw2i2vXriGTySAcDuPHf/zHMT8/j2azie3tbWQyGdy8eRNnzpzBaDTCzs4Otra2kEqlJCBJp/Ta2hre+973yj4rFoui32nTnDt3Tio0lkolbG1tIZfLSbXRpaUlPP7444jFYnImXblyRQK0kUhkjDuUuozBG3Kl0mFOvctzXDtN5ubm0O/3RV/y/GQgku/h79BJvre3h0gkAr/fL9VNWbWSZ5KWI22Pct3Ig0QnsbbHtUNM859xf3Ev8IwnX1YoFEIkEhkLTu3t7eG5556T4AoLwBwcHIgtYzKZ4PF40Gq1cHh4iMcffxwPPfSQVO7UAelGo4Hr168L/5bT6US9Xhc+TZ5XXIdqtSqyGI1GUalUcPbsWdHN/DsWi2FmZgbBYBCtVkvsON4t6GTmGDin4XAYABCNRqW6Is9fXeHP4/GMBbDNZvN975SaZEpN2tutTTil7kFjNgSdGyztrQ8bHfGk8a5JHwFI1owmIuWFiwcDD1P9PeBOiWlmMZCw1e/3SwaFjgLysNeRZTqGGI3hwaKJJAGMVeMoFotj0SdetnTGV7vdhtPplAOj0WjA7/fLO/g7wJ3y6Tr6xv9PT09LVJhkwTRISVzJg94YebLb7WKoABAyXxqGvV5PDj+Ol+vC6BcdGB6PR+aUTgad1QVA5o5rw8+4dnQ88pLBsfNCp+WEhz3JwpnFQqOFxomRFJZOQF19xul0wuv1yjrTScoMMY6jXq8jGAzK2g0GR5Uj+VwaSLx06ywQnSnBuaH8M9MmHA7Lu7RM6UwiOhgY/eLFkJF1p9OJdDotF0KdzcDvcx2YkcEMEmPWhH4/L7Z6PuhEoqOU/eZ6cH05J3Ru8MKqM650phT3Np3FzAbjBb7Vaonc0jDkvnC73eIc0NF7zgP7RHnicyh7nFv+MZIDc36YMcHMFZ2JRV3CdaYxDUAIYRnJ5p5j9Tm+j9UWmSlEI56ZHHwm5YHOQC0TjLYCdwij+Q7uKUbOuUf5bO5brhX3hZZbr9cr5M+UUVbwCQQCkiWho/js13HRcX7Otea/uZfL5TJ6vR4qlcpY1heDBVxXr9eLeDwO4Cjzi/uKziWuM+eCcsw1Z5aMlk82XtKWl5dhsVhQKpXEAUK9xX5rx7Ym8abcUidrhxove3o99DnKrCQS99KhqMmzefZqMnDOPbNlGDXXZN9cE84NHSfMyGHkn/uU32dGIWWT/dd7gg46ZsRyvzMbhHPHd+ozjtk/PB+pT/U5z35Q33Cd+X+bzYZqtSrZV7QheMbwfdpxy7HMz8/D4XBIcYZWqyWOeZ4jOnvM7XZLlin32Gh0VEwgEAiM6R86YwKBgDjkeLYEAgFx1PD5lB9mgGjd53A4MBgMJLOV68p5oc5g35gdQX3Oisac21wuB7fbLXJEPa0zpajfmE1pNptRLBaxsLAgjk3gyAHD7D5einne8LnUI8xqpHOahOiBQECqvbEKrs4AYmY5ZYK2CB07zIxnEInnO/WC1WrF9PS0rAWrQDocDszNzYmzjoU8arUagsGgOGZ08Qqt3/x+P6anp2U9eI5S93CP8dxj9Ug6jOhYjUajIhvAnexXnSWmSa65l9j4e9pO5h9+Rgcy+8F5Yd+NGe7cPwx+MvNGF+igjcD/6/Oe7+Rc8ZzVf2v9xc8oh9RFWhew8X5AlILWWa1WSxy83Dfcy/o85RkwHA4xPT0ttoXuK9/DTEeOlfuM+o9ywXtCvV6XAEu9XsfS0hJMJhPy+bzsU4fDIQUruLd1thsrjrtcrrHsNwY3GYzn+mtbVd+NKBsm01HG7f3Im8RzcX19/U1zSl27du2+nJtJe2u3+9op9du//dv4nd/5nbHP1tbWcP36dQBHhuev/Mqv4E/+5E/Q7Xbxvve9D5/+9Kclkv+9tgnR+aRN2qRN2qRN2qRN2qRN2qRN2tuj3Y+OF95JT5069aadUtevX78v52bS3trN/N2/8vZuZ86cQTqdlj9f/epX5We/9Eu/hM997nP40z/9U3zpS19CKpXChz/84R9hbydt0iZt0iZt0iZt0iZt0iZt0iZt0t5cY5bbm/kzaZP2o2j3PaeU1WoVgkbdqtUq/uiP/gif+cxn8PTTTwMA/viP/xjr6+t4/vnn8eijj37f7zpz5owQerpcLlQqFUlZdjgciEQikqZNAs5OpwOfzydp+OQhajQaGI1GkjJNMmFC0XQaLrmnmCYbDofRbrfh9XoxPT2NkydPIpFIYHNzEx6PBzs7O3C5XIjFYpIyHQ6HBQvvcrnGyBo1KWuz2US320U2m0WhUEAmk0GtVpPvdbtdOJ1O4ZZJp9MCiWJqMuGNhFcRguZwOCTVnmn1TqcTDocD8XgcJ0+eRK/XQ61Wk++srKzA4XCgVCoJnNDj8QjpIeEeTqcT29vbkhKez+exs7MDj8cjpKckOiUcCbgD/wkGgwKPikajOHHiBLrdrpAsakgd8exM52YaseanIL8NAIEJEd5CSBTT5nUqNnAUxajVaiI7fB7lutfrCTcVU52bzaakppOA1+fzod1u4+rVqygUCgAg8BRCAJxOp7z3xIkTQvRMvozZ2Vl5L4l5ORevvvoqAAhPkk6JB47giNvb2xgMBvD5fAAgcDVyVVQqFUnxtlgsmJmZweHhIR555BFYrVZkMhnYbDak02mEw2Eh2Cd8R/+fc7u3t4disSi8HIQRHR4eIp1OIxAIjMH8+G4N0yR/FJ8XDoeF4yWZTGJ1dVV40YA7xMl8biAQQDQahcvlQq1WEyiZ3+8XvqudnR288sor6Ha7AoXRpK6JRAKnT59Gu93GxYsX4fV6BQJHSCPXknCtYrEoMA8NYTSSo1Pw7aiDAACS+ElEQVRXsf83btzAxsYG+v2+kPsTfkrdoOFoADA9PQ2r1YqNjQ0kEgmBopHnY3d3F7FYDG63e4yIGoBAKwiVIkSDa06yXO4ZwgIImyARL3URn0O+H+oawi017EXDEWw2G2KxGObn5zE7O4tQKIR6vY5UKgWr1SrE5oSRkE/P4/GIntacRJqA1gjro75pt9tIpVLCL0O55b8JlWVxgkceeQStVgterxenT58WPqJmsylyR14p6kNyFFYqFdm35DdyOBwiH7FYDO973/tgt9tx9epVgXYRBqwLW3CMg8EA9XodhUIBe3t7UniDUJhUKiXyTK4fkoefOHECy8vLQgBNfdxsNhEOh2UfktRew0sI+SLkj7qq0WgIZxfJnMnNoqFTzWYTFy5cgNPpxN7e3hjvC6F4o9EIPp8PTqdTCnhoXjPuH8ou161cLiOTyYwReVcqFYF9Uv90u12BhPH9fC7lkVB4wuEIQwGO7J2DgwOsr6+LfOjznPw51FXk9CqXy/B4PLh48SKi0SgSiQT8fj92d3cRjUbRbDaRy+XGOM5MJhN8Pp9AbQgh5DqQG4cy0Wg0kEwmMT09jcuXL4v+JUR8ampK7CISkmvC8Xw+L7qJVAPaHqL9RD3Gz6hzCTsrFosoFApyXttsNoEWN5tNFAoFgbgT2uRwOIS76cyZM4hGozg8PMTW1hYeeughDAYDKRpA+F6tVsPy8rLoa11EgNQGhBaR4J4Qpnq9jtXVVcRiMezs7IzB8KhnqdttNhtOnDiBUqkkhOWFQkHmNpFIIJ1OCyyKZNYXL17E/Pw8crkcUqkUTCYT4vE4/l97bx4maVWejd+1de370t3V6/Ts+8DADCMBo0EIIRg/0QQ1fqDEbCBBor+giUAMhJCYqFHUxM9PJHHLogY3oqIC+qGswzIMs8/09Fpd+750Vf3+mNzPnHqnetiG6Znx3NdVV3dXV73vWZ7znOc857z3vW7dOnl8b3JyUnhBOU+m02nh7yPPGnDk8dqBgQGsXbtWOAn37NkjQjDVahWhUEgefQsGg5ifn8czzzwj/UXxlHg8LrGZOpdxbGUyGRQKBRQKhY7H6fjYKP0C+5Btz8fpCoUCent7hdOTMSJjMtoQ51vGafwueYlKpRIymQxisZg8zgpA5mI+FshHBnkvPgYNHBUL4Vgm/5HdbkcikUCj0UAkEhHuUvpwxs8Oh0Pm8Hw+j0gkInMLKRgeeugh2O129Pf3y+O9fGSTj1TTb/f09ODcc8/F6OgoZmdnUa/X0Wg0EIvF0Gq14Ha7kUql8NxzzyGXy4nvUh9LZT/RD3AM8FHqbdu2wWazYf/+/cLxx++x/8rlsjwKTf5D9fHkYrGIwcFBjI+PY3h4GF6vV/wn+RrZvq1Wq0PIaWpqCqFQCLt374aGhsapgzM+KbVnzx7E43E4HA5s27YNd9xxB4aHh/H444+j0Wjgoosuks+uWrUKw8PDePjhh19WUop8KAA6eKBUslTyY6jkpFysAEfJCwlyB3DxwklVfV7d+Mw7f6dj7u/vx/DwsHBVZDIZeL1eCQLn5+fR39/fQVLOCZrPzHNi4AKHE3Qul5PAiIGk3W4Xwkh1Mc9FCTmCeA3+zoWCyplFThcSSDMwp3rayMiIEFaTMDcQCCAUCglHAxe4mUxGyK/JscBnzJkwUQMZ4Ohz/iRFtVqtCAaDGBoaQqVSkUUqA1ez2Yx8Pt8RKHDhryanuBhmXWkvDGrL5bKQyasJLfax3W4XYktyStB+6vU6+vv7RZmk2Wwim80KFwMTIcFgEMViEfv37xeboZ3RPtX7er1euFwu6f9YLIbh4WEAQCqVkkQheR9IjB0KhSTQUPlcfD6fJLOCwSCAo8p5XGAwAOPCkHY1MDDQsRAhSTwXTBaLpYP0n6TGTPSVSiVJlHERy3qpwaSaPFBtlm3NxDATC1z89vX1SVmBI4pFDKgajQbC4bAE3uRlczgcCIVCyGazcLvdoj5DP6ByltFmGeQvWbJEEqdMxHCxryobkQyfBOUsE5MltH3yjTC456JaJYxVx4/Kv8LfOQbIV0PQ1lWeDTVhSztknWm3HDd8T+VfI4kwxxwTeKoqmjpO1PuovGLq/1hGLqDi8Tii0Siy2awsuMmfQn4Ln88nPH7sCzUxpfKNqElA+nFuQKjJPtotf+ecksvlYDKZRKErEAhgxYoV6OvrkwVbNptFMpkUJTnaOAUI1OQb+WxIXMy6Dw8Pw+l0YnZ2Fi6XCz6fD263G8FgUOYKJkPp79PptJDKktuJbcyNAwCSMCI3SDQaxejoKHp6ejAzMyMJKC4iORfl83lZkKmcTFRaYwKSCQ6LxYJAIACz2Sx8gKw3VR6tVitGRkYkoUSeGlWcot0+QqzrcrngdDoRDAaF7FglHvb5fCJ8Qf4rJhFqtRqcTqdsZqh+m5tYTCCpY4L2qo5VlfeG4OJQnVuZ1OD8wQUgr8W/A4EAent7MTIygmAwiEajgXg8LvZDtVuWhcl4bprRfkg+TY488pbF43EsWbIEMzMz8Pv9MJvNIsAyOjqKcrmMQqEgsQCTsLQdCluQu41JVG6+OBwOKRvfo68jZx95u5gw43tMrnFDSj01QD/hdDrR19eHeDyOWq2GbDaLJUuWoNlsCgcgCfCdTifGxsZQrVZRKBQ6hB3Yz+Tw4QYlx5fFYsHg4CAGBgYk1qHIB/0g+ZhsNhvGxsaEH8lkMgn3X6vVgs/nQyqVEp/CukUiEZm/OdfEYjERdCCvHjcFyIcGoINvjb+TVJ8qvR6PRxJ1TBzRVzmdTvT29qLRaODgwYMAIGMqFAphZGQEfr8fMzMzsmHF9mMckslkJCFOZTkmZcgVyCQPk1JMvrCuTNKYTCbxZbQfAMckW5vNI8qN5Lhi/BKNRmGxWKSs5EjjRjLje/pW8iXR3zPBzYQVk93cQBgYGJAYjjEtN2UYZ9hsNiSTSQwODkq8woTy008/DYfDIZs5TKIz+aPaPz+3bNmyDhGboaEh4TtzOp2YmJiQ8ce4iPUDID6ebc71C/2G3W7H1NSU8DiynX0+n5SPcZvKp0tfoPLI0ker6yPVb6oJQfpW41rrTMTLPfWkT0ppLBbOaE6p733veygWi1i5ciWmp6fxl3/5l5icnMSzzz6Lb33rW3jXu94lRIzEli1b8LrXvQ533nnngtfljjWRz+ePkU+ls6RTUEkQjcSL6ikF9TQMcDRJZUxAqQSO/BwXrVy4MeDiTillzimRre4ys2zGEz3GhRPLwV1gBlacLHhfdXdXNTFOTMaTGeqCXyVMZXl4+oOBBT/DxA6DO05QajuzbKw3F6zqpKbuPLEMBP+nBhYMABn48XNGokq1X/k7/zYuNoCjC2H2NctmBOurJnn4frt9lMSWdmIsk1p2KrCwL9Q+UstIUnO2qSqbrPYJ76GeZuhm4wzOaH+0c5WIkgso/s1AjCfESPyqJsQI1X5ZZy4G1ECR5VYXhCqZNL+v2iXQKVRA27FYLJIkNSYSWTfWlwGcSmDOe7NtuIPP9qF98GQV7ZAKaMaxqyY7mGzkOFbrZrQxVXwAgCya1MS4ugPMYFNtH9oG5dCN5LNqn6nfU8eHasNsfwbC6phhkp7vMchWfSX9Ehdbqt9Rg1mWhXbOIJ4LbAbEHAOEeo9uJ6K6+QD1u/xJO2RiVPVJal/SbkiKzU0IdS5QX2wr/lRPEHDsqW1JP8LTYExo8WWcL9T+58kKthP9GPtdJd5mebjoV09GqOXiooLXN7ahOj7U+UQlOFdPc6p+jr/z9A5J843jn+NeXQypfW30DWo70++wfCqxPMcq+5UJV9Wndpsn6e/U6zDBp4peqLbHOZmbJZzPuahmotpqtcrYpU0afaqxnmpd1LmX7cvkJW1JjRmYSDAm2Agjibn6XXWME6pvUv0WYxd1HuJn+H/1OvwMYzietGu32yJlT1tWY7pmsykxoepvjXUz3pd2SoVDjiE1cW70UWriSD3hy0QB50k10eb1ejtOpwNHfLYquKMqx6l2a7RjthG/T7vjKRWWRZ3fOKcxTlD9CpMStEvVP/J9+jU15uJp2m6+lb+r86f6WTVGUT+v2jW/q96Xm85qTEefYEwKqGNZtQOW3xj3cr7m/Kluiqn2S/tQywIc3TjL5XLSP/Rdqr2qc4DJZJLToKrwD22e9lkqleTzxrHPNlBjDf40mY5sSDI2UH2EmjxS7YYbBGo9uSHJeID3M/o941rKZDJJzEYF7jONN4mcUsuXL3/ZnFJ79uw5I9tG49TGGZ2UMiKbzWJkZAT/8A//AKfT+bKTUrd2IVDX0NDQ0NDQ0NDQ0NDQOPVxJiZemJRatmzZy05K7d2794xsG41TG2c80bkKPt6wd+9e9PX1oV6vI5vNdnxmdna2KweVig9+8IMiJZrL5XD48OFXsdQaGhoaGhoaGhoaGhoaGi8M9WTkS32dThgdHcXHP/7xxS6GxgnAmf9QrYJisYh9+/bhne98JzZv3gybzYb7778fV1xxBYAjZL7j4+PYtm3bca/DRzmM2Lp1K7xeL1KplHB+zM/PyzFhHqtVOVAqlQoCgYDwA/T29soRV5J4kgOIz7HzOiT9JrcJj5MXCgU5qn7eeedh69atGBoakseDeIRXPa6sch+phNT8Px9ZKRaLyGazOHToEPbu3SuE28DRY/B8BINkt+T64FHkZDKJvr4+eQZ+enoakUgE0WgUiUQC1WoVw8PDwhPgcDgwMDCATZs2AYDwJbjdbmk79eg366G209zcHCYmJoTTZO/evXjyySexbNkyTE9Pw+PxwOl0CmcAyaX5eI7P54PX60W73UZ/fz/OOeccDA0NCQ8AYXxkEDj2ET4eLVbb2PjYEB/5UB9HUa/PY+PdjmCr1zUeh+Zn+DjG+Pg4nnrqKYyPjwt3TU9PD5LJpByPJin6pk2bEI1GceDAAQDAhg0bsG7dOkQiEXlcgY90ptNpbN++HSbTEa6GUCiEWCzWcUSbdSkWi8Kflc1mhYeCj+dVKhWUy2W0220MDw+jWq3iwgsvRCgUkkc61X5XH0XlUe9arYZqtYqpqSk89NBD8mhKu91GKpUSYnySaJPMn5wK1WpV+MPS6TQ2bNgAh8OBTCaDp59+Gv39/XA6nfB6vVi6dCnWrFkjBO5msxmFQkH4RkjqTOLm7du345JLLsHc3JxwUiQSCSSTSezcuROt1hGCan6X/RuLxXDOOecIUTh5X6LRaIdwAonFe3p6RHgAgDz+5/F4xP5V/iMefc9ms3jqqaewZ88e4U5JJBKwWCwdj43w8+SliMViCIVCwj3Bccvr83sqHxwJYmm75M8gUXcwGMTc3Bz6+vqEMyufzyMcDmP//v1CIE9eNvIyWSwW+P1+aQs+SpDP59Hf349MJoNAIIBW6whPnsfjkTHidruxcuVKbNq0CcFgUIQRyPvhcrmE14S2txCxueonuo1n+thdu3aJDdKvk9ya46xQKMDpdGLLli3yqMW6deswMDDQ8ZgNv1etVoVbh/6Qvi6dTmN6ehputxt+vx+1Wg2HDx/GsmXLcMUVV2B4eFgeI2HdVC4ylcOj0Wggm81iYmICzz//PFqtlpD2ZjIZIS4PBoPIZrNidyaTCcuWLcNZZ52FcDjc4d/IS0R+Qr5Pe6MABzmcVJ4hlUCcj9aSv4SPG7XbbXnUHzjCbQego3/56Jna10Y/rvKrkUMqn89jYmICMzMzKBaLMpcmEgkkEgnhZCE/0NzcHCKRiNzfZDIhmUwKnwwJ3OmT+BgpfaTdbkckEhEeMvoFchUVi8WO9mEc0tPTg3Xr1gmXEf06APHH6iPgHH+Mb2jLtNunn34aK1euxPz8PDKZDIAji4dVq1bJ4zjsm3a7LeTxVqsVvb29HY/3MXZR51CVp9H4aBofIeJjRvTbs7OzmJ6extzcnPQj+cmAo6TT5AHjo1putxsejwfhcBgXXHABhoaGJL5ZuXIlZmZmRNxAFTkhgbXxMULaturX1cc7a7UaIpGIiBY0Gg3pM5W/jbZXLBbxxBNPCGdZqVTCzMyMcF7lcjlMT0/D4XCIoMPWrVsRi8UwMTGB6elpOJ1OjIyMYMOGDTIeOIfwXrwmfTr5hviYWG9vL8477zx4PB64XC5MTk7KPE6b56NoFF+xWq3CeeXxeIQ/1Gq14rnnnpMxWi6XMTIyArvdjh07dsBkMsHv9yOTySCdTgsnFR+dZ1+oMTMpLWhDjOPJlcX+pp+tVqsSN5F/1WQyYWJiQoRMKFxCziefzycxbjqdlj4PBALw+/3it1SeOd6DHKJut1vak36Bc65K7k/SdcZYuVwO4XAYU1NTCAQCcLlciEaj2Lt3L1wuF7xeL7LZLEwmEwqFAsbHxzE3N9fx+KbFYsEFF1yAcDiMZDKJZrOJQ4cOob+/X/yd1WrFnj17kMlkZH7iY4fqXD47OytrHAqtBAIBbN26FYFAAAcPHsTs7CzMZrMIzLhcLqmbw+EQgSVy2jYaDaTTaQwMDMDr9QrRvMlkEu7OXC6HUqkEr9cLv9+PZrMpjwyHQiGk02k5DXQm4+UmmE5EUqpYLOKmm27CN7/5TaRSKSxZsgTXX389/vAP/1A+U61W8ad/+qf46le/ilqthksuuQSf/vSn0dvb+4ruPTo6ikOHDgE4si7t7e3FpZdeio9+9KPCX6txauKMTkq9//3vx+WXX46RkRFMTU3hlltugcViwdve9jb4/X5cc801uPHGGxEKheDz+fDe974X27Zte1kk58DRQJYKaNlsVoIJJoMYZHGRVqlUAEAIickloT4f3mg0kMvlkMlkhNDPZDLJSS8qtnARR7UUTvxMBqlcFCrUQI8Tt3EhZXwGnpNpsViUhSMXCwy+isUi8vk8LBYLSqWSPJ/OxUFPTw8ymYy0BYmtWS9yTKgKYgA6iGCNHBTGMhuTagzCGaRms1mk0+kOPoZ0Oi2Bcjd+Ar/f38HF0q0tu/3drZ3V9ja2MzkJ+N2FoAbiDM7V/y30efKXkFy2VCpJUiqTyUhAqqoXeb1e4YAgsa2xfOpikYsH1S74GXVBzqCVCSgqr6ik7wBkzJBTQuXIMfKAdEsWsh5q8ERlsPn5eSEZr1arSKfT6OnpETVEAEIGTQVILmgYFJOji7ZEkmcumNXEH7l1VKU/2jg/zwQzkxVqUsrhcAiJLLni2u2jJPW0B5VLR+UPASCEwipXkdFuudAkhwQJtJkoULmDms2mqGlxAZXL5aT89F8qyTaVeQB0tFmrdZSYmwskk8kkikysMxWA6H97enokUUHfoSoVqcS32WwWLpdLAvVWq4VMJiO2xYUI+4gJoYV4YtTx3I1byjgu6aMY0PMzbFf2KRebLA+VVjl2uFhRr6P6ceM44IKSyZxCoSBqdxwbJPQ1+jqW2VhXNTHDvlQXdVTWpP+1Wq1yfdosP2/0U8ZkA/0+xzRtSeV7JMeImqxi2TmeyUHDuZNlZ3nY5wvNm0Y+LdUHqeOH7c17MFnEpJzZfEQgw2azSdKT9zebzchkMrJAoxAD512TySR+mkkpdQzkcjlpO6vVKos9EqvT31I8g0kQI7eT6h9ULity3aj+nGqGtFeWlb5H7U+Vo04l4lZ/Hg/dxpbxbzXpy/mEcRl9CwBJYJEsn/1PH8mktnpN/q5uDqnznFoOtd6su7qZw3ZnuzH+ITGz8fqsP5MmTFaqypvc9KEfph9nPzMR12q1OsarWjeCvp7+iD+ZaPJ6vR3zCe2X9eP1OQbIX1Yul4XfjYTVHKftdlu4tdhejC24oaGOBWPyVN0kpE/g36o/YR+pfaPyvrEfTCaT3I9zK+vGz7FtGUeq8aXa7/RdvAeTvyovIH0R537G0eRG4qaLKkLCDQj2ixozcwOJ/Uc1XQAyJlhW/mTilL6e/ly1G8495BEDIEJIjK+oCFqpVEQIg+I2TJiz3kzgMyHFuIOb8Yy3stmsxAwkv89kMigWi+JPOIdzTmZ8q/Hq4cYbb8SPfvQj/Ou//itGR0fx/e9/H3/8x3+MeDyON77xjQCA973vffjOd76Df//3f4ff78d1112HN7/5zfjZz372iu//kY98BO95z3vQbDaxe/du/P7v/z6uv/56/Mu//MsrvrbGq4czmlPqyiuvxIMPPohUKoVoNIpf+ZVfwe23346lS5cCOJql/cpXvtKRpX2hx/eM4PO7nBC7HYE0JhXUnT01iaIGtcb/GYMtvg8cDRKN9+VOVLdg2YjjJT7U+6nBpHEhqy5Y1EWEWlb1MypBotomalDB+qnqRsbvdCu7MVFiXNCoxJHG+xu/rwa+LItxwWes54ttU/WzL3Y4Gj/3cu5pXBSoNmYk92QApiY2mQxR247XVYNZNVg0tq3xO8bFn3FxQrtQd81VLFR3dZHQbeGjLiC7EZSqyQOWg+1ktEcGWMZ6drN/NflsLIfahsbysAxGwQC1jbq1iTEQU8uhftZYbpUsWx3X3ZLWrEe3NlLva/QbxrKqUP9vTECqNqvWxWg7C/2P/a3+z/i7eirBeD1jm3Vr9xcDtUxGYvJui3S1bLyXKk6w0DgyLoz5vtEPtlotWSQabeqF6qf6FvU99WX03bQZdSOgm40s1GbqPbrNky80T7Tb7Q7xA/V/3fr4pc6XxnHA94y2pr7XbXyp11Y/p35G9bUL+dxu1+528q3b/buNFWOdmQhXv68uao3X7ja2Xggv5C/U8qjzi7HdjZ9d6D7q3M/PqokOY5mOF7Opv3cb38eb37pd0xiPsa5qwlAdc91OUNPPGcvCe6rtZ5zPeC91bjb6r24bZ+r/1TkUOEq8Tajv8/PGsf1SxuqLtR8jusVH6ryuxhG8hnqiT/3uQtdlfbvZSDfbVecx1Zcb/1ZjgG4xPACx8eNt+nVLkKpl6tY3vI56Etv4eaNv6TZ38fPdvmMsg7Gd1XIBZzan1NjYWNe5+4XQarWwf//+V9Q269atw+/8zu/gwx/+sLy3efNmXHrppbjtttuQy+UQjUbx5S9/GW95y1sAAM8//zxWr16Nhx9+eMHDIYlEAtdccw1++MMfoq+vD7fddhv+/M//HDfccANuuOEGAEdOSql/A8Btt92Gr3zlK9ixY8fLqo/GycEZfVLqq1/96nH/73A4cNddd+Guu+46IfdTFxPd/rfQ38ZA9cV+T8VCWX+eCjjVYJzMjH8b66PuGJ1IGHfljWXs9vurVZZTBQsFzUY7WsjWX02wv15Nm34xY7jbeFMXPi+1fC+nPmqiaLGwkD86ni80fu+FFgDdvreQn1xoUXm8/xkXTt1+54mFUxEnciwY24cnGk4m1JN8vwx4sUmK4323W78d7z4LXftE+9VTMfZ4OVD9zulWp4U2BruNs1datzM9NvplwYmOK4yx04nw8ep8/lLm/BfyqWcSjhcPvdD3Xile85rX4N5778W73/1uxONx/OQnP8Hu3bvxsY99DADw+OOPo9Fo4KKLLpLvrFq1CsPDw8dNSl199dWYmprCj3/8Y9hsNlx//fVIJBLHLcvk5CS+9a1vYevWra+4XhqvLn6piM41NDQ0NDQ0NDQ0NDQ0NM5UqKfLXuoLOHLiSn0Z1eqPh09+8pNYs2YNBgcH0dPTg1//9V/HXXfdhQsvvBAAMDMzg56eHgQCgY7v9fb2YmZmpus1d+/eje9973v43Oc+h/POOw+bN2/G5z//+a4bZ3/2Z38mXKmDg4MwmUz4h3/4hxddfo3FwRl9Uupk48ILL4TH40G1WhWuHvJLud1uORrf09ODfD4Pp9MpXDTpdBqxWAyxWAw//elPcc4556BYLCIYDArBaaFQkOPiJtOR59pnZ2fhdrsRDoflNAsdRyqVwsUXX4zNmzdj2bJl8Pl8wvOy0ONn3ZyT+nx9qVRCKpXCvn378PTTT6NQKMjjHXzu3Ov1wuv1CrkiibNdLhcymQwqlQpCoZA8C08ehEKhAK/Xi76+PtjtdlgsFnl2/8ILLxQCXJvNJiSWPT09x+wG8Pg361ev1zE7O4u9e/fCZDLhueeewwMPPIBwOIx6vY5kMolQKCRcBvv27UMoFBLSdra3z+dDs9nE+vXrsWbNGqxduxbBYHDBxxxeaBdHPV5t5GUx9okK9Qi98REcAMf0q3qEWe3PUqmE559/Hs8++6xwT2QyGZRKJezZswdut1uIxOfm5nDZZZehv79fnu1fv349zjrrLMTjcTgcDrkHSYXJ1WW32xEIBODxeI55rI28M+l0Gvv378fc3FwHxxUfT8pms6hWqwiHw8jlcrj00ksxNjYGv98v9mfkQuM9VE6myclJPPPMMygUCti3bx98Ph9SqRQ8Ho/wQpDIk7xRAOS9XC6HRCKBdevWCQdIrVaD3W7HM888g8HBQWzcuBGrV6/G4OAgIpGIPEJLQmCVAJvH2ev1On784x9j06ZNcLlcGB8fx4EDB/D888/DYrFgdnYWU1NTqNfrCAaDcLvdiMViWLt2LdxuN0ZHR2UM5XI5efTK7/cLATvbyWazwel0Cq+b8RFf2gm5Kebm5vDzn/8c6XQaxWIRBw8elGtls1lpc5V3wu12Y3BwEH6/H3v27EGpVMLc3BwGBgaEeySbzQrpbrPZhM1mk8egySE3Pz8Pt9uNSqWCdvsot4jL5cLBgwfl8/39/dLXDocDqVQKxWJRuHOKxSK8Xi8ikYjwhBUKBRFh8Hq9IpowMzODSCQifGHRaBSrVq3Cueeei8HBQRG6oP/howjHe5xXHavqI7MqZw35sebn55FMJjE/P48nnnhCiFvJo0JOjGQyibGxMVx88cVot49wIp111lno6+sT3kH6C96TPGiHDx/GE088IaIc6XQa1WpV1GfJE2OxWHDVVVdh9erVXceZai/8vdlsIpfLYdeuXchms5iZmYHX60W1WhUy+kOHDsFqtcLhcIiARDqdxvLly3HhhRdidHRU+BXb7fYxjyCo8xPbUuX1IS+PSsDPx1tULkKVE4vE/+S2UUnrjY+1LVQe9iV9Q7FYRCqVwszMjJBE8zRKKpVCoVAQInDyzDUaDWQyGcTjcSE656NwKvcM23xubg79/f3I5/OIxWKYmZnB6OgoKpUKpqenEQgEhNeHvoz2kc1mkc/nYbVaEQqFsGLFCsTjcSxduhT9/f2IRCKw2WziN9R+V3/ysaD5+XkUi0VMT0/j0KFDQvQ+OTmJcDiMTZs2Ye3atXC5XPIdvkie3dvbK/O8Ecd7pE+1Af5kH5DkfHZ2FolEAgcOHMDAwID49HQ6LUInyWQShUIBgUBAxGWCwSA8Hg9WrFiBLVu2YPny5RJ7kGdK9QPqY2aqcINa1m7cQuQcK5VKAIBIJCJt3o2jjjaXz+exa9cuPPPMM+LTZmZmhIQ7lUqJny0Wi2i321i/fj0CgQDm5uaQSCRQLBaxZMkSvPa1r8Xg4KCIxfCe5XIZDz30EFwuF+6//354vV7xV+yrgYEBnHXWWYhEIhgeHgZw9LEyckGlUikkEgmk02m0Wi243W7h8SoWiwgEAli7di1isRiy2SxSqZQsOj0eDwYGBoQkXW0TPhZ2vDjKGAPRZhk3l0ollMtl4Rv1+/0IhUJwuVzSv06nUwjBWT/Vz5NHqtlsCu8RbYGcYVwfkMuNsUC9Xpf1QbPZRDwel886nU7hlgMgnEuNRgMWiwVerxehUAi7d++G1WqFx+NBqVTC8PAwms0menp6hM/VYrFg3759SKVSMq4ZP7hcLmzcuBF9fX3CW2i324Vj8/Dhw2i325iYmEAikRBydd6vXq8LvyzjQFKmPPHEExgcHMRv/MZvIBKJYPfu3Th48CCazSb6+/ulXVXOMdaTcxS5EPv7+yU+cLlcIiTTbreFk4t8i+Tjq1arwp1XLpfPeOX0V3pSamhoqOP9W265BbfeemvHe1/60pfwB3/wB/L39773PVxwwQX45Cc/iZ///Oe49957MTIyggcffBDXXnst4vF4x+mol4KdO3fCarVi8+bN8t6qVauOSWwBwAc+8AFcffXVaLfbOHz4MD70oQ/hsssuw4MPPihjV+PUg05KnUCQaJQE0JxkVQJaJqUYjNLhcjJwu92ygKbqhqogA0Cuw0RVq3WEgJMTLQkXubCnAyZvDcldjQGmcXFhXEyRNJiEtaVSCcVisSMpxUWAyWQS0kKSELdaLRQKBSF6VpNSrAtwRHGIkwkXYsViEaVSSQICIzG0kZvKmJRiX5A0WSV7ZWKNpJCFQkF+52KA12NQx3YgwSLbTP250HssJ38aFzvdOGHU66kLMSNXiTEho/IzGPuTpOIqkSTbmYpNvA/tkX1Om+JLrScJNEkOTeU3le9GTUqp5OYkzuc9uGAkQbLdbpf/UTGKZKrdElNsK7VMrINqD8BRcnEmaYrFoiSluChjGxUKhY6kFBM4ahtSSYbXoy2pgTS5Hrh4IuG3Wk7VZhuNhhAzu1wuKXu5XBYy51KpJEkpBmcMEk0mkygNqb5AXeyojyCyb9hefHFRy8QOE0kc/xzrbEf1xf5ifVkOBsdcAKlk9irhrUpQz+CCqoUcs+wHEuyynRwOh5Csq0kpLvr4WafTKYs3h8PRYfPGxaRRBczIKaMmkY2LZnVBStJakkRzcUpyapLJkxBWHZOcd1QybTUppRIqG8cB78NxVywWxUezfTiWjYtiIycNkz7qPEGCey4mWB/6WI4DtT4kPlYT7by+aqNqu/LF90g2rNq+6jt5LY5HEjurY6fbwpf2btyMUBe4tDu1rfnifVhf2iIJzFX7ZRnVpBT7muB1qMaotiHbnkkplpuJkkKhIH3R09NzTB9UKpUOsurjJaXY9+q8otafym/0ccakFP0H53ljUsoYq3QbZ8Zkj7EPVN9cLBbFP3HxzZiM/6OPoM9V5x51DqZfNs7hRiJ4o09Q/QjnH7YFfapqd8Y5jtfg2GK5WWcmLLihyfiGc4zNZjumXdhvxqQU70Gbow9XE3LGuACAcIgx8a6qqTFuU+2Vir9qvzEpxc0Pxo7q2FT/NsZBC220qhsD6vzJl81mg8PhkLlHTb4ak1LsbzUpZUzWc05TfSTtg/aqCvtwHuA8yb/ZZrwm6+9wOMTHms1maVf6JDU2YB1VoRTG7Mbxz/IyTuH9OVaoYkh/Rp9L/8LvcKxxw4jXmJ+fl42zbkkpjkv2PUV3VJ/N8rZarY6kFGMvxkisw8l+LP10xOHDhzs4pbqpzr/xjW/seCxuYGAAlUoFH/rQh/CNb3wDl112GYAjat3bt2/HRz/6UVx00UXo6+sTUSs1qcSNsVeKSCSCZcuWAQCWL1+Oj3/849i2bRt+/OMfv+ykmMarjzOa6PxkgaRyGhoaGhoaGhoaGhoaGqc2zmSi8+Hh4ZdNdD4+Pv6y24b3/+53v4tLL71U3v+DP/gDHDhwAN///veF6PwrX/kKrrjiCgDArl27sGrVqgU5pfj/Rx55BOeee27Hex/72MeOS3T+6KOPYsuWLbj33ntx+eWXv+Q6aZwc6JNSGhoaGhoaGhoaGhoaGhpnAF7p43svFz6fD6997WvxgQ98AE6nEyMjI3jggQdwzz33CK+T3+/HNddcgxtvvBGhUAg+nw/vfe97sW3btgVJzleuXIlf//Vfxx/8wR/gM5/5DKxWK2644QY4nc5jPlsoFDAzMyOP7/1//9//h2g0ite85jWvqG4ary50UuqXBMfjYnghGI/Kq++fTLySOqg4EeU+UWU5FfBy2+PVaoMXU55Xas8nAyeifV6orCfLDvWB2pPb1kaJ6+Ph1R4Lr7TeL9V2ziTfSpxu4+fVmmsXs29PVB+cyvZ5MmOb43FlvlwsFGueLHSr06nc368UKu3Dy/3uy8FLmd80Xj4WKykFAF/96lfxwQ9+EO94xzuQTqcxMjKC22+/HX/4h38on/nYxz4Gs9mMK664ArVaDZdccgk+/elPH/e6X/jCF/B7v/d7eO1rX4ve3l7cdttt+PCHP3zM526++WbcfPPNAIBoNIpzzz0X3//+9xEOh19x3TRePejH904AeFTxggsugMPhQKFQQKVSgc/ng9V6JO+ncmOQCJpk38lkEuVyGUuXLoXf78fk5CTi8Tj27t2L5cuXw+VyoVQqIZ1OAzjKqcDn/MlrEIlEhFB83759iMfj2LRpE0KhEDZt2gSfzyekgHw+nuCz6Xzmn8/3FwoFuWZvb69wKuXzeczOzuLQoUPyjDv5DwKBAOx2Ox5++GHU63Vs3LhRnkd3u90YHx/H2NiYPHvO+5K7ge3E59xDoRDWr1+PjRs3YnBwEB6PRzigyNVAjgb1xevwWfxEIoFEIoGnnnoKBw8elGfV6/U6nE6nPLevtovT6RTeKpLYb968GSMjIxgbG0MoFOrgdVK/ayQ1VsvI9la5DxwOhxAos25GYvBufFXq70beDbaBWiaVp+fQoUN4/vnnMTs7K4Sv9XpduIb4HH673cbWrVuF7L1er2P58uVYvXo1YrGYkGfyXuTyIJ+Rw+EQ7gIV7XZbyJcPHDiA8fFxlEol1Go15HI5GUe5XE54wLLZLC677DKMjY11EPGq11TbWiUWnZubw9NPP41sNiuCAHv27EFvby+cTqdwmpDXbOfOnajVagiHwzCbzUJ873a7ARzhVbDb7dixYwdWrFiBubk5nHXWWRgeHsbo6ChGR0cRDAal/gsRJefzefzoRz/CunXrEI1GkUql8NRTT+H5559HKpUS4vW5uTnY7Xa4XC6Ew2GsW7cO4XAYGzZsgNfrFXtX+WPUcdVutzs4ONT2UgmayfFGAvzDhw/j4MGDSCQSwsWWzWaF9FvldyP/RjQaRSgUwtNPPw2r1YpMJoNIJAK32412u439+/cjFosJD1mz2YTH45HrkyuvXq8LnxJ5PqxWK5LJJHp7e4X3iTwfHo8H6XRaSE8LhQJ8Ph/sdjuCwaDwT/Bac3Nz8Pl8iMVi2LlzJyKRCILBoBDsW61WrF27Fueccw6WLVuGSCTSwa1g5Hgjfwd5osh1Qb/ZaDSE04e+12azyfd37NiB1atXw+l04ktf+hJcLhccDgcymQzMZjN8Ph9arRZSqRSi0Sje8pa3yDjq7+9HrVaDw+GAy+USbh72N9tjYmICu3fvxuHDh4UHjBwn7H8KE7z1rW/FsmXLhKuFdaa9kIuFxOI2mw3BYBATExOYmprqkKRPJpMIBoNIJBIoFAoIBoNS9larhcHBQaxfvx5LliyBy+Xq4KBbiMB4If9Ivh71/W5zhMrrp/qnFyKt5/XJKcR+VwnrSfDP8UTuomaziUwmI2PMZDoqpFGr1dDT0yPcKLlcDm63W0h96Qva7TbcbjeKxSI8Ho8QJhcKBXg8HhlP5MXLZDKYm5uDx+NBIBAQrqFKpQKXy4VQKAS/349oNCpxx8qVKzuu3Y1TSgX97OzsLA4cOIDDhw8L95/VasWSJUuwevVqqYfqC+v1upBmk6fSOMcZOYHUsUfuG7Yh27lUKiGZTGJychIHDhyA3++XNkskEsjn87Db7di9ezdisZj4S9aPY9NisWD16tXYtm0bli9fDp/PJ2VXbVxtG5Wvr5tdqXVSy0+uHLa3cQ5XbZC+5vDhw9i+fbvw/KTTaSF17u3tRT6fBwD5uXr1alitVkxOToqN9PT04OKLL8batWvh8Xg6fMf8/DwOHz6MTCaDPXv2IJlMIp1O4/Dhw2i1WnA6nYjH49i6dStGRkYwPDwsnJtq3KMKcpBDa3p6GolEAtVqFYFAACtWrMDo6CiAIz7j0KFDCAQCmJ+fx7Jly0QIx8ifuRC5ueqbVS7ISqWCXC6HYrGIZDIpXJrk6fN4PCJARBseHBwUbkKVY6+bf1HnXbUs7G+VA4/to/JWqXE631cFG1QfXK1WEY/H5XPAER84NTUlvpyciRaLBQcPHsTMzAxcLhf8fr+QtJvNZgwMDGBsbEx8MHn/Go0Gstkspqam8NRTT2FmZgbpdFpOumSzWWQyGZn3/H4/zGYzPB4PMpkMstksenp68Fu/9VuIRqMyB7Hf2+0jXJnz8/PIZrNwOBwiaOLz+VCv1zE9PY1KpYLBwUHk83nh/QIgQhJq3MP5ReU/dLvdyOVy2Llz5xn9+N7AwMDLfnxvcnLyjGwbjVMb+qTUCQSDCZV0daHPGQMLdZJSyRdVQm+StaoToDE4UwNl9ftc2HFBR4JllSyTn+GLQSKDHiYr+LtaRtaLP9U6LlQuTh58HziaROpGBMqAn6o3rAPv2W3hoQa8DEZ4byNhsZpY4k+1H41lYXupCRA1GWRMShkDJJUUvlswZVwE8H3j54wwLtC6EZ1zolbbRLVf2ppadtbbSM7MQMa4wGDbsA78XQXbQS2LusAz2r8aiBnvobaJMQjkZ2m36nhS7dPYDt3GmGpvJHk12pI6ZtjPRkJ2FSRLZxn5t5rsUcvZ7T61Wk0SD6rSlkr0THswlkFNpqjjX62DaidqGUhMqpJJ8578jkpqrPoB48JS9Q3G942Ez0afYvSj3fyi8Tv0Pwv5bt5XTTKRyJZ1NSY/6SNJXqzaN32omvxQyVrZdyQoNpab9TOSl3PBwPKZTCZZ9HNBzfKqfcs+YtuqcxDbgLbFBVY3e6GdUNRDtRk1AaTek7+rfaSOayN5fDciedXfGX2iOm67+Qb1+2piSr3mQgkEtY26JSLpZ9Qx1G388KX6WnUBzf5Tx476nnEsctyp/1/IzxkX6+pL9SkUNTC+uoFJB9XGaF+qH1aFH3g9Nabo5tPVPjBu9vB3zk/qtbrZu9oPqg+nr6Wf5E91DmQSgIk6Yyyi2hXraJzHjfaqJpjUmEq1zW6fN44bdVyxXuq8rSY+1LHH+5nNZqmfKkTApJSxX43+Qi0LyfjV+IPXoI3Ql/J6qt1x00j1oYwBF/IHCyWl1Hoa52Zj/MF+UGMelkWN21S/qsbS7B+OB2M8Yuw/43u8Dsug1s0Y86qxEMupfk79P/uWcYLa5uq44UYxxYboF433MyZR1ZdxzjLaSDefSHs0XkudV9Uxb1xDsE1Un6+ub9QYhNc902Gc617K9zQ0FgP6pNQJgCY619DQ0NDQ0NDQ0NDQOD1wJp4G4po0Ho+/7JNSU1NTZ2TbaJza0CelNDQ0NDQ0NDQ0NDQ0NDTOAOiTUhqnG3RS6gSCx4l5VFQ90gu8MIkjjwPz6Dr/5v8WugbfMz5OwmPX6v941NV4LLjbY2KqQ1MfaTMeRe7G52H8nProEI+EG7+rlpP1VY+v83GUbrxJxvur9zVeV310gddSH2dUr6W2iXpcnGXq9jid2lYvBupnu7Vlt3sYH80ztmO3axiPuatHm41Hngn1sUojd4LKU6O2tfFzLxbqI0PGehrtg/VWeZF4DfWzKtRj7/ybx7lZR6O9d3vURy0PxygfyWLZWD6jzR4P9Bsc+8bj/Wo9eR9e/3h8Oyq62ZLa1uqRduP4Nz6C2s3vqLtyrDe547o9vmn0K+q91fp083/8ndfu5hfUsqnXUsvTbewbxwv5Q4BOmzM+krHQ47YcZ2wj1Y6NZVSvoz5O1K1/rFarPF7V7fFjo72obcDPq75WbUd+l9dXx+ZCtqb6WZVLxtj2Cz1eoT5a2m3uWeie3X5/OVjIFvnT2NcLXUP92e13/s25sJvNdPv7eDaqfka1K/Xzqv10G4vqd9W55aW2q/ooEgDhx2k2j/CnqX3bbe47XhsY23ehshmvo44P/r/bPY93XbPZLDxLC/WZ8fsLle/FtKk6NrvZoeoDOY746K96H36W9qbGMqpfAnAM96PRr6pzk7HO6lykctB1g9rm6qO2Kr+bWnZ+7oWuq5an23tsU2PbqnOM6m/UMWEcFype6hh5KbHRS7mOsRy0e/5PrafaBuq1GFt0qxO/p8bRxvt3Gw/qvMa4RZ3fjOVQYwrV5/I7jLuOdxLIWA5eS30k90xGN1/6Yr+nobEY0EmpE4gVK1bAYrFgYmICZrMZoVBI+I9KpRLq9bqQ1pbLZSHx5UR38OBBrF69GpOTkxgYGEAqlcLY2BharSOktiSOJhEonT+JRJ1OJ2q1GtLpNHK5HOLxOFasWCEkjbVaDZFIBAcPHkQ+n5cEkdPpxMDAANxutzj9QqGAUqmESqUCi8Ui17bZbEJ+PTs7i2q1KiTXlUpFSHbdbjcKhQKKxSISiQTi8TgajQYikQgOHz6MWCyGdDotSgiFQgFerxdOpxPZbBZzc3Not9vw+/1wuVwYHR3FmjVrMDAwgEAgIIsxcgqpz7g3Gg0UCgXU63W43W4Eg0EhNpycnMRjjz2GYrEoBJAAMD4+jlgsBr/fL/Wv1+vwer1CmNjf3w+n04lwOCxHY2dnZ2VSZGBls9lQr9eFZNG4UASOOH3aBsmBSXAOoIMDgCTAnFDz+TxyuRwsFgv8fj/cbrcQcBeLRVit1o5+stls0i/kF3G5XELcvmfPHuzatUv4CHp6eoRk/vDhw/D5fIhGoxgYGIDf70ej0UC5XMbg4CCWLl2KXC6HbDYLt9uNcDiMWCwGn88nXDdc6JJMVV3gkqem1WoJEW2j0UBPTw+y2azYfDabhc/nQzAYRKlUQl9fH6xWK0ZGRoR7gUTmPLrMss7Pz8PlckkgtG/fPjSbTXi9XqRSKUxMTAA4otBBLiar1YpKpYJsNis8QO12G4FAAGazWep76NAhrF69Gnv27MHSpUulbAMDA7DZbFi3bh0GBwfhdDq7LvL4s16vY+/evQiFQgiFQshms3j22Wdx+PBhpFIpIe0mYXalUkF/fz/OP/98BINBrF69GoFA4BgBA/V3thP7hLwO1WpVSLiz2awQ2zcaDaRSKbhcLlgsFszMzKDRaCCfz2P//v3I5/MIBALwer0iGkACZQDo6+tDKBTC/fffj1gshrm5OUSjUTidTgkIe3p60Gw20dPTI2TZ7fZRrq5AICBHyZ1OJ3K5HOx2u/weDAaFCN/hcKBWq8Hr9YovcDqdaDQaKJVK4qcOHDiA4eFhjI+PY2BgANlsFhaLBeFwGCaTCel0Gvl8HtFoVEigN2/ejOXLl8Pj8WB4eBgWiwW1Wk2I4GdmZpDNZtHf3y+8fSo3idpm4XAYHo9H/CGJ4nO5HLxeL8bHxzE4OIhgMIhHHnlE+D9KpRJmZmaE/6ZSqWD9+vV44xvfiJ6eHrET+g36F/pD+i0AQvxM8tlGowG/348DBw4gGAwCgBCYX3nllfB4POIj6N9pF/Rh7fYRAln2V19fH0qlkpDRttttTE9PY2hoCOVyGfPzR4i72TYejwfxeByDg4MIhUKyuOYCgsTtnC9Vwn4SYxsX3PS1Kozvq/9X+Z2MHDTVahWlUgm5XA6zs7Pw+XxwuVxotVrSJxRKMJlMqFQqkqzO5/PChVMqlZDNZmEymbB3717E43ERTmBb0r44p5TLZQBAMBgUkn/OT5xrON94vV709fXB6XSiUCjAbDYLofrMzIwQd1OAgTbj9XrhdrvR39+PaDSKeDyOSqWCWCwm/aq2nzERqiag0uk0du/eLfaxa9cubN68GQcOHMD555+PYrEoNkRxD5fLJT6uVCqhWq0KZwz5ctrtNqrVqpDxWywWEQ1QF8N2ux2FQgHZbFb8azabFVvs6elBJpMRn0lRDZLUq/OFyqvT29uLLVu2YHh4GF6vV/yWyi1G/iGz+YgwhlHgwmi7ahLWmKQhKTltkuTc+XxeYhSLxYK+vj7U63U8//zzePjhh7FkyRKxSQrlFItF7Nq1C0NDQwiFQohGo7DZbBgfH0c2m0UsFoPJZMK6deuwZs0aaVez2Sz9UywWMT09jd27d2PHjh3CWUWRm3g8jmXLliEUCmHlypUdfaNu1rD/GGMmEgns3LkT9XodwWAQS5Yske+zT1qtFiYmJmSuU9vMmGQ38r1xLFerVeTz+Y4x6HQ6kUwmkUwm0Wq1xO8xHg0EAohEIhJ/hMNh2Gw2eamcYca5faHkKsupJl/Y7wslBLolto18cE6nU0Q4aDOzs7MoFototVoiAmKxWDA9PY3Z2VlYrVZ4PB4ZeyaTCb29vdiwYQN8Pl9HcrDVOiISMjU1hSeffBKpVAqTk5Piv6rVKjwej/h3s9ks4+nw4cMIh8Pwer04//zz0dfXh4cffljsi991Op0dAhGRSERiu3g8jgceeAA+nw9LlizBwYMHxfYZs9ntdlitVhkrtIVqtYrh4WGZC5PJJKamprq29ZkCnZTSON2gk1InEKFQCDabTZyx3++XYJxqXpw0mCxQCSap8tVsNhEOh2GxWBAKhSSzT6USJh0IXouqVVarFS6XC7FYTBZtTOB4PB74/X6ZSJmU8vl8smgjManVahWVE16bAR0TJSRCZfnr9bqog1EBqlgsIhqNotlsIhgMotFoyMRO9SWXywW32w2HwyFJkXa7LeUKhUKSfCHBKNuACwkuBPnTZrNJObiQdbvdCIVCcDqdaDabMplOTk4iGo2KApLL5RK1QO4ahUIhOBwO+P1+CVg8Hk/HIof35emQhaAmpRqNhiwqWKeenh75yeSOMdlgNh9R4nI6nbJY4w4lgyUqxlAljUkptgUX/tFoVBKkan8ePnxYkgvBYFASPWwHl8slCzguGrnIMJ7K67aYUU+dUAWGSSmTyQS73Y52uy2Bk9/vR09PjyhbUqmFSTsG6V6v95jkBG2eiQ4ugriICIVC0j5MyrEvWV6/3y/lYnI5EomgWCyKshwX/1arVdTPup3y40/Wz+l0dvQXVbK4EONYd7vdEqx5vV5R0+QO90I7tt0EDhhocnwwGURbbjabHUEeTzxw0ej3+6Xe8/Pz4lva7ba0Q19fHyKRiCR+2KdMsLdaLfT09KBSqUhyg4t5n8/XUUbWlb7F5/OJYp/dbketVoPb7e4oO8cxlaDK5TJisRjq9Tqi0SgcDgdMJhNCoRBMJpP4jXA4jEqlIrbOgJm23Wq1xI8wqHe73dIXKmF7u91GMBgUn0e7pW9mMpRJdK/XC4/Hg1AoJCTDTqdTxgxtgr7MZrNJ4pNjmHMP5xj6QpPJJGOJcwvLUiqVhEOiXq+jUqmI3/X7/ZLs4ljnwpD+iglHtpd6+gKAqGny1Az7hDYUCATg8XjE/3LhzrZWF8rqAr/bicEXk5Tq9j/j9dXFNNuTdqf2CX0/P8uEK8vFpBSVOAFIMoD9wvmASllcYDMpzfHF5EckEpHPc9x6PB4Eg0GxC9oDF6u0CzUuMJvNHf1Mv8Ly2u128YHqvKZuuqh+htehfTARy3K1222Zt+jz1PlcJWfnmFRPKtJPcY4zJqVYR/o72pIxmcDEks1mk001p9PZoSarJo5CoVBHIo3xEOc5dQHPxbaalDImVI0nA9XTIfw+cPSEOUG/wr6nTVE9MRQKib9n/zkcDuRyOUSjUfj9ftncYywWCoUkOcn6sb3VeILxIu/BTR/OrRwX3RI26jjq6emRudvlciEQCKDRaEiyl36UbdxqteB2u6VNVRtUT75wzPA9th3vrQqH0L65qcl4wOVyib9UVavtdvsxNmSso9HPGH2QcaNSTVSpJ0TV73Q7faTaCtuWbaaCcV+73ZY51Gw2y6akqibMsaS2s2qfjK85JzKJ7nQ6AUDmX84DjJUYWwQCAbjdbvHxwWBQ4mvGpFQ2ZCKJPgOAzKG9vb0Ih8OoVqsSu1qtVhFCYrzCDbb5+XmJ0ZhoNJlMOil1nO9paCwGNNH5CYAmOtfQ0NDQ0NDQ0NDQ0Dg9cCaSeXNNGo1Gj7s5vhBarRbm5ubOyLbROLXx0q1VQ0NDQ0NDQ0NDQ0NDQ0NDQ0PjFUI/vqehoaGhoaGhoaGhoaGhcQZAP76ncbpBJ6VOIHjM0WQyCbmiykcBdCpRqM/Yk4yaz86TP4D8ScViUXhWjEpbKr8Cv0eeIrvdLiSlfH6cz6erZNO8FstFZ8bn7+fn56Vs5PxRuYJIKqmqtpAgmrwG/Hyj0RDuDeNz82wjVYmFz987nU4hliUvEflVjEp6RvJVfrZSqQj5Ndub9arVasLDQKhcAeQRUMnmyUXAeqv3U5VijESWLDfvoZL6qjwvvLfKr0ICXHKI2O12aWfWRS2Dei3ys5AngpwA5AtSeZ5IDKryDZBHhgTAtE9+lxwm5AVRlVLIB2PsP9XmVKJPjoNarSa8QCSRJ+8Y683rqSpevIbKP0bwfZJhsg1VfgR1DKt8CiRtJ+eGyWQSAmjaHfmu2E/sQ445lQeCvAtGDhxytJFviG3DsaHyQ5CTphvJs3EscwyrAYvKZ6PaCfmuyGnVbreF1JZlYdvTj/Ga5Icj2bLKpUGCVvIpkaeJHCNGbhb+znYkr4xqb6y/Sq6vlpNcVvxsrVYTLh5VKUxVT2X/kQOD5VPJrSkQoNq0Oo75fwBC3kwiZSPPWrValTFFXiFV5Ugl8AUgHHlsl3w+L36Bcw85DtVxwb7kGOW8orad6pedTqcIFajzlOonVV+t8ua0Wi2USiXhUlSJeFU7N45TtR4sG7+n2oTKwaJyNPLFsa6WVbV51pn2yHmgGzeVSqhMH6HyWXFsquXg/dV5l/9XBTFUDj72PduE/cvxa+wjthuvpfomclKp/oD2Sw5Jig1w3KocTqoYhWo7KpePylWnzjtqmRgH1Gq1jvFGThnyyKiKXKpSKv8ulUodfEWMi3h/jg9jmdSyso05XsvlsvB+kSeJ32fZaHfkb6INcO5QfYuRX0odS0auIf5f5YxSfYgaq6kxk9HPkeiZ36EN06+rMYkaW9B2VbtQ7UcdL5wLOP+rPE3sX857qo0wziDnGccDv0cie86Fqh+gjXJuMY551o2cp6yL0d+pbc57kt+sWCx22BI/w7ZR426r1Sr8myqHo9HH0haNfb8Q75RaPmMsYPxdheoHjXXmPEd+TJXDk3GV+j3+TV4vdZyqZWfMyHZQY3DVT6ptqbYtuUELhULHHK+OaQr1eDweVCoV4U0lSb46JtV5ReX24xpEFYChONP8/DxKpVLXNj1ToJNSGqcbdFLqBOLss8+WYCSTyaBQKAhxH3A06Gi3j6hccPI3m82IxWI4dOgQ4vE4arUaCoUCWq0WRkdH4XA48Oijj6JQKAhRoKq2k81mEQwG4fF4UCwWAQBzc3Pw+/0YGRnBhg0bUKlUcODAAVHToCITySk5WXDy52Iok8mg3W4jk8lgcHAQpVIJqVQKsVisI2grFAoygbCOs7OzyOVyaDQaGBkZkWAxnU4jEonA4XB0JBW4iKjX61J/qv5ZrVasWrUKa9asQalU6iBup0IdgzAqgaly6eVyGR6PB3v27JFnpQ8fPoz+/n4hPR4fH0c4HEapVDpmYW2z2RCNRhEOh1Gr1RCNRtHX1yeqW16vV5JC8/PzMmmT8JNBK99nOzGQSyQSMlHzvXQ6LeVPp9OSYJyamkKtVkMgEEC9XhdFkVqtht7eXiHIJXG03W5HOp2WxXW1WoXP50MsFkOj0cDk5CSmpqaQSqXQbrcl6E6lUti/fz/WrVuHVquF3t5erF69GjabDZlMBul0GgMDA3A6nchkMmi1WohEIrBarcjlcsjn80in0zCZTPD5fIjH40JA2dPTg1KpBL/fL4sMLjgY0FYqFZTLZRw8eBDJZBIbNmxALBbD5OQkBgcHhUSfC4larSZBBomnS6USnE4n+vr6OhYmLMPk5CR2796N4eFhUWRcsWKF2DxtjUSZJHedmJjA4OCgBFITExMYGRmR9vb7/VizZg3q9bqMOSqdmc1mSe5RwWxwcFASvVyUjY+PY2ZmBnNzcwAgCapSqYT5+XkMDQ1h1apVcDqdWLJkiSRN6Rvoc/jKZrNotY6o56TTaUluqoF2MpmE1WqF2+2WxaPf78e+ffskWHz22WfhcDjQarVEDY8iDLFYTJIoy5YtQywWwyOPPCKfJxF9vV5HOp1GX18fUqkU+vr64HA4kMlk0Gg0ZOHSarVkkcJFRyKRgNfrRT6fRyQSgc1mQ7FYFMJfBrMkT6Wa5uDgoNiY2WzGxMQEvF4vgsGgfJ/+g21YrVbh9XpxzjnnYNWqVaKiVi6XEQwGRaGSSV4mcZkAs9vtosZqsViwf/9+5HI5rF69ukMIg+Ph4MGDGBwcFCLZyclJZLNZSRBTsYp2vmHDBrzxjW8EAGQyGfzsZz+Dz+cT3+l0OpFOp4Xon8lLLghTqRTy+byQxlNhjsTWXCxQFdZkMmF8fBx9fX1CIgtAyKG58HC5XEKYXK1W8fTTT2N4eBj79u3D0NAQgKOkuocOHcL09DRcLhcikQiAIwugQCAgCwr6CZPpKGk3E26cV5vNpihL2Ww2SWIzYQx0kjYzWUFlXPozKo7S73MsUWWsUqnIGM3n80KE7HQ6ZfOI45x+iT612WyiWCwinU6j3W7LPM1keLlcFvufnJwUwn36Y/oBqmRxkRmJRNBqtRAKhVCv19Hf3y82Vy6XsW/fvo4kZL1el1gilUqhUCigt7cXFosFIyMjIlLQbh8hKaffYCKHySOn0ynjgcmbSqUiBPlc4NJ+ly5dikOHDskYY38EAgH09fWhUCgglUpJm3PRysVqLpfDjh07EAqFRC0wn89LTERfwIU47axarUpZq9WqCHOQmPn555+Hy+XC/v37EY1GkUwmhQA+FAqJn6ESMEUxms0mhoaGpN9LpZL4Up/P17EhZCQ25/zP6zDuMJlMkgRnHMa4jvEBkyrsE4oE7N69Wzbd/H6/CD0kk0mpu8vlQjablfmip6cHHo9HEk1+vx/9/f2y+UbSas5rBw4cQCaTQTKZhMvlAgCZT0ZHR7F69WqZO9TNm+npaTQaDWzcuBEejwcWi0UUdlOpFA4fPgyz2YyRkRFEo1HxPy6XS5Sa1Y1Oxquzs7Oo1WqYnZ0Vu6DfYCKDbc1XrVbDzMwMVq5ciWaziSeeeAIOhwPFYlGSakxeuN1usTW73Q6fz4epqSk4HA4h6mcyTfUZjDvpz1RSdI4j9qdxg1edv9kOTAKqCUp+h0kmboYRNpsNExMT2Lt3rwj5cFONyr6MnRlzVqtVnH/++Vi9erWMawCSfGdfTkxMiPo0lXyZgGRcxr4ol8sSgzcaDVxwwQUYHBzEo48+KpubFDax2+0oFot4/vnnceDAAZx99tnYvXs3li1bBqvVikQigT179qC3t1dET/bu3YuhoSFpc4oSzc7Oitoe63HgwAEsW7YMmUwGjz/+OM5k6KSUxukGnZQ6gaD8sNlsRqlUkp0fnj5Qd484EdCR8xQPF2WUMk0mkxJYc6IE0LGzTZlbylbz+pRV3bdvH+r1OhKJhCSims2mBLbcJQIgiwruPjEYKhaLmJ2dRbValWtwQcuyM+FCsA2azSZyuZzsmLC8XMiqO5oM4rjjR1l1s9ksctaqKhol39XTSrwuFwXqSZZEIoFcLifJj3K5jEwmI4E6A1rg6I4aF9K8Dhcn+Xwe2WwWpVJJkndceDD454ke9j0DP+7QARBJ6kKh0KFGxr8ByO8MHLizyMURT4BxF5PlZnKOi+58Po96vS5S9lyYsh4M9LhrbDabZWFgtVpx8OBBuR6/zyCCSQouhCqVCgqFgtgYg3yWiQsXJhAYLHJHvlarSYK2Vqthbm5OFo8AZMHL/mH92V68BsePurPPk4SpVEqC4mq1ilqtJsk5lllVmuRYYVKX452S4xxX9Xod+/fv71AmKhaLHQtrs9ksi2u2G20OAJLJJNLptMiC06Y4phKJhJz0y+fzHSpk6ukEjiPaPO2cu6L0J2qiWj19l06nkUgkOhJ66sIIgFyL92i1jhBlMolGf8JTO6wLy8E+LpVKHbvLDLa5u09fQ5vP5/OyU8qf7DP1FEilUkE6nRb/wz7jqS++ZzKZRGqeyTMAOHz4sJwS49hLJpOy4GObMynJBKPVapXErMlkQi6XQ7lcFplu9jmTF5lMRk7HpNNpsU8u8Dgm6KPm5ubwzDPPiI9OJBIoFouS6LLb7cjn8x2KpaqvLxQKKJfL8jneg36In7VYLFKPZDIp5WEfMXHI7zgcDknENBoNJBIJScJw4U2fOjc3h3w+3+HPOIa5uOT4ZAKVdq5uajDhw/lUVZNVVczUxRXti4nLSqWCVCqFTCbTcR9en23PMVoul1EoFKTPOf8Wi0WpI+/Pk1TValX6iMlFjmuObd4LOLoYVD/LEwp85fN5iS2Mp2DoQ4Gjp09ZXyY2uBHEeZY+kX6I4149ech5iptC6phRT47yxAX9M6Xe2U9MgicSCZkz2D9sTyZy1Pm6UChIEpqLWs4rjUZDfBNtkDGDGtvQ9zDRzwU051CWgf6VvoGJ4na7Lb6LfUb/RvVC9RSn8SSN2pbqJgGTHSwHfR79OvuZ96Na69TUlHyHMQPjLyYOmNRmUpCbirS7Uqkk8SdP2zNB5XK5xHcVCgVJyNCW1FPB9PdMBtD/2mw28Uflclnsk3602WwimUyKn2B8wcSZcV7LZrNoNBoSwzCppCozqvEcy5XJZCQ2Y5zNscm5jXNrNpsVH8ckGedexmjqhhD7mj6LPlRNTtLvqycQOUYZy7Keqh3x8+rJVNoDT6RzXrdarUgmk5iZmZHNB/ZPMplEoVCQObmnpwfFYhH1eh379u0Tf6SWm36Fc1M2m5Wy0e+020eUYTlP0rYZj87Pz+PAgQPI5/OYmprqOMlE1cVqtYpMJiPJxlKphEQiIWOP45YbRzwlrLa5zWaTzXLGCYxVstmsrG3OZOiklMbpBq2+dwKg1fc0NDQ0NDQ0NDQ0NDROD5yJCnNckwaDwa6PsL4QWq0WMpnMGdk2Gqc29EkpDQ0NDQ0NDQ0NDQ0NDY0zBPrcicbpBJ2U0tDQ0NDQ0NDQ0NDQ0NA4A/ByE1I6kaWxWNBJqROIoaEhOByODpUi8m2QS4g8E+RsaTabwr1BIkqS87ZaLSHwJHEgn0dXSU7J66OqWZGzym63Y3BwENlsFrlcToiuyQdhVBoBIHwV5IkggW25XBaOAqphqDwOLDvJkcnZUqvVhESX1/T7/cKlw7KrijXkWXA6ncIdYbFYEIlERHmDnAHkwSJhLQnOWS+HwwG73S5KawCkjer1OhwOhygTkqeA9QeOkp2zvYrFInp6euD3++W5drYnyTFJZE+iTyqDkA9A5Zgi2TGfq2f7A0c4AdiGFotFyFpJwM12JEeC1+sVvipVWYXP2qucByrXUT6fR7lcFp6DcrksJKHJZBKxWEzIVNk/JBEnZweV6tj+JJS1Wq3IZDIIBAIdpPbk6Orp6REeEHLe0B5IXEn+EfKTtNtt5PN54WaiLfI7Ks8J+4ecOvPz83C73SiVSkgmk3C73cJvQa4LchOxnCQCVQUBeH2OQXKYkODW6/WKb1DVKcnrROJUk8mEWCwmHDKVSkU+TyJYVYWKdXS5XEIYSy4k+gXyNNCWSQLMPiHfHTlAyLWh8nzEYjEhvieRrcpLViqV4Ha7O1SsVK4gl8sFl8uFw4cPC7EyfQ/tkPXJ5/NCukvelHK53KF0xb4kuW8+n0cgEAAAqSuh8kfQpq1WK0qlEorFIux2u5Bfc1yoSmgkAm82m3A6nYjH44hGo8Inl81mZczSHumTVN4SjmFyzbFvqXBGvhbgCD8R+7y/v7+Dq4MEv+TloM+LRCIYGhqCzWZDuVxGIpEQ0mzyNVG1lP6G44B1pq9SFShpEyTiDQQCwkXDOUTlGrFYLMIb4nK5RKmT85GqmAQc5VfJZrMyhsgHRfVL1rHZbCKfz2NgYADJZFJ8aT6fRzwel36nbyFvDcUSOG44P/F/rVYLqVQK/f39Um/OBfwOxzvtj36btkJfSn/g8XhE4ETl5SOXFK/Je6g8PLRL2pLKHUOCZMYInB+oKmkymUTZLhgMypxKWyGnIwUDWG5y59BftNttBAIBeL1eOBwOFAoFUV5kHdrttvh98kiR15F1of8m2T5jGRL6z87OiuIf53m/3y+2ovoX1sNqtQqpeTabRV9fH7LZrBDiJxIJIaZmnTj30d7JKWe32zEzMyO0CyS8p9/g/bg4oz+mT5ufnxcxBtoOeXnIgUnfRh+gxjUcN7QtklTb7XZks1n5nZxZ9HG0b/oc+iqv1wuTyYRMJiPjRuWwIq+f6qtpV/S55IF0u91Ccl+pVKRsvB7vr/KJqnNkMBhEvV4XX0+ydY5B8rtxnNAGaZ+cZ1lHxqD1eh1+v194MPmIUTAYlFiCcSp9EG2JMTI5/1wuFyqVihB/T05Owm63o1KpyJzKeYFtz/mi3W5j3759CAQC8Hg8HSIejH9VQQXVDjk2qESoqi6rNlGpVISTjRxtFNNRidtpY+32EVVD8o+phOjRaFT4nyhEQz4yrjNU/laPxwO/3w+Xy4VCoSDlY7xFvsLZ2VmZZzKZjNghfT39I/kgx8fHReQiGo3KnEJuUtZX5UtTuSRV3kdVEIYxNoVQuDZh/6scewBEgKhYLCKTyeBMhk5KaZxu0EmpE4hVq1YhFAoJgR6Jj7kYI7EtFTw4YQYCAVGeymQyiEQiQrbZ19cHp9OJ6elppFKpDmUPKilxcq1UKvD7/UJC6XQ6EQgEcMEFF2Dfvn3Yt28fBgYGJHDxeDyyEFEJKUnSyuRLMBhErVYT1atqtYpUKoVQKCQT/NzcHDKZjCikjI2NIZ/PI5FIIJ/PY2hoSBJjDocDS5YsgdlsxqFDhyRhxaBEDfKj0aio4tntdqxbt04SCT09PfB6vTIpTU9PS72p+jE/P49QKIRgMCiKMUx0FAoF5PN5+R/bgkEYiRMZpDMAmZqagsfjwdjYGMbHxyUI9vl8SKVSCAaDSKVScDqdos4UCARkImUwAkACqFarJcEQycHb7TbcbreoGNrtdoTDYWQyGUxNTcHn82FsbEwWpLt378bQ0BCi0agkjRggkajY6XQKYWc0GpV2O3jwIBKJhCzCE4kEIpGIENeuXLkS/f39WLp0qSR9ZmZmEI1G4XA4JCHIxJnX6xWiSqfTib1792JsbEwWxQxWstksfD4fksmkLEKY5GTwTIJLu92O3t5esZWDBw+Kglk4HJYFL4l/ab+U/6UiV6VSQV9fH2ZnZ/HMM8+gr68PPT09mJmZQTAYFHLqXC4n5XQ4HAiFQrKIKpVKQiTLMUgS8+HhYdhsNgwNDcnkzgCQi8VCoYC+vj5JYJ111lkilJBMJiWQ3rt3rxC8A0cl5pmQGBgYkEV6KpWSdmJygIk1JiYymYyQspvNZrjd7o5A2WazIZlMIpPJYOPGjQCAQCCAXbt2Cdnr+Pg4CoUCpqenEY/HJTFD38RgPBKJoK+vDz/5yU9QLBYxNjaGdDotC2neu9VqYXx8XBTbGOQnk0kEAgFZ1LL/SPB+8OBBLFu2TAJyVWSB/cRED6XKp6enMTU1hUAggGAwiHb7iHqp0+lELpfrIMmlTUciEZx33nnYuHEjyuUy5ubmsH//flmkcvPB5XJ1SN4zIeJyuaRPUqkUarUaQqEQnE4ngsGg+ASOv71792LLli2S6KlUKkK6T2JyKhatWbMGr3vd68RPPPnkkygWi6I29NRTTyESiYiaFUUiXC6X+KdUKgW73S5+Pp/PS8KKmwvLli3DzMyM9Dn9JUn7e3p6RKwhFovB6/UiEonA6/VKmanWxcW71WrFnj17xH6npqZkLAMQe6Qy6vnnn48dO3YIx8X4+Di2bdsm/c7FBxdWTDoxCUrVV/Zxs9nEjh07sGXLFiHODQaDIqSgbnpwIca+yuVyknBhsrNQKGBgYAATExPo6+uDzWYTlbNarYZ0Oi1151hnYt9sNmNqagp+v1/mZnUTi0pp2WxWyPDpV7gxEQ6HkU6nsXLlSgQCAVEvrdfrOHDggMwntHMu+JiwYMJ/6dKlGBwcRDgcxsTEBEKhEAqFAur1uqishsNhWfgx0URfT3/Yah1RY41EIqII6PV6MT09jSeffFI2q+bn5xGJRDA6OiqL1Hw+j9nZWfT398uGl8PhwOHDhxGLxbBv3z6ce+652Lt3L5YuXYpGo4Enn3wSoVAIvb298h0uqJlMajQayGQy8Pl8eOyxxzA2Nia2Njs7K3NIpVLpIIxmsiwajSIWi6FSqWBgYEDmR84FXq+3Q1mQC372Mf06E2WMCfL5PBwOB3w+Hw4cOCDqm6FQSMQBPB5Ph69WRWKGhoZgsViwa9cuiYdUdcPp6WmUy2WxYSb7bTabKJ7Nzc0hmUyiv78fo6OjaLfbQvrvcrmOScByfKRSKSFbD4fDWLZsGQqFAtLpNObn5xEIBFAul4Ugmwkvqh8zMU5FRM6zrKPdbkcgEECxWMSSJUtQqVTw3HPPodlsYs+ePVi2bBksFgtyuZwQ6cdiMXg8HrGncrksm4jBYFASNcPDwzCbzfjZz36GQCCAZDKJeDwuisUOh0PsR92QK5fLGBsbw9DQkCThisUiIpFIh2ofxz5jMCbmVLVGu93eQTrPuS8YDAphfTabxdDQkCSUabPc7Gi32+jv70ej0RAFUib6Nm7ciOeeew779u3DunXrJPFOwR9+n0Iu8XgcY2NjiEajmJiYkM1YqpJS2fHxxx9HNBqF2WzG7t27YTabMTg4KHMkYw5uUCaTSaxbtw7AEdXYZcuWYWpqStSkWV8mv3O5nGyksT+4PlDJ/wuFgswzbrcbyWQS4XAYPp9PNvPpB7gui0QimJyc1EmpE/w9DY1XCk10fgJAUrmxsTFRgwOOKscsdFKKDpiTkirZS/USLtKpiGI8KcUghcEGFz+qzCtPSmWzWdnlZgKIkyAXYmrCRD1txYmY9+HEy6CHMuzcKQoEAqjVahIUe71ekWm2Wq0ywS90Uoptw4UTg2jjSSnuKPMEU7eTUkzEUFKdCxdVJUhVgOOJH54mobISJ+dSqSQy1jzhwVMF3KWhSg935hjg8sVdcJ4O4qJHPaEFHNmhY8DP/mRQw2CNgSJPSvFUBG1IVRVjuzHQYrvl83lR3zveSalgMAgAElAxWFV3ptn+TMRYrVbZ0WYQrSpDsd0YTLM+VF1iQGuxWGTnHIDYDpMuqqpRrVaTXUguDtSdbAasc3NzcqqhVCpJEModYo43JtvUEzjcHQc6FbGYaPL5fB2nbtTTFjwpxT7v7e3tOCnFHUyelFJVeFhHJv940kTdsVZPStGO6GOYnODCSB1vrHu1WkUsFgMACQi7nZTiaQF195325nK54Ha7MT4+LlLj9D0cuwBEwYp2YzwpxfHBEz48OXe8k1JGX8b7UTVSPSnFscWEDe9Fm+ZJqVgsdsxJKbY10Hkiiiel2B/sd/YtkxlMwAGQ8ZfJZNDf39+hUsgdX/WklNVqRTgcliQoVf0ajYbYcSKRkAQUd8ONJ6Uo+83kLe2ac1Oz2UQwGJQFHucQLo44xnhSiv6WSYt6vd5xUkpVoKICFutvPClF21JPSqknLYwnpfhTTS6wPyuVivgr+mEuwjkmOU9wjNGOgKMJYdVmjAt1r9eLfD4v44I+hElKXpOJTPp/9aQU5xL1hAXHFudQQj0pxVO0wWBQ+pJzAJNgXCQbT0oxcaeelFJPKTNBQP/R7aQUbZLzKxO1jAk8Ho8ofPGkFOurnpRi/EL/Yjwp5XK55DShegJ3dnZWkgH8Dn2R8aQUNyHoPxjf0L8aT0oxRnI6nXJ9JoloOwudlKKfYEKD11RPqatxC5VY6aO4+Fb9pXpSCoCc+GHSXz19wzlePSnF/mcyyWI5qpjr8Xgk8cu5gMkA42kv9aQU50gmaZiYdDgcEvsy2QdAxgk3DzluGVdyzlM3WgKBAObn50Wdj/3PsUH/zIRQt5NS3KBQT0pNTEzIqTSPxyMbY+w3nmplf/OkFDdReMqITzkw4cexz7ajbXF8vNBJKY7ParUKn88n16LN8ppMWtLPcGy3223EYjFJLkajUTm9xRiJdsQTfx6PB4FAoOOklMlkErVFJgqNJ6UAwOv1Sh+oG1Tz8/M4dOiQnJSKxWKSaGSCjielOHdyTKlqzS/lpBT7m36AYPK8UCiIGveZRubNNSlPUL5UMCY7E9tG49SGTkqdAGj1PQ0NDQ0NDQ0NDQ0NjdMDZ2LiRSelNE5X6Mf3NDQ0NDQ0NDQ0NDQ0NDTOAOjH9zRON+iklIaGhoaGhoaGhoaGhobGGQCdlNI43aCTUhoaGhoaGhoaGhoaGhoaZwB0UkrjdINOSp1AbNu2DW63G+l0WgjCVeJyKkGYzWZR+SqVSkLUCRwhUCbBbz6fR29vL1wuF8rlskinkgSQRJgzMzMYGBjoIPGs1WrweDxwuVxYsWIF2u02SqUS8vk8ms0mUqkUrFarqCuRpJGSyyTXJCkr6zM9PQ2fz4dcLodIJAKfzydEnSSEBI6QMPKzVOXL5XJCGE4Swmw2C7fb3UHqSEJnku+S6NlsNiMWi6FWq4miC1W3SNRIcnESb1qtVng8HpG1Jmm4SjQ7OzuLaDQKAJiZmRFyc5I0khQ+EAgIkamqtELCSK/XC6vVCrfbjUOHDonKFutGksZGoyGS6Ww7kjq6XC7MzMzA6/UKOaNK+KmS+ZIklwqEKtmq1+sVUmASM8/Pz4tqkirdXi6XUS6XkcvlhMTe6XQKeSVVB9vtNlasWCFEnbQJkvATVPJqNBrS53a7Hbt370Y8Hpe2UMmlqWBEFSgqs1UqFeRyOVFVoSpQsViEzWaD0+kUZR22D1XXarUabDZbB2kwFSqpGJhOp4Wkm8TZ8/PzmJubQ09Pj5CRq8SlHEskZyXJqt1uF7vy+XyiNEZVPpKJU42RmJ+fx8aNGzE/Py9knlR1zGQyoo7VbDZRLBaFZNZmsyEYDApZLdXiqGpFwlgSg7O9SXTNwKNUKqFcLotiV6lUQqvVEnvv7e1FOp0WBapCoYBKpSKEoiRK5lggmarH40E4HEY+n0e1WsXk5CR8Pl8H+XWj0ZD7UhzA7XYLGS5JsDkGSHyazWZlbIZCoQ7pdQDiQ+hPLRYLgsEg8vk89u/fj97eXpRKJSxZsgTZbFbI6Cn3TvJskpWPjo5i1apVaLVayOVySKVSIgZAP0+/Eo1GMTMzAwBixxxr+Xwe2WxWbIuEu3a7HZlMRtpqZGQELpdLSI9J6stxRrLeYDAon6XCUb1eRz6fF4Lg6elpOJ1O+Hw+8REkt6V4A22Zds33SV4di8Wwf/9+OBwOOBwOIaYnGTSJgHndUCgkCqipVAoOhwPFYhFOpxO1Wg1utxv5fF6UPulLSPZPG+H92Q9ut1vsO5lMShnYZyRW5stsNovKKpUMI5GI+Bx+l36DKqqqVDpVH0kSTvXMUqkk80u1WhXJdlUMgX9z7AKQMcOxNjk5iVWrVnUQK5NImGInKgE8xw4FGGgPHN+9vb1CkJ1Op8XHqkp/Kok+RSsqlYpItXPsTk5Oyj1JFK4SRgeDQfG17AsSt9OOqKbo9/vh8/kwMzODXC4n4hxUMaTKH30klQGnp6dhNpsRCASEFLtarSISiYg4BQmt2b7z8/Myf4VCIbFx1oEqt9lsVuIJCqWQcJoCHqod0n+ZTCaEw2ERUti3bx9Wr14ttuF2uzuU0jiOHQ4Henp64PF4UK/XxfYdDgfS6bSIS5TLZVHAVVX0aNMkeeZcFw6H4fF4kEgkUKlUhHCfZaViI0n5aQckyOY8yjiCasEUtJmcnITL5YLf75d4x2azoVAoCFG6yWRCMBhEb2+vEFu73W40m00Z77lcDq1WC1NTU1ixYoWMQ5WQmrEX265cLovKL9VNM5kMnnvuOQwODgo5O2NHxtWHDh0CAIyNjYlCJAVw5ubmMDw8jP3792PVqlViCxSJoWgA5xT68EgkInbJ9jl06BCWL18uPoo/KcJC0RHaF9uLYiisO4n6VSU5igHQthnDqvMiY3CKUnDscKxQIILjkerTc3NzEkfQ7ufn5+H1ehGNRhEKhUTcgn6Mip6cPykwwriaNsa2ozCC3W5HsViUGLe3txcjIyOYm5tDIpGA3+/vUDamfXG+Zb/VajXs3r1blDo9Hk9HXMA2otoyyemTySTGx8exfPlyAEcUcROJBPbu3YszGToppXG6QSelTiACgQACgUBH0qFcLkvSgAslBlhc5IbDYUk2UL6UE1I4HIbf75dFBgMCq9UqSjCpVEoCNr7PZJff78fy5cvFuc/NzYkSmM1mQzQaFaUxn88nyniFQgEARPWC9cnn8yJjHg6HEYlERFXKZDJJ8mJ+fl6kyRuNhtTR4XBIucvlssjLUjmkVqvJBMjFAANVi8WCeDyOarWKaDQqZSmVSgCOKuZwQqSMdigUgsfjkQQHFwNsbwY9VECikhFV9zipxmIxUSLKZrOIx+MSzNfrdZEy9vv9kujp7++XvmTgRsU/BhOc6G02m0iZh0IhWfBxwaQqfbGtKMPMejDwDYfDEsTl83kJRvv7+2UR5ff7pU+pIlir1VAqleD1eiXg5iKl1WphbGxM1GB6enpECalQKIjii8vlQl9fnyySuehIJpMYGhrC/Py8yEkzUKzVakilUqjX6/D5fPD7/dIfFotFxtXQ0BBarRbS6TTsdrsE39FotENJMpfLSXKXixYqtlFJkAsFBjAmkwmxWEyUgxwOBwKBgCjAUSWT1+dihYkfqi62222RJKbyIAO++fl5RKNR9Pb2ysRfr9dx9tlni6w0F5t+vx+zs7OycKKCEG3Abrejv79fVI+y2WyHPbtcLthsNqknE5D8nQmEXC4n7cLgvNlsoq+vD06nEyMjI5JMoNINVXmYFGbSr91uS4IwFAohHo8jlUpJAtDn80nAzyQBE/RMRDOhxzFsVC/kQpGJNdV/sl4AJDjmYjkWi4laGFW9otGo+BvaHvuVSWuz2Yx4PI41a9ag2WyKTXPhQB9VrVZRKpXExqlkxsWHw+GQzQAmiXw+n1yHyc9CoYD+/n74/X7Mzc2JH6ACEnAk2eXz+dDX14fVq1fD5/OhVCphYmIClUpF7uNyuUQVjkl0Jpu4+KIKX7PZFLvm4pk+dcmSJbJh4fV6RZ5b9Y9ut1vGXzweRygUQqPRwOTkJDweD9LpNLxeLyqVCgKBAObm5mSM2Gw22XwBIGOp0WhIsorzZqVSQSgUkvszgcWFGJN9VNFKp9OYm5tDpVIRxT4mEqnQxYQWkx1Um2Pd/H4/7HY7yuWyyK4zuRgMBmWTgmpaHNf0D41GQxTwOGboMxkDFAoFsXePxyObUD6fT2yWC8p6vS6bLrQHKtvF43F4PB65PhMHZrNZNk5UtTIm4LigZWJqcHBQFnqMAdi+VDLs7+9HPp8XZV5uQACQ5MfAwADa7Tai0SjC4TAOHDiAubk5UcHyeDzwer2Ix+OS/GZbZjIZmftisZjMe6VSSVSFmQCisifnLrZlf3+/2DjrQLug0mw0GhXpevpfytFXq1U0m01JsDExFI/HJYmaTCYxMjIitkGlUW7S9fT0SDzjcDgQCoUkwcx51Gw2Y2hoCO12G/l8Ho1GA319ffJdfp91oV8sFAoYGBjomM8jkQiSyaSUlbGm1WqVDUsmu6kix4R4pVJBLBaTzRe2L22DCQgm0p1Op7R1b28vlixZIrbPTZ5AIIBkMom5uTk0m00UCgUMDQ3JOOR8QN9IWzKbzchmsxgeHobH4xHbm56exvT0NAYGBlAsFkXtmYn2bDaLubk5AEBfX5/EQaptDgwMIJVKYWRkRBLcTCx7vV6Uy2W5HnAkqTowMCCbbQBkvhweHpY+4ZzBPmUyKJvNdiiAUj2Vfq7dbsPtdiMUCiGTyYjanpogYwzLcc81AuOu+fl58V/c9Fm+fDkmJiYwPz8Ph8MhqtecTxl/sV3C4TCGhobQ398vqt2MkRgrLlmyRJJF3CRibEG1R8ZvLBv9jtfrxdDQENasWYPx8XGYzWZEo1FJJudyOYmROe64sVupVLB//37ZjAsGg5JkZhtWq1VZg6mbm7w3AEn8aWhonFrQ6nsnAFQ64GKM8reqVDplTtVTDpTX5QQDQIJDLpa5q8JdDyYpuDvA4FKVU1Xvy2AWgASgXGxxEaiexGHCiwtfnvBgfdRAnsES7wtAdom5q8HdRpvNJjtIDPq4M81yqtfhtbjTxEUZJaRZRpaf92R5WXbWkbuCrL8qI84AC4BMzjzVROUKBnTqdbggU5NGvB9PdzGwYtnUcqq7XWobs91U1Qx+Rx2u6okj9RosgyrtzglbLQ9365rNZsdn1IUUAKk3cGTxo9oZgy5jv3GXi7ufZrMZxWJR7JTlZJnVvmGdAIjd8wQcdzKZBOHYYPDPtuIik/fmfWgz/J6aLGbg1W63JcBkPxjtgWVVbU6VjOc9eF21bFyEq+/5fL6OevHUUKPR6LiXKiluMpkkYGY/0g6MEt7qZ9R6sI3VscTy8ho8HUg/wcU/7YRlo+/i7iQDXtpHpVIRv6cmW2krap/S3hYaA/RfLCdhVJpRr0sfVC6XYbfbO05G8frqaUR+n0lq+lEG+5Tnpi2xPmqQTxtQx4p6yoX3Y9KYbet0OmUOYJ240FN9KJM5qj2zD1Wfzc+qdWN7qdL1tC9Vept+lzv0arlYNt6L7cgEG8cSv8P6qn/XarWO+ZK2SntT/R5tVF2Yq+Xnd9k+HH+0Xy5yVJ/A79Emje2k2qQ6BtgGaplU/2z8XR2H/JsS7jxVxvZku9AmF5ov1PmJ45sJKJ7CVX0fr6GOQQAyRjmnc+xyMcxrqH1D38B60GZUO+BcwHHKpAj7Q53/VV9BPzw/Py9jie+p/cQ6sU3YdvQR/J5qy6q/53jjtYyxA/ub3+FcSH+injblqQ3atTrn01+xL2kz6sksJmBpG0yisSzq91X7pE1zjjSeLjSZTB1jheOPYJ049mnL7HejD1HjMbXf2dasQ7lcljHB8c65rFqtSpKVbazGQKodqXEwbY8ndpmsUOch+lkm/ZgcUsdXvV6XTWNuUKgJZdUXqWOSmx7q5mClUpG4SB33vJZaJranGqex/rVaTcaCOreqZVHnM16bfUW/Qv/F9uBGKq/FcvP0ldEHWq1WSQpyfKj9TR+jbkQZx44aX6v9z37l5jRPdquxtToHqRtDvF6xWJR5W107sQ7G9RH7m0+tsG9qtRqq1eoZqTDHNSmTkC8VHKNnYttonNrQSakTADoADQ0NDQ0NDQ0NDQ0NjVMbZ2LihWtSbhC+VDBJeia2jcapDf34noaGhoaGhoaGhoaGhobGGYCXe+ZEn1XRWCzopJSGhoaGhoaGhoaGhoaGxhkAnZTSON2gk1InEOeffz6CwaCQ05KgkM9fqxw/1WpVyBn5zD85CUjunMlkhPC2Xq8jnU4jn88LFwp5aDKZDFwulxB8mkwmpFIpBINB7NmzB29/+9vh8/lQLpeFTJpEhOQjASAEm1TL27FjB0ZHR4UU2u/3Y3JyEsFgEF6vFy6XS7hGqD6nquolk0nY7XZks1lR6SHxM0lwSfAdCoVgMpmELLjRaMDj8QifDfmOIpEI8vk81q9fLySnVAghabqqhkV+k/7+ftTrdSSTSeE34jULhQK8Xq8Qe5pMJszMzMDpdMLv98vz/ZFIRMi12W87d+7E6tWrhVS7Wq12kGVTdYSEoVTbav8PISufiSfPBkkuVdLlVColanzkj6ACYzgchs1mk7bl7/39/WJL6XRantsn4SSJwqmMREJLkniTDD2dTkt7rVu3DqOjo9In5Feg6hv5P2w2G/r7+9FqtaQuJAPevXs31q9fL6osVPdhfcgHQE4mqs2Q+JgkqI8//jhe+9rXChcYv0tVPnKPqZwLJJTnuKnX68jlcsJhMD8/L/ZEEmWSv1MVkNclOSnLRBshmTd5iMxms5BJU8DA4/EIrwT5X/r7+8UOzGYz9u3bJ1wYJL2dnp5GJpMRX2IymRCJRBAKhcRO2c/VahX79+/HyMgIMpkM7HY7nE4n0um0qC2RV4XtxD5VycTD4TCsVityuZxwU5RKJbkX+1/liXG73Wg0GnA4HBgYGBDlMwA4ePAgxsbGMD8/j3Q6DafTKX6rWCyi3W4LfxMVxOgvSMLbarVENYlKblNTUwCAWCwm6khs23K5jGAwiEgkIkqUHH8ktlUJ5hOJhJBkk59pcHAQZ511FqxWK5LJJPbu3YtQKCTcNnNzc5iamsLKlSuFBL3dbmNiYgJmsxl9fX1CfsyxSm4OlSCfAhEkOW42m3jssccwPDyMQqEg5NU+nw9erxehUAhjY2Mwm4+oVu3atUtEAg4fPox4PN7BS0I+lunpaSGq5vw0Pz8v6qx79+7FsmXLYDKZkEgksGLFChkXmUxGbJd8QbOzs7BarVi6dCmAI7we4XBYVGOpdsaxFo/HhSNnbm4OxWJRfDDnN/o7+qK5uTmEw2HMz8+LMAaJ7NWxT1VTCiywzVmObDYrvnLHjh0YGBgQEtxms4lIJCLjgZxK5D+Zm5sTVSpyCu7evRvLli0T/hyOIXLg5HK5Dj4qiodQmEDldaItU6WUogOq+qfNZpNxQAEPqp3SBr1er/DqUISkXC7L+KdCGa+bzWbRaDQwPDwsvmFoaEhEGhwOBw4cOCACHBMTE4hEIujt7RW+Fvo2csiUSiWkUimsW7cOgUAAs7OzWLNmDarVqtyP3EBUkVXJ3TnvJJNJ6QMAohZWqVTE73IOKRQKQrxN1VGv1ytxBQBRQ2b5GJsUCgXpKwq5kFuFKosejwc+n0/8k8pvRv7MQqEgNsu+zufzACA8XMFgUNpI5WujfbXbbSQSCcRiMZTLZVSrVYTDYYRCIbElzr/VahV9fX2i8MY4ijEdBWXI6cdyARBhFpazXq+jXC4Lofrs7CxisZjM46OjoygWi2g2m5iamoLT6RSBgna7jd7eXgwMDIiQTa1WE3/LeIvcfgAwNzcn/8tms/B4POIrGWeo4gcsUygUEhtKJpPS3nxciXahEq43m02J0ej/JycnxZdlMhnh4gqFQpienobJdIS8nQIdvI/KBUbRl0KhICqrFosFTz/9tCij8nEoCgWQT0vlqMrn88J5xGsVCoUOom9yf5IvjZxjBIUGyM9F4Ybp6WkRt1HVjlWBCJPpCDG51WrFyMiIzB3FYhEHDhxALBYT4nK/39+RuPjFL36BarWKZcuWdXD3UdCBvF0kenc6ndi0aZPEGY1GA+Pj4xLbcvw1Gg2ZkxqNBhKJhIg72Ww24fFl/JfL5cRPtlotIfrPZrMdXFZUIt+5c+dLX+idRtBJKY3TDTopdQLR19eHcDgshJBqUoqLbgY81WoVwWBQkhu1Wk2CcipbWa1W9PX1yec44TAoDwQCsiiiXK9KohsOh5HJZDA8PCySxwyu8/k8TCaTBB8AJMi12+2IRqNIJBLo7++XBBRV90KhEAKBgEi3cxHl8/lgt9tlAU+pYyY/1MU+1XWKxaL8nwtIJjl4PS54AYiq2NDQkChBFQoFKUMwGITD4ZCAiIuEwcFBITS3WCyy0Ocimkp4DICazSZcLhdCoZAQl/b29sJut8Pn84lKTzqdxtDQkJB4VyoV9Pf3i7KY3W6X8nm9Xkl6tNttCQYZsNTrdUSjUZE9p/wyE2EkwGRygPLzVFWjogsVwJhkZCJMVe9hv8RiMZhMR9SeXC6XkCwziUkCSpfLhXg8jpGREVG7YkBVLBYl4KJK0+DgoLRtvV6XZGIul8PQ0JAoGjEpxUBLJdkmGSXttlwuw+VyweFwYHx8XNR7GHxx7FA6W10EttttUV0k/xsTGiTp5Lji4pZkn7Q/2jsTMVzYkHSTCkmBQEASvmazWdqcCyQuuJhI4AKQ9aCPYMKYwTcTXI1GQ5JXvb29CIfDMjYZIDMBNzg4KIEyk2pUt2NSiokCqq4xyGO/9fT0iMoSg0wm5lqtlihQctFBuXOn0ykKWVwklUol9Pf3S3sxuc7FXKvVkvfsdruMIao+MXmTz+dF4ZFy4PTBXJyyLlRG4zXYh5SobzabkrBgstDr9QphLJWalixZAqvVKgpQ0WhUgm8SPg8NDUlSSiXpHxgYEOU4JgM4ltWkFINwSnk3Gg0cPnxYVDyZ6KSyaiQSwejoqATc5XJZFP+azSaGh4eFXJdkwlxQud1uDA4OSlJKvXexWMTAwIAkV0ZGRkRi3u12A4CoUpKw12azYWRkRPxnNBpFuVyWhYKaAFavTcUwv98v49Dtdou/Y+KFdsC5hvbORS7HrSrrTt9XKpU6FCMtFgvsdjuSySQGBgZgMplEKSwajQKAJJ3b7bb4ZCrW8l5MHA0MDIgNOBwOGe8c82pSigkT9rualOLijUl99g1JlpnUoJAGVcK4gGs2m7KRRVL/crncseCk4iH/pt9iIlRVgqN6FctKlVN+tr+/X5LF9G2MSaj6Nzo6ilAoBIfDgaVLl0pCjnMe7YpKlNxcYkKeySiSSXOjgG1AG+JCmxsXpVIJZrMZfr9flBdp99yY6+npQSgUEjtlfNBoNMQOOA9SLZPqsEx+chNAXeyzX9jXTO7R5zO5x7ihUChIX1DRmPFfsVhEpVIRX8+xzKRopVIR+2PSmkkiJqWYOFTL2m63YbfbRQmaKszcQKNd0PfUajXxA5ynXS6XJKDa7Tb6+/sxMjIi71WrVaRSKQAQsm3ampqU4Xzh9XoxMDCAYDAoSSk1mcgyRaNR2RxkQpOxNudPkupTkY7qc4wVuDnFpCvVdefn5xGLxSSuj8fj8Pv9svHL5B2T6tyQzOVyEiMwwTg4OCjKxYx53G63bByw/tzAo5gGNwapiszYjAkbkpTTJxB2u11U6yiYEovFxA6DwaC0P1XuGAcDkPhpZGRElI5VJUjOa9yQAY4kMA4dOoRKpYLBwUEpJzeH8/m8JMmp7Ox0OjE6OiqxDJOHalKKfcaNOMZAjIVpu+xn+l62CWN4tjP9hJrs09DQOLWgic5PABhQqwoSwFFVC1XdglCVWYzg/1SlDr6vKsGo7/N+xmuoaljq97t9R72HUa1noTKpdTPeX1U3Mip8qGXvVhf1fbXt+LeqbvNC3wGOKpOon+3WF6qCh1ouXkMtg9pGxjKq1zX22fHa3qj6on63G17ofbXOxvfVOnHB1K3cfI+LSCO6tWU32+SOoHqNhcaH8fpqmwOQpMZCZenWLsb/GdumG45n32rZjGU1XqPbT/V3VbGKdtVt3HfrT1UpTYWqTPVC4+149Ve/t9D4UX+qfaX6Q7VM3caE+v1ubdrtOoSq2rZQWV6Mv+S1jH2oqrmp6mfq91VVK9WP8Pvd2rzbe+rY5Jgx+i/WhwsjtR3UevB7C/k3dUGj/l9V1VLVrRZqv27X6+bT1fZUv2uEcYy8kB9cqFzdxrr6OdZTvY/Rhoz3MNqiOid2K6PxO8a52Fhvtd+62Yrxuur/usUM6ue72YJaHvW7xlhGbStjfxvHmHo/ddyo42Mhv6HWx2jzxvobsZD/7XYdtT0W8q3G66h1XMgWu9lIt37u5rONfa+WVe0bI4zXM1632xzdrZ7G+rM8qh8z+hD1vqriGa93vDlGHftG9b2Fxn23Plto7PHzqh9U7cAYa6mf7+a7Fxo7arnUGKVbvKRep5sPNdbR+LlutnS8uMdYT+N1utkG+9E4Hyx0H6oqGuvbzQ6N85ZxrjS2kVpOft8Ynxv7wIiF5qxms3lGknlzTUrf+1LBuONMaZuDBw9iyZIlePLJJ7Fp06bFLo7G8dDWaLfb7fanPvWp9sjISNtut7e3bNnS/sUvfvGiv5vL5doA9Eu/9Eu/9Eu/9Eu/9Eu/9Eu/9OsUf+VyuVdxZbk44JrUbDa3LRbLS36ZzeZX3Db/+Z//2X7DG97QDoVCbQDtJ5988pjPVCqV9h//8R+3Q6FQ2+12t9/85je3Z2ZmOj5z6NCh9m/8xm+0nU5nOxqNtt///ve3G43GSyrLgQMHOsrAv/my2WztpUuXtv/qr/6q3Wq1Xm6VNU4AOrdJf0nxta99DTfeeCNuueUWPPHEE9i4cSMuueQSJBKJxS6ahoaGhoaGhoaGhoaGhsaLQrt97Cn7F/t6pSiVSviVX/kV3HnnnQt+5n3vex++9a1v4d///d/xwAMPYGpqCm9+85vl/81mE5dddhnq9Tr+3//7f/jiF7+Iu+++GzfffPMrLh8A/PCHP8T09DT27NmDv/zLv8Ttt9+O//t//+8JubbGy8QiJMJOOWzZsqV97bXXyt/NZrMdj8fbd9xxx4v6vj4ppV/6pV/6pV/6pV/6pV/6pV/6dXq8zuSTUgDaJpPpJb9OZNsYTykR2Wy2bbPZ2v/+7/8u7+3cubMNoP3www+32+12+7vf/W7bbDZ3nJ76zGc+0/b5fO1arbbgPX/xi1+0N23a1Lbb7e3Nmze3v/71r3eUYaEy/dqv/Vr7j//4j19ZhTVeEX7pT0rV63U8/vjjuOiii+Q9s9mMiy66CA8//PAilkxDQ0NDQ0NDQ0NDQ0ND48zA448/jkaj0bH2XrVqFYaHh2Xt/fDDD2P9+vXo7e2Vz1xyySXI5/PYsWNH1+sWi0X85m/+JtasWYPHH38ct956K97//ve/YHkee+wxPP7449i6desrrJnGK8EvvfpeMplEs9nsMHoA6O3txfPPP9/1O7VaTSTOgSNKGRoaGhoaGhoaGhoaGhqnPton4FG1UxmvpH75fL7jb7vdDrvd/kqLBACYmZlBT08PAoFAx/u9vb2YmZmRz3Rbm/N/3fDlL38ZrVYLn//85+FwOLB27VpMTEzgj/7oj4757Gte8xqYzWbU63U0Gg38/u//Pv73//7fJ6B2Gi8Xv/QnpV4O7rjjDvj9fnkNDw8vdpE0NDQ0NDQ0NDQ0NDQ0XgQKhcJiF+GEo6enB319fa/oGh6PB0NDQx1r3TvuuOOYz33pS1+Cx+OR10MPPfSK7vtKsXPnTmzYsAEOh0Pe27ZtW9fPfu1rX8P27dvx1FNP4d/+7d/wX//1X7jppptOVlE1uuCX/qRUJBKBxWLB7Oxsx/uzs7MLDuoPfvCDuPHGG+XvbDaLkZERjI+Pw+/3v6rl1Xj5yOfzGBoawuHDh88ImdMzEbqPTg/ofjo9oPvp9IDup9MDup9OD+h+Oj2wmP3UbrdRKBQQj8dP6n1PBhwOBw4cOIB6vf6yr9Fut2EymTre63ZK6o1vfGPHI28DAwMv6vp9fX2o1+vIZrMdp6XUtXdfXx8eeeSRju9xrf5Kk24AMDQ0hGXLlgEAVq9ejX379uHDH/4wbr311o6klsbJwy99UqqnpwebN2/G/fffjze96U0AgFarhfvvvx/XXXdd1+8sdITR7/frCfA0gM/n0/10ikP30ekB3U+nB3Q/nR7Q/XR6QPfT6QHdT6cHFqufzuRDBA6H46QkVrxeL7xe70v+3ubNm2Gz2XD//ffjiiuuAADs2rUL4+PjcrJp27ZtuP3225FIJBCLxQAAP/jBD+Dz+bBmzZqu1129ejX+5V/+BdVqVer/85///EWVyWKxYH5+HvV6XSelFgm/9EkpALjxxhtx1VVX4ZxzzsGWLVvw8Y9/HKVSCe9617sWu2gaGhoaGhoaGhoaGhoaGqc80uk0xsfHMTU1BeBIwgk4csKpr68Pfr8f11xzDW688UaEQiH4fD68973vxbZt23DeeecBAC6++GKsWbMG73znO/G3f/u3mJmZwV/8xV/g2muvXZDb6u1vfzv+/M//HO95z3vwwQ9+EAcPHsRHP/rRrp9NpVKYmZnB/Pw8nnnmGXziE5/A6173Op3IXkTopBSA3/md38Hc3BxuvvlmzMzMYNOmTbjvvvuOIVjT0NDQ0NDQ0NDQ0NDQ0NA4Fvfee2/HwY4rr7wSAHDLLbfg1ltvBQB87GMfg9lsxhVXXIFarYZLLrkEn/70p+U7FosF3/72t/FHf/RH2LZtG9xuN6666ip85CMfWfC+Ho8H3/rWt/CHf/iHOOuss7BmzRrceeedchpLBZX/LBYL+vv78Ru/8Ru4/fbbT0T1NV4mdFLqf3Ddddct+LjeC8Fut+OWW245YaoEGq8OdD+d+tB9dHpA99PpAd1Ppwd0P50e0P10ekD30+kB3U9nLq6++mpcffXVx/2Mw+HAXXfdhbvuumvBz4yMjOC73/3uS7r3eeedh+3bt3e8p6oQjo6OnvGqi6crTG3dMxoaGhoaGhoaGhoaGhoaGhoaJxnmxS6AhoaGhoaGhoaGhoaGhoaGhsYvH3RSSkNDQ0NDQ0NDQ0NDQ0NDQ0PjpEMnpTQ0NDQ0NDQ0NDQ0NDQ0NDQ0Tjp0UuoV4q677sLo6CgcDge2bt2KRx55ZLGLpGHAgw8+iMsvvxzxeBwmkwnf/OY3F7tIGgbccccdOPfcc+H1ehGLxfCmN71JJGQ1Th185jOfwYYNG+Dz+eDz+bBt2zZ873vfW+xiaRwHf/M3fwOTyYQbbrhhsYuiYcCtt94Kk8nU8Vq1atViF0vDgMnJSfzu7/4uwuEwnE4n1q9fj8cee2yxi6WhYHR09JixZDKZcO211y520TQUNJtNfPjDH8aSJUvgdDqxdOlS/NVf/ZUmntbQ0NBJqVeCr33ta7jxxhtxyy234IknnsDGjRtxySWXIJFILHbRNBSUSiVs3LjxuAoPGouLBx54ANdeey1+/vOf4wc/+AEajQYuvvhilEqlxS6ahoLBwUH8zd/8DR5//HE89thjeP3rX4/f+q3fwo4dOxa7aBpd8Oijj+Kf/umfsGHDhsUuisYCWLt2Laanp+X105/+dLGLpKEgk8ng/PPPh81mw/e+9z0899xz+Pu//3sEg8HFLpqGgkcffbRjHP3gBz8AALz1rW9d5JJpqLjzzjvxmc98Bp/61Kewc+dO3Hnnnfjbv/1bfPKTn1zsomloaCwytPreK8DWrVtx7rnn4lOf+hQAoNVqYWhoCO9973tx0003LXLpNLrBZDLhG9/4Bt70pjctdlE0joO5uTnEYjE88MADuPDCCxe7OBrHQSgUwt/93d/hmmuuWeyiaCgoFos4++yz8elPfxq33XYbNm3ahI9//OOLXSwNBbfeeiu++c1vHiNfrXHq4KabbsLPfvYzPPTQQ4tdFI2XgBtuuAHf/va3sWfPHphMpsUujsb/4Dd/8zfR29uLz3/+8/LeFVdcAafTiX/9139dxJJpaGgsNvRJqZeJer2Oxx9/HBdddJG8ZzabcdFFF+Hhhx9exJJpaJz+yOVyAI4kPDROTTSbTXz1q19FqVTCtm3bFrs4GgZce+21uOyyyzrmKI1TD3v27EE8HsfY2Bje8Y53YHx8fLGLpKHg3nvvxTnnnIO3vvWtiMViOOuss/C5z31usYulcRzU63X867/+K9797nfrhNQphte85jW4//77sXv3bgDAU089hZ/+9Ke49NJLF7lkGhoaiw3rYhfgdEUymUSz2URvb2/H+729vXj++ecXqVQaGqc/Wq0WbrjhBpx//vlYt27dYhdHw4BnnnkG27ZtQ7VahcfjwTe+8Q2sWbNmsYuloeCrX/0qnnjiCTz66KOLXRSN42Dr1q24++67sXLlSkxPT+Mv//IvccEFF+DZZ5+F1+td7OJpANi/fz8+85nP4MYbb8SHPvQhPProo7j++uvR09ODq666arGLp9EF3/zmN5HNZnH11VcvdlE0DLjpppuQz+exatUqWCwWNJtN3H777XjHO96x2EXT0NBYZOiklIaGximFa6+9Fs8++6zmVjlFsXLlSmzfvh25XA7/8R//gauuugoPPPCATkydIjh8+DD+5E/+BD/4wQ/gcDgWuzgax4F6OmDDhg3YunUrRkZG8G//9m/6cdhTBK1WC+eccw7++q//GgBw1lln4dlnn8VnP/tZnZQ6RfH5z38el156KeLx+GIXRcOAf/u3f8OXvvQlfPnLX8batWuxfft23HDDDYjH43o8aWj8kkMnpV4mIpEILBYLZmdnO96fnZ1FX1/fIpVKQ+P0xnXXXYdvf/vbePDBBzE4OLjYxdHogp6eHixbtgwAsHnzZjz66KP4xCc+gX/6p39a5JJpAMDjjz+ORCKBs88+W95rNpt48MEH8alPfQq1Wg0Wi2URS6ixEAKBAFasWIG9e/cudlE0/gf9/f3HJNxXr16N//zP/1ykEmkcD4cOHcIPf/hDfP3rX1/somh0wQc+8AHcdNNNuPLKKwEA69evx6FDh3DHHXfopJSGxi85NKfUy0RPTw82b96M+++/X95rtVq4//77Nb+KhsZLRLvdxnXXXYdvfOMb+NGPfoQlS5YsdpE0XiRarRZqtdpiF0Pjf/Brv/ZreOaZZ7B9+3Z5nXPOOXjHO96B7du364TUKYxisYh9+/ahv79/sYui8T84//zzsWvXro73du/ejZGRkUUqkcbx8IUvfAGxWAyXXXbZYhdFowvK5TLM5s6lp8ViQavVWqQSaWhonCrQJ6VeAW688UZcddVVOOecc7BlyxZ8/OMfR6lUwrve9a7FLpqGgmKx2LHzfODAAWzfvh2hUAjDw8OLWDIN4tprr8WXv/xl/Nd//Re8Xi9mZmYAAH6/H06nc5FLp0F88IMfxKWXXorh4WEUCgV8+ctfxk9+8hP893//92IXTeN/4PV6j+Fic7vdCIfDmqPtFMP73/9+XH755RgZGcHU1BRuueUWWCwWvO1tb1vsomn8D973vvfhNa95Df76r/8av/3bv41HHnkE//zP/4x//ud/XuyiaRjQarXwhS98AVdddRWsVr28ORVx+eWX4/bbb8fw8DDWrl2LJ598Ev/wD/+Ad7/73YtdNA0NjUWGqd1utxe7EKczPvWpT+Hv/u7vMDMzg02bNuEf//EfsXXr1sUuloaCn/zkJ3jd6153zPtXXXUV7r777pNfII1jsJBCzhe+8AVNVnoK4ZprrsH999+P6elp+P1+bNiwAX/2Z3+GN7zhDYtdNI3j4Fd/9VexadMmfPzjH1/somgouPLKK/Hggw8ilUohGo3iV37lV3D77bdj6dKli100DQXf/va38cEPfhB79uzBkiVLcOONN+I973nPYhdLw4Dvf//7uOSSS7Br1y6sWLFisYuj0QWFQgEf/vCH8Y1vfAOJRALxeBxve9vbcPPNN6Onp2exi6ehobGI0EkpDQ0NDQ0NDQ0NDQ0NDQ0NDY2TDs0ppaGhoaGhoaGhoaGhoaGhoaFx0qGTUhoaGhoaGhoaGhoaGhoaGhoaJx06KaWhoaGhoaGhoaGhoaGhoaGhcdKhk1IaGhoaGhoaGhoaGhoaGhoaGicdOimloaGhoaGhoaGhoaGhoaGhoXHSoZNSGhoaGhoaGhoaGhoaGhoaGhonHToppaGhoaGhoaGhoaGhoaGhoaFx0qGTUhoaGhoaGhoaGhoaGhoaGhoaJx06KaWhoaGhobFIuPrqq/GmN71p0e7/zne+E3/913+9aPc/Ebj77rsRCATk789+9rO4/PLLF69AGhoaGhoaGhoaLxo6KaWhoaGhofEqwGQyHfd166234hOf+ATuvvvuRSnfU089he9+97u4/vrrF+X+rxbe/e5344knnsBDDz202EXR0NDQ0NDQ0NB4AVgXuwAaGhoaGhpnIqanp+X3r33ta7j55puxa9cuec/j8cDj8SxG0QAAn/zkJ/HWt751UcvwaqCnpwdvf/vb8Y//+I+44IILFrs4GhoaGhoaGhoax4E+KaWhoaGhofEqoK+vT15+vx8mk6njPY/Hc8zje7/6q7+K9773vbjhhhsQDAbR29uLz33ucyiVSnjXu94Fr9eLZcuW4Xvf+17HvZ599llceuml8Hg86O3txTvf+U4kk8kFy9ZsNvEf//Efxzzm9ulPfxrLly+Hw+FAb28v3vKWt8j/Wq0W7rjjDixZsgROpxMbN27Ef/zHf3R8f8eOHfjN3/xN+Hw+eL1eXHDBBdi3b598/yMf+QgGBwdht9uxadMm3HffffLdgwcPwmQy4etf/zpe97rXweVyYePGjXj44Yc77nH33XdjeHgYLpcL/+t//S+kUqlj6nf55Zfj3nvvRaVSWbANNDQ0NDQ0NDQ0Fh86KaWhoaGhoXEK4Ytf/CIikQgeeeQRvPe978Uf/dEf4a1vfSte85rX4IknnsDFF1+Md77znSiXywCAbDaL17/+9TjrrLPw2GOP4b777sPs7Cx++7d/e8F7PP3008jlcjjnnHPkvcceewzXX389PvKRj2DXrl247777cOGFF8r/77jjDtxzzz347Gc/ix07duB973sffvd3fxcPPPAAAGBychIXXngh7HY7fvSjH+Hxxx/Hu9/9bszPzwMAPvGJT+Dv//7v8dGPfhRPP/00LrnkErzxjW/Enj17Osr253/+53j/+9+P7du3Y8WKFXjb294m1/jFL36Ba665Btdddx22b9+O173udbjtttuOqd8555yD+fl5/OIXv3iZvaChoaGhoaGhoXEyYGq32+3FLoSGhoaGhsaZjLvvvhs33HADstlsx/tXX301stksvvnNbwI4clKq2WwKH1Kz2YTf78eb3/xm3HPPPQCAmZkZ9Pf34+GHH8Z5552H2267DQ899BD++7//W647MTGBoaEh7Nq1CytWrDimPN/85jfxlre8BY1GAyaTCQDw9a9/He9617swMTEBr9fb8flarYZQKIQf/vCH2LZtm7z/e7/3eyiXy/jyl7+MD33oQ/jqV7+KXbt2wWazHXPPgYEBXHvttfjQhz4k723ZsgXnnnsu7rrrLhw8eBBLlizB//k//wfXXHMNAOC5557D2rVrsXPnTqxatQpvf/vbkcvl8J3vfEeuceWVV+K+++47pm1DoRA+9rGP4aqrruraJxoaGhoaGhoaGosPfVJKQ0NDQ0PjFMKGDRvkd4vFgnA4jPXr18t7vb29AIBEIgHgCGH5j3/8Y+Go8ng8WLVqFQDIo3NGVCoV2O12SUgBwBve8AaMjIxgbGwM73znO/GlL31JTmPt3bsX5XIZb3jDGzruc88998g9tm/fjgsuuKBrQiqfz2Nqagrnn39+x/vnn38+du7cuWD9+/v7O+q6c+dObN26tePzapJMhdPplPJraGhoaGhoaGicmtBE5xoaGhoaGqcQjEkdk8nU8R4TSa1WCwBQLBZx+eWX48477zzmWkzqGBGJRFAul1Gv19HT0wMA8Hq9eOKJJ/CTn/wE3//+93HzzTfj1ltvxaOPPopisQgA+M53voOBgYGOa9ntdgBHkkAnAser60tBOp1GNBo9IWXS0NDQ0NDQ0NB4daCTUhoaGhoaGqcxzj77bPznf/4nRkdHYbW+uGl906ZNAI48HsffAcBqteKiiy7CRRddhFtuuQWBQAA/+tGP8IY3vAF2ux3j4+N47Wtf2/WaGzZswBe/+EU0Go1jEms+nw/xeBw/+9nPOr7/s5/9DFu2bHnRdV29evUxPFE///nPj/ncvn37UK1WcdZZZ73oa2toaGhoaGhoaJx86Mf3NDQ0NDQ0TmNce+21SKfTeNvb3oZHH30U+/btw3//93/jXe96F5rNZtfvRKNRnH322fjpT38q733729/GP/7jP2L79u04dOgQ7rnnHrRaLaxcuRJerxfvf//78b73vQ9f/OIXsW/fPjzxxBP45Cc/iS9+8YsAgOuuuw75fB5XXnklHnvsMezZswf/8i//gl27dgEAPvCBD+DOO+/E1772NezatQs33XQTtm/fjj/5kz950XW9/vrrcd999+GjH/0o9uzZg0996lMdCn7EQw89hLGxMSxduvSlNKWGhoaGhoaGhsZJhk5KaWhoaGhonMbgCaRms4mLL74Y69evxw033IBAIACzeeFp/vd+7/fwpS99Sf4OBAL4+te/jte//vVYvXo1PvvZz+IrX/kK1q5dCwD4q7/6K3z4wx/GHXfcgdWrV+PXf/3X8Z3vfAdLliwBAITDYfzoRz9CsVjEa1/7WmzevBmf+9zn5NTU9ddfjxtvvBF/+qd/ivXr1+O+++7Dvffei+XLl7/oup533nn43Oc+h0984hPYuHEjvv/97+Mv/uIvjvncV77yFbznPe950dfV0NDQ0NDQ0NBYHGj1PQ0NDQ0NjV9CVCoVrFy5El/72tcWJAs/HbFjxw68/vWvx+7du+H3+xe7OBoaGhoaGhoaGseBPimloaGhoaHxSwin04l77rkHyWRysYtyQjE9PY177rlHJ6Q0NDQ0NDQ0NE4D6JNSGhoaGhoaGhoaGhoaGhoaGhonHfqklIaGhoaGhoaGhoaGhoaGhobGSYdOSmloaGhoaGhoaGhoaGhoaGhonHTopJSGhoaGhoaGhoaGhoaGhoaGxkmHTkppaGhoaGhoaGhoaGhoaGhoaJx06KSUhoaGhoaGhoaGhoaGhoaGhsZJh05KaWhoaGhoaGhoaGhoaGhoaGicdOiklIaGhoaGhoaGhoaGhoaGhobGSYdOSmloaGhoaGhoaGhoaGhoaGhonHTopJSGhoaGhoaGhoaGhoaGhoaGxkmHTkppaGhoaGhoaGhoaGhoaGhoaJx0/P9DPGshtNiwxAAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mel 频谱图形状: torch.Size([1, 320, 831])\n" + ] + } + ], + "source": [ + "# Cell 4: 计算并可视化 Mel 频谱图\n", + "# 计算 Mel 频谱图\n", + "mel_spec = mel_transform(waveform)\n", + "\n", + "log_mel_spec = AmplitudeToDB()(mel_spec)\n", + "\n", + "# 创建可视化\n", + "fig, axes = plt.subplots(2, 1, figsize=(12, 8))\n", + "\n", + "# 原始波形\n", + "axes[0].plot(waveform[0].numpy())\n", + "axes[0].set_title(\"Original waveform\")\n", + "axes[0].set_xlabel(\"sample\")\n", + "axes[0].set_ylabel(\"Amplitude\")\n", + "axes[0].grid(True)\n", + "\n", + "# Mel 频谱图\n", + "im = axes[1].imshow(\n", + " log_mel_spec[0].numpy(),\n", + " cmap='gray',\n", + " aspect='auto',\n", + " origin='lower',\n", + " extent=[0, waveform.shape[-1] / sample_rate, 0, CONFIG[\"n_mels\"]]\n", + ")\n", + "axes[1].set_title(\"Log Mel Spectrogram\")\n", + "axes[1].set_xlabel(\"Time (second)\")\n", + "axes[1].set_ylabel(\"Mels\")\n", + "plt.colorbar(im, ax=axes[1], format='%+2.0f dB')\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "print(f\"Mel 频谱图形状: {mel_spec.shape}\") # (channel, n_mels, time_frames)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "56db5576", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([1, 320, 831])\n" + ] + } + ], + "source": [ + "print(log_mel_spec.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "cfa5546a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([1, 320, 831])\n", + "CNN OUT: torch.Size([1, 32, 40, 208])\n", + "transformer input: torch.Size([1, 208, 640])\n", + "tensor([208])\n", + "conformer out: torch.Size([1, 208, 200])\n", + "conformer length out: tensor([208])\n", + "loss: tensor(-3.9094, grad_fn=)\n" + ] + } + ], + "source": [ + "from torch.nn import Conv2d, Linear, CTCLoss\n", + "from torchaudio.models import Conformer\n", + "from torch import Tensor\n", + "import math\n", + "\n", + "print(log_mel_spec.shape)\n", + "#torch.Size([1, 320, 831])\n", + "\n", + "filter_1 = Conv2d(in_channels=1, out_channels=16, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n", + "filter_2 = Conv2d(in_channels=16, out_channels=32, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n", + "filter_3 = Conv2d(in_channels=32, out_channels=32, kernel_size=(3, 3), stride=(2, 1), padding=(1, 1))\n", + "proj = Linear(in_features=1280, out_features=640)\n", + "ctc_head = Linear(in_features=640, out_features=200, bias=False)\n", + "encoder = Conformer(\n", + " input_dim=640,\n", + " num_heads=8,\n", + " ffn_dim=2048,\n", + " num_layers=6,\n", + " depthwise_conv_kernel_size=31,\n", + " dropout=0.1,\n", + " \n", + ")\n", + "\n", + "log_mel_spec = log_mel_spec.unsqueeze(1)\n", + "\n", + "out: Tensor = filter_1(log_mel_spec)\n", + "out = filter_2(out)\n", + "out = filter_3(out)\n", + "print(\"CNN OUT:\", out.shape)\n", + "# torch.Size([1, 32, 20, 208])\n", + "\n", + "transformer_input: Tensor = out.reshape([out.shape[0], out.shape[3], out.shape[1] * out.shape[2]])\n", + "transformer_input = proj(transformer_input)\n", + "print(\"transformer input: \", transformer_input.shape)\n", + "# transformer_input = proj(transformer_input)\n", + "# print(transformer_input.shape)\n", + "#[N, T, d_model] where N = batch, T = seq len, d_model = feature\n", + "lengths = torch.tensor([transformer_input.shape[1]], dtype=torch.long)\n", + "print(lengths)\n", + "out_latent_space, out_lengths = encoder(input=transformer_input, lengths=lengths)\n", + "out_latent_space: Tensor = ctc_head(out_latent_space)\n", + "out_latent_space: Tensor\n", + "out_lengths:Tensor\n", + "\n", + "print(\"conformer out: \", out_latent_space.shape)\n", + "print(\"conformer length out: \", out_lengths)\n", + "\n", + "criterion = CTCLoss(blank=0, zero_infinity=True, )\n", + "dummy_target = torch.randint(0, 200, [1, math.floor(out_latent_space.shape[1] / 4)])\n", + "loss: Tensor = criterion(log_probs=out_latent_space.reshape(out_latent_space.shape[0] * out_latent_space.shape[1], out_latent_space.shape[2]), targets=dummy_target, input_lengths=out_lengths, target_lengths=torch.tensor([dummy_target.shape[1]], dtype=torch.long))\n", + "print(\"loss: \", loss)\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "421d0749", + "metadata": {}, + "source": [ + "## Conv1D over waveform approach" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "83fc7c1e", + "metadata": {}, + "outputs": [], + "source": [ + "from torch.nn import Linear, Conv1d, ModuleList, GELU, GroupNorm\n", + "from torchaudio.models import Conformer\n", + "waveform = waveform.unsqueeze(0)[:, :, :16000]" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "a76e8e18", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Shape of waveform: torch.Size([1, 1, 16000])\n", + "Shape after 0th: layer: torch.Size([1, 512, 3199]), layer_instance: Conv1d(1, 512, kernel_size=(10,), stride=(5,))\n", + "Shape after 1th: layer: torch.Size([1, 512, 3199]), layer_instance: GroupNorm(32, 512, eps=1e-05, affine=True)\n", + "Shape after 2th: layer: torch.Size([1, 512, 3199]), layer_instance: GELU(approximate='none')\n", + "Shape after 3th: layer: torch.Size([1, 512, 1599]), layer_instance: Conv1d(512, 512, kernel_size=(3,), stride=(2,))\n", + "Shape after 4th: layer: torch.Size([1, 512, 1599]), layer_instance: GroupNorm(32, 512, eps=1e-05, affine=True)\n", + "Shape after 5th: layer: torch.Size([1, 512, 1599]), layer_instance: GELU(approximate='none')\n", + "Shape after 6th: layer: torch.Size([1, 512, 799]), layer_instance: Conv1d(512, 512, kernel_size=(3,), stride=(2,))\n", + "Shape after 7th: layer: torch.Size([1, 512, 799]), layer_instance: GroupNorm(32, 512, eps=1e-05, affine=True)\n", + "Shape after 8th: layer: torch.Size([1, 512, 799]), layer_instance: GELU(approximate='none')\n", + "Shape after 9th: layer: torch.Size([1, 512, 399]), layer_instance: Conv1d(512, 512, kernel_size=(3,), stride=(2,))\n", + "Shape after 10th: layer: torch.Size([1, 512, 399]), layer_instance: GroupNorm(32, 512, eps=1e-05, affine=True)\n", + "Shape after 11th: layer: torch.Size([1, 512, 399]), layer_instance: GELU(approximate='none')\n", + "Shape after 12th: layer: torch.Size([1, 512, 199]), layer_instance: Conv1d(512, 512, kernel_size=(3,), stride=(2,))\n", + "Shape after 13th: layer: torch.Size([1, 512, 199]), layer_instance: GroupNorm(32, 512, eps=1e-05, affine=True)\n", + "Shape after 14th: layer: torch.Size([1, 512, 199]), layer_instance: GELU(approximate='none')\n", + "Shape after 15th: layer: torch.Size([1, 512, 99]), layer_instance: Conv1d(512, 512, kernel_size=(2,), stride=(2,))\n", + "Shape after 16th: layer: torch.Size([1, 512, 99]), layer_instance: GroupNorm(32, 512, eps=1e-05, affine=True)\n", + "Shape after 17th: layer: torch.Size([1, 512, 99]), layer_instance: GELU(approximate='none')\n", + "Shape after 18th: layer: torch.Size([1, 512, 49]), layer_instance: Conv1d(512, 512, kernel_size=(2,), stride=(2,))\n", + "Shape after 19th: layer: torch.Size([1, 512, 49]), layer_instance: GroupNorm(32, 512, eps=1e-05, affine=True)\n", + "Shape after 20th: layer: torch.Size([1, 512, 49]), layer_instance: GELU(approximate='none')\n", + "torch.Size([1, 49, 256])\n" + ] + } + ], + "source": [ + "\n", + "print(f\"Shape of waveform: {waveform.shape}\")\n", + "\n", + "filters = ModuleList([\n", + " Conv1d(in_channels=1, out_channels=512, kernel_size=10, stride=5),\n", + " GroupNorm(num_channels=512, num_groups=32),\n", + " GELU(),\n", + " Conv1d(in_channels=512, out_channels=512, kernel_size=3, stride=2),\n", + " GroupNorm(num_channels=512, num_groups=32),\n", + " GELU(),\n", + " Conv1d(in_channels=512, out_channels=512, kernel_size=3, stride=2),\n", + " GroupNorm(num_channels=512, num_groups=32),\n", + " GELU(),\n", + " Conv1d(in_channels=512, out_channels=512, kernel_size=3, stride=2),\n", + " GroupNorm(num_channels=512, num_groups=32),\n", + " GELU(),\n", + " Conv1d(in_channels=512, out_channels=512, kernel_size=3, stride=2),\n", + " GroupNorm(num_channels=512, num_groups=32),\n", + " GELU(),\n", + " Conv1d(in_channels=512, out_channels=512, kernel_size=2, stride=2),\n", + " GroupNorm(num_channels=512, num_groups=32),\n", + " GELU(),\n", + " Conv1d(in_channels=512, out_channels=512, kernel_size=2, stride=2),\n", + " GroupNorm(num_channels=512, num_groups=32),\n", + " GELU(),\n", + "])\n", + "\n", + "projector = Linear(in_features=512, out_features=256)\n", + "\n", + "filter_out = waveform\n", + "for i, filter in enumerate(filters):\n", + " filter_out: Tensor = filter(filter_out)\n", + " print(f\"Shape after {i}th: layer: {filter_out.shape}, layer_instance: {filter}\")\n", + "filter_out = filter_out.permute(0, 2, 1)\n", + "filter_out = projector(filter_out)\n", + "print(filter_out.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "567df2f1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "49\n" + ] + } + ], + "source": [ + "dummy_waveform = torch.zeros(1, 1, 16000)\n", + "for i, filter in enumerate(filters):\n", + " # print(i)\n", + " dummy_waveform = filter(dummy_waveform)\n", + "shink_factor = dummy_waveform.shape[2]\n", + "print(shink_factor)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "study-asr (3.11.12)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/handle/test.py b/src/handle/test.py new file mode 100644 index 0000000..4a0cedc --- /dev/null +++ b/src/handle/test.py @@ -0,0 +1,220 @@ +import os +import random +import sys + +import pandas as pd +import torchaudio +from pathlib import Path +from tqdm import tqdm + + +workspace_dir = Path(__file__).parent.parent.parent +sys.path.append(str(workspace_dir.joinpath('src'))) +# sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +from handle.text_handle import process_text +from tokenizer import ASRTokenizer + +# 读取 TSV +# df = pd.read_csv(workspace_dir / '.data/ug/train.tsv', sep='\t') + +# # 计算每个音频的时长（秒） +# durations = [] +# for audio_path in tqdm(workspace_dir / '.data/ug/clips' / df['path'], desc="计算音频时长"): +# try: +# # 获取音频信息（不加载整个文件，速度快） +# info = torchaudio.info(audio_path) +# duration = info.num_frames / info.sample_rate +# durations.append(duration) +# except Exception as e: +# print(f"读取失败: {audio_path}, 错误: {e}") +# durations.append(None) + +# # 添加到 DataFrame +# df['duration'] = durations + +# # 统计 +# print(df['duration'].describe()) +# print(f"超过20秒的样本: {(df['duration'] > 20).sum()}") + +# 保存结果（可选） +# df.to_csv('data/audio/train_with_duration.tsv', sep='\t', index=False) + +# audio_path = workspace_dir / '.data/ug/clips/common_voice_ug_40252722.mp3' +# info = torchaudio.info(audio_path) +# print("info:", info) +import pandas as pd +import torch +import torchaudio +import numpy as np +from pathlib import Path +from tqdm import tqdm + +def analyze_audio_quality(audio_path, sample_rate_target=16000): + """ + 评估音频质量，返回多个指标 + """ + try: + # 加载音频 + waveform, sr = torchaudio.load(str(audio_path)) + + # 重采样 + 单声道 + if sr != sample_rate_target: + resampler = torchaudio.transforms.Resample(sr, sample_rate_target) + waveform = resampler(waveform) + if waveform.shape[0] > 1: + waveform = waveform.mean(dim=0, keepdim=True) + + # 归一化 + max_val = waveform.abs().max() + if max_val > 0: + waveform = waveform / max_val + + # ===== 指标 1: 静音比例 ===== + silence_threshold = 0.01 + is_silence = waveform.abs() < silence_threshold + silence_ratio = is_silence.float().mean().item() + + # ===== 指标 2: 动态范围 ===== + frame_len = int(0.025 * sample_rate_target) # 25ms + hop_len = int(0.010 * sample_rate_target) # 10ms + + num_frames = (waveform.shape[1] - frame_len) // hop_len + 1 + if num_frames <= 0: + return None + + energies = [] + for i in range(num_frames): + start = i * hop_len + frame = waveform[:, start:start + frame_len] + rms = frame.pow(2).mean().sqrt().item() + energies.append(rms) + + energies = np.array(energies) + energies = np.clip(energies, 1e-10, None) + + log_energies = 20 * np.log10(energies) + dynamic_range = log_energies.max() - log_energies.min() + + # ===== 指标 3: 语音活跃度 ===== + energy_threshold = np.percentile(energies, 30) + voice_ratio = (energies > energy_threshold).mean() + + # ===== 指标 4: 频谱中心频率 ===== + spec_transform = torchaudio.transforms.Spectrogram(n_fft=512) + spec = spec_transform(waveform) # [1, freq, time] + + # 用 torch 计算，避免 numpy axis 问题 + freqs = torch.fft.rfftfreq(512, d=1.0/sample_rate_target) + spec_mean = spec.mean(dim=-1).squeeze() # [freq_bins] torch 张量 + + # 确保类型一致，用 torch 计算 + spectral_centroid = (freqs * spec_mean).sum() / (spec_mean.sum() + 1e-10) + spectral_centroid = spectral_centroid.item() + + # ===== 指标 5: 频谱通量 ===== + spec_np = spec.squeeze().numpy() # [freq, time] + flux = np.abs(np.diff(spec_np, axis=1)).mean() + + return { + 'duration': waveform.shape[1] / sample_rate_target, + 'silence_ratio': silence_ratio, + 'dynamic_range_db': float(dynamic_range), + 'voice_ratio': float(voice_ratio), + 'spectral_centroid': spectral_centroid, + 'spectral_flux': float(flux), + 'energy_std': float(energies.std()), + } + + except Exception as e: + print(f"失败: {audio_path}, {e}") + return None + + +# ===== 批量处理 ===== +# df = pd.read_csv(workspace_dir / '.data/ug/train.tsv', sep='\t') + +# results = [] +# for _, row in tqdm(df.iterrows(), total=len(df), desc="评估音频质量"): +# audio_path = workspace_dir / '.data/ug/clips' / row['path'] +# metrics = analyze_audio_quality(audio_path) +# if metrics: +# metrics['path'] = row['path'] +# results.append(metrics) + +# # 汇总 +# quality_df = pd.DataFrame(results) +# print(quality_df.describe()) + + +# # ===== 质量评分 ===== +# def score_quality(row): +# score = 100 + +# if row['silence_ratio'] > 0.5: +# score -= 30 +# elif row['silence_ratio'] > 0.3: +# score -= 15 + +# if row['dynamic_range_db'] < 10: +# score -= 25 +# elif row['dynamic_range_db'] < 20: +# score -= 10 + +# if row['voice_ratio'] < 0.3: +# score -= 20 + +# if row['spectral_centroid'] > 4000: +# score -= 15 + +# return max(0, score) + +# quality_df['quality_score'] = quality_df.apply(score_quality, axis=1) + +# quality_df['grade'] = pd.cut( +# quality_df['quality_score'], +# bins=[0, 40, 60, 80, 100], +# labels=['差(弃用)', '较差', '一般', '良好'] +# ) + +# print("\n质量分级统计:") +# print(quality_df['grade'].value_counts()) + +# # 保存结果 +# quality_df.to_csv('audio_quality_analysis.csv', index=False) +# print("\n结果已保存到 audio_quality_analysis.csv") + + +# Test +# text = "مەن مەكتەپكە باردىم" +# text = "ئاۋۋال كومپىيوتىرنى بىر كۆرسەم شۇنىڭغا قاراپ ماسلاشتۇرسام بوللاتتى" +text = "قاپاقنى پۇلغا ئالماي، باراڭنى پۇلغا ئاپتۇ" +# text = "ئامېىقى جاھان گۈرلىكىە قارشتۇرۇپ چوكشەڭگە ياردەم بېرىش ئۇرۇشىنىڭ ئلۇغ غەلبىسى جۇڭگو خەلقى ئورندىن دەستۇرغاندىكىن، دۇنيانىڭ شەرقىدە قەت كۆتۈرگەنلكىنى خىتاب لامىسى." +# text = "ئاۋسترالىيە" + +text = " ھەر قانداق ئىشتا كىشىلەر بىلەن كېڭىشىش كېرەك. لېكىن كۆڭۈل تارتقان ئىشنى قىلىۋېرىش كېرەك." +text = "\" 15 يىل بۇرۇن مەن بىلەن سەي چۇڭشىن (ئالى بابانىڭ قۇرغۇچىسىدىن بىرى) ئامېرىكىغا بېرىپ 30 نەچچە مەبلەغ سالغۇچى شىركەتلەر بىلەن كۆرۈشكىنىمىزدە ئۇلار بىزنى رەت قىلىپ ئىشىك سىرتىدا قالدۇرغاندى. ھېچكىم بىزگە ۋە كەلگۈسىمىزگە ئىشەنمىگەن ئىدى، ھېچكىممۇ بىزنىڭ ھازىر 300 مىليارد سودىنى تاماملىيالايدىغانلىقىمىزنى ئويلاپ خىيالىغىمۇ كەلتۈرمىگەن ئىدى.\" ئالى بابانىنىڭ ئورگىنى تەرىپىدىن ئىشلەنگەن ئىگىلىك تىكلەش ھۆججەتلىك فىلىمى \" بۇ چۈش ئەمەس\" نىڭ باش قىسمىدا مۇنداق بىر داڭلىق سۆز چىقىدۇ:\" مەن تاغدىن ئۆتكەن ۋاقتىمدا تاغ ماڭا گەپ قىلمىدى، مەن دېڭىزنى كېچىپ ئۆتكىنىمدە دېڭىز ماڭا گەپ قىلمىدى.\" بۇ فىلىمنىڭ قوشۇمچە ئىسمى بولسا \" مايۈن ۋە ئۇنىڭ مەڭگۈلۈك ' ياش ئالى'سى\" بولۇپ، ھەرخىل خەتەر ۋە قىيىنلىقنى بىرمۇ بىر يەڭگەن مايۈن ۋە ئۇنىڭ ئالى بابا قوشۇنىدىكى ھەمكارلاشقۇچىلىرىنىڭ قەيسەر كەچمىشى جانلىق بايان قىلىنغان." +# text = "يۆ جيەنتاۋ يېقىنقى بىر مەزگىلدە، خىزمەتداشلىرى بىلەن نۇرغۇن قىيىنچىلىققا ئۇچرىغان شوپۇرغا ياردەم قىلغانلىقىنى، شۇنداقلا يېمەكلىك ۋە سۇ يەتكۈزۈپ بەرگەنلىكىنى، ئەمما ئاياغ سوۋغا قىلىشى تۇنجى قېتىم ئىكەنلىكىنى، بۈگۈنكىسى 20 يىللىق ساقچىلىق جەريانىدا تۇنجى قېتىم شوپۇرغا ئاياغ سوۋغا قىلىشى ئىكەنلىكىنى ئېيتتى." +text = "يۆ جۇڭمىڭ مۇنداق دېدى: 2019- يىلى 12-ئايدا، مەملىكەتلىك خەلق قۇرۇلتىيى دائىمىي كومىتېتىنىڭ 44- قېتىملىق كومىتېت باشلىقلىرى يىغىنى مەملىكەتلىك خەلق قۇرۇلتىيى دائىمىي كومىتېتىنىڭ 2020-يىللىق قانۇن چىقىرىش خىزمىتى پىلانىنى پىرىنسىپ جەھەتتىن ماقۇللىدى، خىزمەت تەرتىپى بويىچە، 13-نۆۋەتلىك مەملىكەتلىك خەلق قۇرۇلتىيى 3-يىغىنىنىڭ روھى ۋە ۋەكىللەرنىڭ تەكلىپ-تەۋسىيەلىرىگە ئاساسەن پىلاننى تەڭشەش كېرەك. بۇ يىل 6-ئاينىڭ 1-كۈنى، 58-قېتىملىق كومىتېت باشلىقلىرى يىغىنى تەڭشەلگەندىن كېيىنكى يىللىق قانۇن چىقىرىش خىزمىتى پىلانىنى قاراپ چىقىپ ماقۇللىدى." +text = " ئاشقازان-ئۈچەينىڭ لۆمۈلدىشىنى ئىلگىرى سۈرىدىغان دورىنى تاماقتىن بۇرۇن ئىستېمال قىلىش كېرەك." +text = "مەن مەكتەپكە باردىم" +# text = "غەرىپئەللىرى" +# text = "ئىكەنلىكىنى، بۈگۈنكىسى 20 يىللىق ساقچىلىق جەريانىدا تۇنجى" +# text = " يېزىدىكى كەڭ، ئازادە ئۆي، باغلىرىنى تاشلاپ، خەقنىڭ ھويلىسىدا قورۇنۇپ-ئەيمىنىپ يەر دەسسەپ يۈردى. " +# text = "بۇ يىللىق ئەمگەكچىلەر بايرىمىدا، 1-مايدىن 5-مايغىچە جەمئىي بەش كۈن دەم ئېلىشقا قويۇپ بېرىلىدۇ. 9-ماي (شەنبە) نورمال خىزمەت قىلىنىدۇ. شۇنىڭ بىلەن بىر ۋاقىتتا، ئۈرۈمچى شەھىرى تىيانشان رايونى، سايباغ رايونى، داۋانچىڭ رايونى، ئۈرۈمچى ناھىيەسىدىكى ئوتتۇرا، باشلانغۇچ مەكتەپلەر 29-ئاپرېلدىن 30-ئاپرېلغىچە ئەتىيازلىق دەم ئېلىشقا قويۇپ بېرىدۇ؛ سانجى ئوبلاستىدىكى ئوتتۇرا، باشلانغۇچ مەكتەپلەرنىڭ ئەتىيازلىق دەم ئېلىشى ئۈچ كۈن بولۇپ، بۇنىڭ ئىچىدە ئىككى كۈن 29-، 30-ئاپرېلغا ئورۇنلاشتۇرۇلىدۇ، قالغان بىر كۈن 1-ئىيۇنغا ئورۇنلاشتۇرۇلىدۇ، قۇربان ھېيتلىق دەم ئېلىش بىلەن بىرلەشتۈرۈلۈپ، ئۇدا ئالتە كۈن دەم ئېلىنىدۇ." +# text = "ئەڭ يېڭى دەم ئېلىشقا قويۇپ بېرىش ئۇقتۇرۇشى! تەقەززالىق بىلەن كۈتكەن يەنە بىر دەم ئېلىش كېلەي دەپ قالدى! گوۋۇيۈەن بەنگۇڭتىڭىنىڭ «2025-يىللىق قىسمەن بايرام، دەم ئېلىش كۈنلىرىنى ئورۇنلاشتۇرۇش توغرىسىدىكى ئۇقتۇرۇشى»غا ئاساسەن، دۈەنۋۇ بايرىمىلىق دەم ئېلىشقا قويۇپ بېرىش ئورۇنلاشتۇرۇلۇشى تۆۋەندىكىچە: 5-ئاينىڭ 31-كۈنى (شەنبە)دىن 6-ئاينىڭ 2-كۈنىگىچە جەمئىي ئۈچ كۈن دەم ئېلىشقا قويۇپ بېرىلىدۇ! بۇ قېتىمقى دۈەنۋۇ بايرىمىلىق دەم ئېلىش ۋاقتى تەڭشەلمەيدۇ!" +# text = "مەن شۇ چاغدا چۈشۈمدىمۇ كۆرۈپ باقمىغان مۇنچىۋالا جىق قېرىنداشلىرىم، جىگەرلىرىمنىڭ بارلىقىدىن سۆيۈندۈم." +# text = "ئامېرىكا جاھان گىرلىكىگە قارشى تۇرۇپ، چاۋشەنگە ياردەم بىرىش ئۇرۇشىنىڭ ئۇلۇغ غەلبىسى، جۇڭگو خەلقى ئورۇندىن دەس تۇرغاندىنكىن دۇنيانىڭ شەرقىدە قەد كۆتۈرگەنلىكىنىڭ خىتاپنامىس" + + +# result = export_syllabize(text) +result = process_text(text) +print(f"Original: {text}") +print(f"Syllables: {result}") + + +# tokenizer = ASRTokenizer(vocab_path=workspace_dir / 'config/asr_vocab.json') + +# print(text) +# ids = tokenizer.encode(text=text) +# # print(ids) +# print('|'.join(tokenizer.decode([id]) for id in ids)) \ No newline at end of file diff --git a/src/handle/text_handle.py b/src/handle/text_handle.py new file mode 100644 index 0000000..bccd3d6 --- /dev/null +++ b/src/handle/text_handle.py @@ -0,0 +1,195 @@ + +from .text_normalizer import UYGHUR_LETTERS, clean_input_text + +# def uighur_syllabize(text: str): +# # Uyghur Vowels +# vowels = "ئاەئەوۆئۇئۈئىئېاەوۆۇۈىې" + +# def split_word(word): +# syllables = [] +# current_syllable = "" +# i = 0 + +# # Helper to check if a character is a vowel +# is_vowel = lambda char: char in vowels + +# while i < len(word): +# current_syllable += word[i] + +# # If we find a vowel, look ahead to decide where to split +# if is_vowel(word[i]): +# # Check next characters +# remaining = word[i+1:] + +# # Rule 1: V-V (e.g., 'ائ') -> Split after first vowel +# if len(remaining) >= 1 and is_vowel(remaining[0]): +# syllables.append(current_syllable) +# current_syllable = "" + +# # Rule 2: V-C-V (e.g., 'ba-ra') -> Split after first vowel +# elif len(remaining) >= 2 and not is_vowel(remaining[0]) and is_vowel(remaining[1]): +# syllables.append(current_syllable) +# current_syllable = "" + +# # Rule 3: V-C-C-V (e.g., 'mek-tep') -> Split after first consonant +# elif len(remaining) >= 3 and not is_vowel(remaining[0]) and not is_vowel(remaining[1]) and is_vowel(remaining[2]): +# current_syllable += remaining[0] +# syllables.append(current_syllable) +# current_syllable = "" +# i += 1 # Skip the consonant we just added + +# # Rule 4: End of word or C-C-C clusters (rare in native words) +# # We keep going until we find a clear boundary or end of word +# i += 1 + +# if current_syllable: +# syllables.append(current_syllable) +# return syllables + +# # Clean text and process word by word +# words = text.split() +# all_syllables = [] +# for w in words: +# all_syllables.extend(split_word(w)) + +# #merge ئ to next syllable. single ئ no any semantic meaning and no it's dedicated sound. +# original_ayllables = [*all_syllables] +# all_syllables.clear() +# handled = True +# for s in original_ayllables: +# if s == "ئ": +# handled = False +# continue +# if not handled: +# s = "ئ" + s +# handled = True +# all_syllables.append(s) + +# return all_syllables + +# test_words = ['تەكلىپتەۋسىيەلىرىگە', 'تەكلىپ-تەۋسىيەلىرىگە'] +# for tw in test_words: +# print(f"{tw} -> {uighur_syllabize(tw.strip())}") +# تەكلىپتەۋسىيەلىرىگە -> ['تەك', 'لىپ', 'تەۋ', 'سى', 'يە', 'لى', 'رى', 'گە'] +# تەكلىپ-تەۋسىيەلىرىگە -> ['تەك', 'لىپ-تەۋ', 'سى', 'يە', 'لى', 'رى', 'گە'] + + +def uighur_syllabize(text: str): + # Uyghur Vowels (ASU) + vowels = "ئاەئەوۆئۇئۈئىئېاەوۆۇۈىې" + + def is_vowel(char): + return char in vowels + + def split_word(word): + syllables = [] + i = 0 + last_split = 0 + + while i < len(word): + # Look for vowel patterns to determine boundaries + if is_vowel(word[i]): + rem = word[i+1:] + + # Rule: V-V -> Split after first vowel + if len(rem) >= 1 and is_vowel(rem[0]): + syllables.append(word[last_split:i+1]) + last_split = i + 1 + + # Rule: V-C-V -> Split after vowel (e.g., ba-ra) + elif len(rem) >= 2 and not is_vowel(rem[0]) and is_vowel(rem[1]): + syllables.append(word[last_split:i+1]) + last_split = i + 1 + + # Rule: V-C-C-V -> Split between consonants (e.g., mek-tep) + elif len(rem) >= 3 and not is_vowel(rem[0]) and not is_vowel(rem[1]) and is_vowel(rem[2]): + syllables.append(word[last_split:i+2]) + last_split = i + 2 + i += 1 # Skip first C + + # Rule: V-C-C-C-V (VCCCV) -> Split after second consonant (e.g., gert-mek) + # This fixes "gertmek", "eytqan", "partlap", "dostlar" + elif len(rem) >= 4 and not is_vowel(rem[0]) and not is_vowel(rem[1]) and not is_vowel(rem[2]) and is_vowel(rem[3]): + syllables.append(word[last_split:i+3]) + last_split = i + 3 + i += 2 # Skip first two Cs + i += 1 + + # Add the remaining part of the word + if last_split < len(word): + syllables.append(word[last_split:]) + + return syllables + + # Process word by word + words = text.split() + final_output = [] + + for w in words: + raw_syllables = split_word(w) + + # Handle Hemze (ئ) re-merging + processed = [] + skip_next = False + for j in range(len(raw_syllables)): + if skip_next: + skip_next = False + continue + + s = raw_syllables[j] + # If the current syllable is JUST "ئ" or ends in "ئ", merge it with next + if s == "ئ" and j + 1 < len(raw_syllables): + processed.append("ئ" + raw_syllables[j+1]) + skip_next = True + else: + processed.append(s) + final_output.extend(processed) + + return final_output + +# Verification +# test_words = ["گەرتمەك", "ئېيتقان", "دوستلار", "مەكتەپكە", ' كومپېيۇتېر تورى زادى قانداق نەرسىدۇ؟ '] +# for tw in test_words: +# print(f"{tw} -> {uighur_syllabize(tw.strip())}") + +# test_words = ['تەكلىپتەۋسىيەلىرىگە', 'تەكلىپ-تەۋسىيەلىرىگە'] +# for tw in test_words: +# print(f"{tw} -> {uighur_syllabize(tw.strip())}") + +# تەكلىپتەۋسىيەلىرىگە -> ['تەك', 'لىپ', 'تەۋ', 'سى', 'يە', 'لى', 'رى', 'گە'] +# تەكلىپ-تەۋسىيەلىرىگە -> ['تەك', 'لىپ-', 'تەۋ', 'سى', 'يە', 'لى', 'رى', 'گە'] + + + +text = " ھەر قانداق ئىشتا كىشىلەر بىلەن كېڭىشىش كېرەك. لېكىن كۆڭۈل تارتقان ئىشنى قىلىۋېرىش كېرەك." +text = "\" 15 يىل بۇرۇن مەن بىلەن سەي چۇڭشىن (ئالى بابانىڭ قۇرغۇچىسىدىن بىرى) ئامېرىكىغا بېرىپ 30 نەچچە مەبلەغ سالغۇچى شىركەتلەر بىلەن كۆرۈشكىنىمىزدە ئۇلار بىزنى رەت قىلىپ ئىشىك سىرتىدا قالدۇرغاندى. ھېچكىم بىزگە ۋە كەلگۈسىمىزگە ئىشەنمىگەن ئىدى، ھېچكىممۇ بىزنىڭ ھازىر 300 مىليارد سودىنى تاماملىيالايدىغانلىقىمىزنى ئويلاپ خىيالىغىمۇ كەلتۈرمىگەن ئىدى.\" ئالى بابانىنىڭ ئورگىنى تەرىپىدىن ئىشلەنگەن ئىگىلىك تىكلەش ھۆججەتلىك فىلىمى \" بۇ چۈش ئەمەس\" نىڭ باش قىسمىدا مۇنداق بىر داڭلىق سۆز چىقىدۇ:\" مەن تاغدىن ئۆتكەن ۋاقتىمدا تاغ ماڭا گەپ قىلمىدى، مەن دېڭىزنى كېچىپ ئۆتكىنىمدە دېڭىز ماڭا گەپ قىلمىدى.\" بۇ فىلىمنىڭ قوشۇمچە ئىسمى بولسا \" مايۈن ۋە ئۇنىڭ مەڭگۈلۈك ' ياش ئالى'سى\" بولۇپ، ھەرخىل خەتەر ۋە قىيىنلىقنى بىرمۇ بىر يەڭگەن مايۈن ۋە ئۇنىڭ ئالى بابا قوشۇنىدىكى ھەمكارلاشقۇچىلىرىنىڭ قەيسەر كەچمىشى جانلىق بايان قىلىنغان." +text = "يۆ جيەنتاۋ يېقىنقى بىر مەزگىلدە، خىزمەتداشلىرى بىلەن نۇرغۇن قىيىنچىلىققا ئۇچرىغان شوپۇرغا ياردەم قىلغانلىقىنى، شۇنداقلا يېمەكلىك ۋە سۇ يەتكۈزۈپ بەرگەنلىكىنى، ئەمما ئاياغ سوۋغا قىلىشى تۇنجى قېتىم ئىكەنلىكىنى، بۈگۈنكىسى 20 يىللىق ساقچىلىق جەريانىدا تۇنجى قېتىم شوپۇرغا ئاياغ سوۋغا قىلىشى ئىكەنلىكىنى ئېيتتى." +text = "يۆ جۇڭمىڭ مۇنداق دېدى: 2019- يىلى 12-ئايدا، مەملىكەتلىك خەلق قۇرۇلتىيى دائىمىي كومىتېتىنىڭ 44- قېتىملىق كومىتېت باشلىقلىرى يىغىنى مەملىكەتلىك خەلق قۇرۇلتىيى دائىمىي كومىتېتىنىڭ 2020-يىللىق قانۇن چىقىرىش خىزمىتى پىلانىنى پىرىنسىپ جەھەتتىن ماقۇللىدى، خىزمەت تەرتىپى بويىچە، 13-نۆۋەتلىك مەملىكەتلىك خەلق قۇرۇلتىيى 3-يىغىنىنىڭ روھى ۋە ۋەكىللەرنىڭ تەكلىپ-تەۋسىيەلىرىگە ئاساسەن پىلاننى تەڭشەش كېرەك. بۇ يىل 6-ئاينىڭ 1-كۈنى، 58-قېتىملىق كومىتېت باشلىقلىرى يىغىنى تەڭشەلگەندىن كېيىنكى يىللىق قانۇن چىقىرىش خىزمىتى پىلانىنى قاراپ چىقىپ ماقۇللىدى." +text = "مەن مەكتەپكە باردىم" + +# text = normalize_extended_uyghur_characters(text=text) +# print(clean_uyghur(text=text)) + +def process_text(text: str) -> list[str]: + text = clean_input_text(text=text) + result = [] + current_word_chars = [] + + for char in text: + if char in UYGHUR_LETTERS: + current_word_chars.append(char) + else: + # 遇到非字母字符，先处理缓存的单词 + if current_word_chars: + word = ''.join(current_word_chars) + result.extend(uighur_syllabize(word)) + current_word_chars.clear() + # 非字母字符直接加入 + result.append(char) + + # 处理末尾的单词 + if current_word_chars: + word = ''.join(current_word_chars) + result.extend(uighur_syllabize(word)) + + return result \ No newline at end of file diff --git a/src/handle/text_normalizer.py b/src/handle/text_normalizer.py new file mode 100644 index 0000000..bd6b356 --- /dev/null +++ b/src/handle/text_normalizer.py @@ -0,0 +1,126 @@ +UYGHUR_LETTERS = { + 'ا', 'ە', 'ب', 'پ', 'ت', 'ج', 'چ', 'خ', 'د', 'ر', 'ز', 'ژ', 'س', 'ش', 'غ', 'ف', + 'ق', 'ك', 'گ', 'ڭ', 'ل', 'م', 'ن', 'ھ', 'و', 'ۇ', 'ۆ', 'ۈ', 'ۋ', 'ې', 'ى', 'ي', + "ئ" +} + + +uyghur_symbols = { + "ھەرىپلەر": [ + 'ا', 'ە', 'ب', 'پ', 'ت', 'ج', 'چ', 'خ', 'د', 'ر', 'ز', 'ژ', 'س', 'ش', 'غ', 'ف', + 'ق', 'ك', 'گ', 'ڭ', 'ل', 'م', 'ن', 'ھ', 'و', 'ۇ', 'ۆ', 'ۈ', 'ۋ', 'ې', 'ى', 'ي', + "ئ" + ], + "تىنىش_بەلگىلىرى": [ + "۔", "،", "؟", "!", "-", "«", "»", "؛", ":", "'", "\"", "]", "[", " ", "›", "‹" + ], + "سانلار": [ + "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", + ], +} +english_symbols = { + "characters": [ + 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', + 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z' + ], + "symbols": [ + ".", "!", "?", "-", "<", ">", "=", "+", "*", "/", "|", "\\", "~", "_", "^", "@", "{", "}", "[", "]", "(", ")", "#", "%", "$", "€", "£", "¥", " " + ] +} + +# Export all symbols: +symbols_list = uyghur_symbols["ھەرىپلەر"] + uyghur_symbols["تىنىش_بەلگىلىرى"] + uyghur_symbols["سانلار"] + english_symbols["characters"] + english_symbols["symbols"] +symbols = {i: i for i in symbols_list} + + +def normalize_extended_uyghur_characters(text: str) -> str: + characters = [ + #["standard", "individual", "beginning", "middle", "end"] + ["ئ","ﺋ","ﺋ","ﺌ","ﺌ"], + ["ا","ﺍ","ﺍ","ﺎ","ﺎ"], + ["ە","ﻩ","ﻩ","ﻪ","ﻪ"], + ["ب","ﺏ","ﺑ","ﺒ","ﺐ"], + ["پ","ﭖ","ﭘ","ﭙ","ﭗ"], + ["ت","ﺕ","ﺗ","ﺘ","ﺖ"], + ["ج","ﺝ","ﺟ","ﺠ","ﺞ"], + ["چ","ﭺ","ﭼ","ﭽ","ﭻ"], + ["خ","ﺥ","ﺧ","ﺨ","ﺦ"], + ["د","ﺩ","ﺩ","ﺪ","ﺪ"], + ["ر","ﺭ","ﺭ","ﺮ","ﺮ"], + ["ز","ﺯ","ﺯ","ﺰ","ﺰ"], + ["ژ","ﮊ","ﮊ","ﮋ","ﮋ"], + ["س","ﺱ","ﺳ","ﺴ","ﺲ"], + ["ش","ﺵ","ﺷ","ﺸ","ﺶ"], + ["غ","ﻍ","ﻏ","ﻐ","ﻎ"], + ["ف","ﻑ","ﻓ","ﻔ","ﻒ"], + ["ق","ﻕ","ﻗ","ﻘ","ﻖ"], + ["ك","ﻙ","ﻛ","ﻜ","ﻚ"], + ["گ","ﮒ","ﮔ","ﮕ","ﮓ"], + ["ڭ","ﯓ","ﯕ","ﯖ","ﯔ"], + ["ل","ﻝ","ﻟ","ﻠ","ﻞ"], + ["م","ﻡ","ﻣ","ﻤ","ﻢ"], + ["ن","ﻥ","ﻧ","ﻨ","ﻦ"], + ["ھ","ﮪ","ﮬ","ﮭ","ﮫ"], + ["و","ﻭ","ﻭ","ﻮ","ﻮ"], + ["ۇ","ﯗ","ﯗ","ﯘ","ﯘ"], + ["ۆ","ﯙ","ﯙ","ﯚ","ﯚ"], + ["ۈ","ﯛ","ﯛ","ﯜ","ﯜ"], + ["ۋ","ﯞ","ﯞ","ﯟ","ﯟ"], + ["ې","ﯤ","ﯦ","ﯧ","ﯥ"], + ["ى","ﻯ","ﯨ","ﯩ","ﻰ"], + ["ي","ﻱ","ﻳ","ﻴ","ﻲ"], + ["ۅ","ﯠ","ﯠ","ﯡ","ﯡ"], + ["ۉ","ﯢ","ﯢ","ﯣ","ﯣ"], + ["ح","ﺡ","ﺣ","ﺤ","ﺢ"], + ["ع","ﻉ","ﻋ","ﻌ","ﻊ"] + ] + replacement_table: dict[str, str] = {} + #Create a replacement table. + for char_map in characters: + for char in char_map[1:]: + replacement_table[char] = char_map[0] + + replacement_table['ﻼ'] = "لا" #add some additional exceptional symbols + + text = text.replace('ئ', 'ئ') + clean = "" + #Replace the extended characters with their standard unicode ones. + for char in text: + if char in replacement_table: + char = replacement_table[char] + clean += char + + return clean + + +def is_uyghur_char(char: str) -> bool: + """判断是否是维吾尔语字母""" + return all(c in UYGHUR_LETTERS for c in char) + + +def is_uyghur_text(text: str) -> bool: + """清洗后检查是否全为维吾尔语""" + return all(c in symbols for c in text) + +def clean_unknown_symbols(text: str) -> str: + return ''.join(c for c in text if c in symbols) + +import re +def collapse_spaces(text: str) -> str: + return re.sub(r'\s+', ' ', text) + +def clean_english_text(text: str) -> str: + return re.sub(r'[a-zA-Z]', ' ', text) + +def clean_chinese_text(text: str) -> str: + return re.sub(r'[\u4e00-\u9fff]', ' ', text) + +def clean_http_links(text: str) -> str: + return re.sub(r'https?://[^\s]+', ' ', text) + +def clean_input_text(text: str) -> str: + text = collapse_spaces(text) + text = clean_http_links(text) + text = normalize_extended_uyghur_characters(text) + text = clean_unknown_symbols(text) + return text \ No newline at end of file diff --git a/src/inference.ipynb b/src/inference.ipynb new file mode 100644 index 0000000..b72ef1c --- /dev/null +++ b/src/inference.ipynb @@ -0,0 +1,580 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "f72992c5", + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import torchaudio\n", + "import librosa\n", + "import pyrubberband as pyrb\n", + "from torch import Tensor, no_grad, device\n", + "from torchaudio.transforms import FrequencyMasking, MelSpectrogram, AmplitudeToDB, Resample, TimeMasking, TimeStretch\n", + "from torch_audiomentations import Gain, PitchShift, LowPassFilter, HighPassFilter\n", + "from pathlib import Path\n", + "from librosa import effects\n", + "import torchaudio.functional as F\n", + "from IPython.display import Audio\n", + "import matplotlib.pyplot as plt\n", + "import random\n", + "from typing import TypedDict\n", + "\n", + "from tokenizer import ASRTokenizer\n", + "from model import ASRModel\n", + "\n", + "CONFIG = {\n", + " # 模型配置\n", + " 'input_dim': 256,\n", + " 'num_heads': 8,\n", + " 'ffn_dim': 2048,\n", + " 'num_layers': 8,\n", + " 'dropout': 0.1,\n", + "}\n", + "workspace_dir = Path.cwd().parent" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "15a9a926", + "metadata": {}, + "outputs": [], + "source": [ + "class AdvancedAugment:\n", + " def __init__(self, noise_folder=None):\n", + " # 如果你有噪音文件夹，可以预加载噪音路径列表\n", + " # 场景建议：1.汽车 2.餐厅 3.街道 4.办公室 5.下雨 6.风声 7.键盘声 8.婴儿哭声 9.音乐 10.走廊回声 11.白噪音 12.粉红噪音\n", + " self.noise_files = [] # 这里存放你的 .wav 噪音文件路径\n", + "\n", + " def _add_noise(self, waveform: Tensor) -> Tensor:\n", + " \"\"\"\n", + " 更丰富的加噪：随机选择 白噪音、粉红噪音 或 真实环境音\n", + " \"\"\"\n", + " # 1. 随机决定噪音类型\n", + " noise_type = random.choice(['white', 'pink', 'environmental'])\n", + " \n", + " # 2. 随机设定信噪比 (SNR) - 模拟各种清晰度\n", + " snr_db = random.uniform(5, 25) \n", + " \n", + " if noise_type == 'white':\n", + " noise = torch.randn_like(waveform)\n", + " elif noise_type == 'pink':\n", + " \n", + " noise = self._generate_pink_noise(waveform)\n", + " else:\n", + " # 模拟环境音 (如果你有噪音库)\n", + " # 这里演示如果没有噪音库，就用多种不同频率的随机噪音组合\n", + " noise = self._generate_simulated_env_noise(waveform)\n", + "\n", + " # 3. 计算能量并叠加\n", + " return self._mix_signal_noise(waveform, noise, snr_db)\n", + "\n", + " def _generate_pink_noise(self, waveform):\n", + " \"\"\"粉红噪音（比白噪音更像自然界的声音，低频能量更高）\"\"\"\n", + " # 简易实现：对白噪音做低通滤波\n", + " white = torch.randn_like(waveform)\n", + " return torch.cumsum(white, dim=-1) / 10.0 # 简单的积分近似\n", + "\n", + " def _generate_simulated_env_noise(self, waveform):\n", + " \"\"\"模拟环境噪音（通过叠加不同频率的波形）\"\"\"\n", + " # 模拟 12 种以上变化：随机叠加正弦波或窄带噪音\n", + " noise = torch.zeros_like(waveform)\n", + " for _ in range(random.randint(3, 8)):\n", + " freq = random.uniform(50, 4000)\n", + " t = torch.arange(waveform.shape[-1]).to(waveform.device)\n", + " noise += torch.sin(2 * 3.14159 * freq * t / 16000)\n", + " return noise + torch.randn_like(waveform) * 0.5\n", + "\n", + " def _mix_signal_noise(self, signal, noise, snr_db):\n", + " \"\"\"核心：根据 SNR 混合信号和噪音\"\"\"\n", + " s_p = signal.pow(2).mean()\n", + " n_p = noise.pow(2).mean()\n", + " \n", + " # 防止除以 0\n", + " if n_p == 0: return signal\n", + " \n", + " snr_linear = 10**(snr_db/10)\n", + " scale = torch.sqrt(s_p / (n_p * snr_linear))\n", + " \n", + " noisy = signal + scale * noise\n", + " return noisy / (noisy.abs().max() + 1e-7) # 归一化防止爆音\n", + "\n", + " def _simulate_reverb(self, waveform):\n", + " \"\"\"\n", + " 模拟走廊/房间回声 (Simple Reverb)\n", + " \"\"\"\n", + " # if random.random() < 0.3: # 30% 概率添加回声\n", + " # 模拟简单的延迟反馈（模拟大走廊）\n", + " delay_samples = random.randint(500, 2000) # 30ms - 125ms 延迟\n", + " decay = random.uniform(0.3, 0.6)\n", + " \n", + " reverb_signal = torch.zeros_like(waveform)\n", + " reverb_signal[:, delay_samples:] = waveform[:, :-delay_samples] * decay\n", + " return (waveform + reverb_signal) / (1 + decay)\n", + " return waveform\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c0635d68", + "metadata": {}, + "outputs": [], + "source": [ + "class NoiseAugmentor:\n", + " def __init__(self, noise_root: Path, sample_rate=16000):\n", + " self.sample_rate = sample_rate\n", + " # 递归找到目录下所有的 wav 文件\n", + " self.noise_files = list(Path(noise_root).rglob(\"*.wav\"))\n", + " print(f\"成功加载 {len(self.noise_files)} 个噪音文件\")\n", + "\n", + " def apply_real_noise(self, waveform: Tensor):\n", + " # 1. 随机选一个噪音文件\n", + " noise_path = random.choice(self.noise_files)\n", + " noise_waveform, sr = torchaudio.load_with_torchcodec(noise_path)\n", + " \n", + " # 2. 统一采样率\n", + " if sr != self.sample_rate:\n", + " resampler = Resample(sr, self.sample_rate)\n", + " noise_waveform = resampler(noise_waveform)\n", + " \n", + " # 3. 截取或填充，使其长度与语音一致\n", + " sig_len = waveform.shape[1]\n", + " noise_len = noise_waveform.shape[1]\n", + " \n", + " if noise_len >= sig_len:\n", + " # 随机截取一段\n", + " start = random.randint(0, noise_len - sig_len)\n", + " noise_waveform = noise_waveform[:, start:start + sig_len]\n", + " else:\n", + " full_noise = torch.zeros_like(waveform)\n", + " start = random.randint(0, sig_len - noise_len)\n", + " full_noise[:, start : start + noise_len] = noise_waveform\n", + " noise_waveform = full_noise\n", + " # 如果噪音太短，循环填充\n", + " # repeats = (sig_len // noise_len) + 1\n", + " # noise_waveform = noise_waveform.repeat(1, repeats)[:, :sig_len]\n", + " \n", + " # 4. 设定随机信噪比 SNR (5dB 到 20dB)\n", + " snr_db = random.uniform(5, 20)\n", + " \n", + " # 5. 混合\n", + " return self._mix_at_snr(waveform, noise_waveform, snr_db)\n", + "\n", + " def _mix_at_snr(self, signal: Tensor, noise: Tensor, snr_db: float):\n", + " s_p = signal.pow(2).mean()\n", + " n_p = noise.pow(2).mean()\n", + " snr_linear = 10**(snr_db / 10)\n", + " scale = torch.sqrt(s_p / (n_p * snr_linear + 1e-8))\n", + " \n", + " noisy = signal + scale * noise\n", + " # 归一化，防止溢出\n", + " return noisy / (noisy.abs().max() + 1e-8)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e77899f1", + "metadata": {}, + "outputs": [], + "source": [ + "class ASRInference:\n", + " def __init__(self, model_path: Path, vocab_path: Path, noise_dir: Path, device: device, augment: bool = True, augment_prob: float = 0.5) -> None:\n", + " self.device = device\n", + " self.augment: bool = augment\n", + " self.augment_prob: float = augment_prob\n", + " self.noise_augmentor = NoiseAugmentor(noise_root=noise_dir)\n", + " self.tokenizer = ASRTokenizer(vocab_path=vocab_path)\n", + " self.model = ASRModel(vocab_size=self.tokenizer.vocab_size(), **CONFIG).to(device=device)\n", + " self.model.load_state_dict(torch.load(model_path, map_location=device)['model_state_dict'])\n", + " self.model.eval()\n", + "\n", + " print(f\"params params: {self.model.get_num_params():,}\",)\n", + "\n", + " self.sample_rate = 16000\n", + "\n", + " # self.gain_up = Gain(min_gain_in_db=5, max_gain_in_db=10, p=1.0, output_type='tensor')\n", + " # self.gain_down = Gain(min_gain_in_db=-20, max_gain_in_db=-10, p=1.0, output_type='tensor')\n", + " # self.pitch_up = PitchShift(min_transpose_semitones=3, max_transpose_semitones=5, p=1.0, sample_rate=self.sample_rate, output_type='tensor')\n", + " # self.pitch_down = PitchShift(min_transpose_semitones=-5, max_transpose_semitones=-3, p=1.0, sample_rate=self.sample_rate, output_type='tensor')\n", + " # self.lowpass = LowPassFilter(min_cutoff_freq=400, max_cutoff_freq=2400, p=1.0, output_type='tensor')\n", + " # self.highpass = HighPassFilter(min_cutoff_freq=1400, max_cutoff_freq=3400, p=1.0, output_type='tensor')\n", + "\n", + " self.gain_up = Gain(min_gain_in_db=4, max_gain_in_db=8, p=1.0, output_type='tensor')\n", + " self.gain_down = Gain(min_gain_in_db=-15, max_gain_in_db=-8, p=1.0, output_type='tensor')\n", + " self.pitch_up = PitchShift(min_transpose_semitones=1, max_transpose_semitones=4, p=1.0, sample_rate=self.sample_rate, output_type='tensor')\n", + " self.pitch_down = PitchShift(min_transpose_semitones=-4, max_transpose_semitones=-1, p=1.0, sample_rate=self.sample_rate, output_type='tensor')\n", + " self.lowpass = LowPassFilter(min_cutoff_freq=600, max_cutoff_freq=2000, p=1.0, output_type='tensor')\n", + " self.highpass = HighPassFilter(min_cutoff_freq=800, max_cutoff_freq=2000, p=1.0, output_type='tensor')\n", + " \n", + " def _load_audio(self, audio_path: Path) -> Tensor:\n", + " waveform, sample_rate = torchaudio.load_with_torchcodec(audio_path)\n", + "\n", + " if sample_rate != self.sample_rate:\n", + " waveform = Resample(sample_rate, self.sample_rate)(waveform)\n", + "\n", + " if waveform.shape[0] > 1:\n", + " waveform = waveform.mean(dim=0, keepdim=True)\n", + "\n", + " waveform = waveform / (waveform.abs().max() + 1e-8)\n", + " return waveform\n", + " \n", + " def augment_waveform(self, waveform: Tensor) -> Tensor:\n", + " # if not self.augment or random.random() > self.augment_prob:\n", + " # return waveform\n", + " \n", + " # 1. voice Stretch/Compress \n", + " if random.random() < 0.5:\n", + " waveform = self._voice_stretch_or_compress(waveform=waveform)\n", + "\n", + " if random.random() < 0.4:\n", + " waveform = self.noise_augmentor.apply_real_noise(waveform)\n", + "\n", + " if random.random() < 0.3:\n", + " waveform = self._time_mask_waveform(waveform=waveform)\n", + " \n", + " # torch_audiomentations: [1, time] -> [1, 1, time]\n", + " if waveform.dim() == 2:\n", + " waveform_3d = waveform.unsqueeze(0)\n", + " # 随机选择一种频谱增强\n", + " choice = random.random()\n", + " if choice < 0.15:\n", + " # 增益变化（上或下）\n", + " if random.random() < 0.5:\n", + " waveform_3d = self.gain_up(waveform_3d, sample_rate=self.sample_rate)\n", + " else:\n", + " waveform_3d = self.gain_down(waveform_3d, sample_rate=self.sample_rate)\n", + " elif choice < 0.25:\n", + " # 音高变化（上或下）\n", + " if random.random() < 0.5:\n", + " waveform_3d = self.pitch_up(waveform_3d, sample_rate=self.sample_rate)\n", + " else:\n", + " waveform_3d = self.pitch_down(waveform_3d, sample_rate=self.sample_rate)\n", + " elif choice < 0.30:\n", + " # 低通滤波（声音发闷）\n", + " waveform_3d = self.lowpass(waveform_3d, sample_rate=self.sample_rate)\n", + " elif choice < 0.35:\n", + " # 高通滤波（电话效果）\n", + " waveform_3d = self.highpass(waveform_3d, sample_rate=self.sample_rate)\n", + " \n", + " # [1, 1, time] -> [1, time]\n", + " waveform = waveform_3d.squeeze(0)\n", + " \n", + " # 防止多次 augment 后振幅溢出，最后归一化\n", + " max_amp = waveform.abs().max()\n", + " if max_amp > 1.0:\n", + " print(max_amp)\n", + " waveform = waveform / max_amp\n", + " \n", + " return waveform\n", + " \n", + " def _voice_stretch_or_compress1(self, waveform: Tensor) -> Tensor:\n", + " speed_factor = random.uniform(0.8, 1.4) # (Speed Change: 0.6x - 1.4x)\n", + " waveform_np = waveform.squeeze(0).cpu().numpy()\n", + " y_stretch = librosa.effects.time_stretch(waveform_np, rate=speed_factor)\n", + " waveform = torch.from_numpy(y_stretch).float().to(waveform.device).unsqueeze(0)\n", + " return waveform\n", + " \n", + " def _voice_stretch_or_compress(self, waveform: Tensor) -> Tensor:\n", + " speed_factor = random.uniform(0.8, 1.25) # (Speed Change: 0.6x - 1.2x)\n", + " spec = torch.stft(\n", + " waveform.squeeze(0),\n", + " n_fft=400,\n", + " hop_length=160,\n", + " window=torch.hann_window(400).to(waveform.device),\n", + " return_complex=True\n", + " )\n", + " \n", + " # 时间拉伸（不改变音高）\n", + " stretch = TimeStretch(hop_length=160, n_freq=spec.shape[-2], fixed_rate=1.4)\n", + " stretched_spec = stretch(spec)\n", + " \n", + " # 转回波形\n", + " waveform_stretched = torch.istft(\n", + " stretched_spec,\n", + " n_fft=400,\n", + " hop_length=160,\n", + " window=torch.hann_window(400).to(waveform.device)\n", + " ).unsqueeze(0)\n", + " \n", + " return waveform_stretched\n", + "\n", + " def _voice_stretch_or_compress2(self, waveform: Tensor) -> Tensor:\n", + " speed_factor = random.uniform(0.6, 1.4) # (Speed Change: 0.6x - 1.4x)\n", + " waveform_np = waveform.squeeze(0).cpu().numpy()\n", + " y_stretch = pyrb.time_stretch(waveform_np, self.sample_rate, speed_factor)\n", + " return torch.from_numpy(y_stretch).float().to(waveform.device).unsqueeze(0)\n", + " \n", + " def _time_mask_waveform(self, waveform: Tensor) -> Tensor:\n", + " audio_len = waveform.shape[1]\n", + " sr = self.sample_rate # 16000\n", + " \n", + " # 设置参数：单次遮盖最长 0.4 秒 (6400个点)\n", + " max_mask_time = 0.4\n", + " max_mask_samples = int(sr * max_mask_time)\n", + " \n", + " # 根据音频长度决定遮盖次数：\n", + " # 比如每 3 秒钟允许遮盖 1 次\n", + " num_masks = max(1, audio_len // (sr * 3)) \n", + " \n", + " for _ in range(num_masks):\n", + " # 每次随机遮盖 0.1s 到 0.4s\n", + " current_mask_len = random.randint(int(sr * 0.1), max_mask_samples)\n", + " \n", + " if audio_len > current_mask_len:\n", + " start_pos = random.randint(0, audio_len - current_mask_len)\n", + " \n", + " # 填充微小噪音（模拟环境底噪）\n", + " noise = torch.randn(1, current_mask_len).to(waveform.device) * 0.002\n", + " waveform[:, start_pos : start_pos + current_mask_len] = noise\n", + " \n", + " return waveform\n", + "\n", + " def transcribe(self, waveform: Tensor) -> str:\n", + " waveform = waveform.to(device=self.device)\n", + " waveform_length = torch.tensor([waveform.shape[1]], dtype=torch.long, device=self.device)\n", + "\n", + " with no_grad():\n", + " log_probs, _ = self.model(waveforms=waveform, waveform_lengths=waveform_length)\n", + " \n", + " text = self.tokenizer.ctc_greedy_decode(log_probs=log_probs[0])\n", + " return text" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5af7c836", + "metadata": {}, + "outputs": [], + "source": [ + "device = torch.device('cuda:1')\n", + "\n", + "# checkpoint = sorted(workspace_dir.glob('.checkpoints/checkpoint_epoch_*.pt'), key=lambda p: int(p.stem.split('_')[-1]))[-1]\n", + "checkpoint = workspace_dir / \".checkpoints/best_wer_model.pt\"\n", + "# checkpoint = workspace_dir / \".checkpoints/best_cer_model.pt\"\n", + "checkpoint = workspace_dir / \".checkpoints/prodect/checkpoint_epoch_24 copy.pt\"\n", + "print(f\"Load Checkpoint: {checkpoint}\")\n", + "inference = ASRInference(model_path=checkpoint, vocab_path=workspace_dir / 'config/asr_vocab.json', noise_dir='/mnt/dataset/dataset/audio/noise', device=device)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "967e23cb", + "metadata": {}, + "outputs": [], + "source": [ + "# audio_path = workspace_dir / '.data/ug/clips/common_voice_ug_42681424.mp3'\n", + "# audio_path = workspace_dir / '.data/ug/clips/common_voice_ug_26188445.mp3'\n", + "# audio_path = workspace_dir / '.data/ug/clips/common_voice_ug_43349581.mp3'\n", + "# audio_path = workspace_dir / '.data/ug/clips/common_voice_ug_42640878.mp3'\n", + "# audio_path = workspace_dir / '.data/ug/clips/common_voice_ug_26245615.mp3'\n", + "# audio_path = workspace_dir / '.data/ug/clips/common_voice_ug_40794549.mp3'\n", + "# audio_path = workspace_dir / 'data/ug/clips/common_voice_ug_26245614.mp3'\n", + "audio_path = '/mnt/train/audio/Dilnaz/only_vocals/3272800876_100006098_(vocals)_melband_roformer_big_beta5e.m4a'\n", + "# audio_path = workspace_dir / 'data/test/how_are_you.mp3'\n", + "# audio_path = workspace_dir / 'data/test/split_1.m4a'\n", + "# audio_path = workspace_dir / 'data/test/let_me_see_the_computer.mp3'\n", + "# audio_path = workspace_dir / 'data/test/introduce_myself.mp3'\n", + "# audio_path = workspace_dir / 'data/test/F001_001.wav'\n", + "# audio_path = workspace_dir / 'data/test/download.wav'\n", + "# audio_path = workspace_dir / 'data/test/test_voise_1.m4a'\n", + "orginal_waveform = inference._load_audio(audio_path=audio_path)\n", + "print('load audio:', orginal_waveform.shape)\n", + "# orginal_waveform = orginal_waveform[:, :]\n", + "\n", + "def simple_corridor_echo(waveform, sample_rate=16000, delay_ms=80, decay=0.3):\n", + " \"\"\"\n", + " 模拟一次明显的走廊回声：原始声音 + 一个衰减延迟的拷贝\n", + " delay_ms: 延迟毫秒数，80ms 模拟中等走廊\n", + " decay: 回声的衰减系数，0.2~0.4 比较自然\n", + " \"\"\"\n", + " delay_samples = int(sample_rate * delay_ms / 1000)\n", + " echo = torch.zeros_like(waveform)\n", + " echo[..., delay_samples:] = waveform[..., :-delay_samples] * decay\n", + " return waveform + echo\n", + "\n", + "print(\"Orginal audio\")\n", + "display(Audio(orginal_waveform, rate=inference.sample_rate))\n", + "\n", + "# augment_waveform = inference.augment_waveform(waveform=orginal_waveform)\n", + "# augment_waveform = simple_corridor_echo(waveform=orginal_waveform)\n", + "# augment_waveform = inference._voice_stretch_or_compress(waveform=orginal_waveform)\n", + "# noise_augmentor_waveform = inference.noise_augmentor.apply_real_noise(waveform=orginal_waveform)\n", + "# display(Audio(augment_waveform, rate=inference.sample_rate))\n", + "# text = inference.transcribe(waveform=orginal_waveform)\n", + "# print(f\"\\n{text}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "16195280", + "metadata": {}, + "outputs": [], + "source": [ + "from silero_vad import load_silero_vad, read_audio, get_speech_timestamps\n", + "class TimestampsType(TypedDict):\n", + " start: int\n", + " end: int\n", + "\n", + "THRESHOLD_MS = 2000\n", + "SAMPLE_RATE = inference.sample_rate\n", + "\n", + "def merge_timestamps(timestamps: int, threshold_ms: int, sample_rate: int):\n", + " if not timestamps:\n", + " return []\n", + " threshold_samples = (threshold_ms / 1000) * sample_rate\n", + " merged = []\n", + " curr_start = timestamps[0]['start']\n", + " curr_end = timestamps[0]['end']\n", + " \n", + " for i in range(1, len(timestamps)):\n", + " # 如果当前积攒的长度不到 2 秒，就一直合并到当前的 end 上\n", + " if (curr_end - curr_start) < threshold_samples:\n", + " curr_end = timestamps[i]['end']\n", + " else:\n", + " merged.append({'start': curr_start, 'end': curr_end})\n", + " curr_start = timestamps[i]['start']\n", + " curr_end = timestamps[i]['end']\n", + " merged.append({'start': curr_start, 'end': curr_end})\n", + " return merged\n", + "\n", + "vad_model = load_silero_vad(onnx=False)\n", + "waveform_vad = inference._load_audio(audio_path=audio_path)\n", + "speech_timestamps: list[TimestampsType] = get_speech_timestamps(\n", + " waveform_vad, \n", + " vad_model, \n", + " sampling_rate=inference.sample_rate,\n", + " threshold=0.4, # 可以根据需要调整阈值\n", + " min_speech_duration_ms=100, # 最小语音持续时间，防止短噪音被误判\n", + " min_silence_duration_ms=200, # 最小静音间隔，用于分割语音块\n", + " speech_pad_ms=100, # 在语音块前后添加的填充时间\n", + ")\n", + "print('speech_timestamps:', speech_timestamps)\n", + "print('speech_timestamps:', len(speech_timestamps))\n", + "final_timestamps = merge_timestamps(speech_timestamps, THRESHOLD_MS, SAMPLE_RATE)\n", + "print(f'VAD原始片段: {len(speech_timestamps)} -> 合并后片段: {len(final_timestamps)}')\n", + "for ts in final_timestamps:\n", + " ts: TimestampsType\n", + " start_sample = int(ts['start'])\n", + " end_sample = int(ts['end'])\n", + "\n", + " segment_waveform = waveform_vad[:, start_sample:end_sample]\n", + " display(Audio(segment_waveform, rate=inference.sample_rate))\n", + "\n", + " segment_text = inference.transcribe(waveform=segment_waveform)\n", + " print(segment_text, end=\" \", flush=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3671d334", + "metadata": {}, + "outputs": [], + "source": [ + "# mel_spec = inference._extract_features(waveform=orginal_waveform)\n", + "# ################################\n", + "# from PIL import Image, ImageFilter\n", + "# import numpy as np\n", + "# import math\n", + "\n", + "# img = (mel_spec.numpy())\n", + "# print(img.max(), img.min())\n", + "# img = img + np.abs(img.min())\n", + "# img = img / img.max()\n", + "# print(img.max(), img.min())\n", + "# img = Image.fromarray((img * 255).astype(np.uint8))\n", + "# shapened = img.filter(ImageFilter.UnsharpMask(radius=1, percent=150, threshold=3))\n", + "# img.save(\"original_hd.jpg\")\n", + "# # img.save(\"sharpen_hd.jpg\")\n", + "\n", + "# fig, axes = plt.subplots(2, 1, figsize=(30, 12))\n", + "\n", + "# axes[0].imshow(\n", + "# img,\n", + "# cmap=\"gray\",\n", + "# origin=\"lower\",\n", + "# vmin=0,\n", + "# vmax=255,\n", + "# aspect=\"auto\"\n", + "# )\n", + "# axes[0].set_title(\"Original\")\n", + "# axes[1].imshow(\n", + "# shapened,\n", + "# cmap=\"gray\",\n", + "# origin=\"lower\",\n", + "# vmin=0,\n", + "# vmax=255,\n", + "# aspect=\"auto\"\n", + "# )\n", + "# axes[1].set_title(\"Sharpened\")\n", + "# plt.tight_layout()\n", + "# plt.show()\n", + "\n", + "# ################################\n", + "# mel_spec = inference._augment_spec(mel_spec=mel_spec)\n", + "# print(mel_spec.shape)\n", + "# mel_spec = mel_spec.unsqueeze(0)\n", + "# print(mel_spec.shape)\n", + "# # 创建可视化\n", + "# fig, axes = plt.subplots(2, 1, figsize=(18, 12))\n", + "\n", + "# # 原始波形\n", + "# axes[0].plot(orginal_waveform[0].numpy())\n", + "# axes[0].set_title(\"Original waveform\")\n", + "# axes[0].set_xlabel(\"sample\")\n", + "# axes[0].set_ylabel(\"Amplitude\")\n", + "# axes[0].grid(True)\n", + "\n", + "# # Mel 频谱图\n", + "# im = axes[1].imshow(\n", + "# mel_spec[0].numpy(),\n", + "# cmap='gray',\n", + "# aspect='auto',\n", + "# origin='lower',\n", + "# # vmin=-150,\n", + "# # vmax=1,\n", + "# extent=[0, orginal_waveform.shape[-1] / inference.sample_rate, 0, 80]\n", + "# )\n", + "# axes[1].set_title(\"Log Mel Spectrogram\")\n", + "# axes[1].set_xlabel(\"Time (second)\")\n", + "# axes[1].set_ylabel(\"Mels\")\n", + "# # plt.colorbar(im, ax=axes[1], format='%+2.0f dB')\n", + "\n", + "# plt.tight_layout()\n", + "# plt.show()\n", + "\n", + "\n", + "# print(f\"Mel 频谱图形状: {mel_spec.shape}\") # (channel, n_mels, time_frames)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "study-asr (3.11.12)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/inference.py b/src/inference.py new file mode 100644 index 0000000..160700e --- /dev/null +++ b/src/inference.py @@ -0,0 +1,123 @@ +import torch +import torchaudio +from torch import Tensor, no_grad, device +from torchaudio.transforms import Resample +from pathlib import Path +from typing import TypedDict +from silero_vad import load_silero_vad, get_speech_timestamps +from tokenizer import ASRTokenizer +from model import ASRModel + +CONFIG = { + # 模型配置 + 'input_dim': 256, + 'num_heads': 8, + 'ffn_dim': 2048, + 'num_layers': 8, + 'dropout': 0.1, +} + +class TimestampsType(TypedDict): + start: int + end: int + +class ASRInference: + def __init__(self, model_path: Path, vocab_path: Path, device: device, sample_rate: int = 16000) -> None: + self.device = device + self.sample_rate = sample_rate + self.tokenizer = ASRTokenizer(vocab_path=vocab_path) + self.model = ASRModel(vocab_size=self.tokenizer.vocab_size(), **CONFIG).to(device=device) + self.model.load_state_dict(torch.load(model_path, map_location=device)['model_state_dict']) + self.model.eval() + + print(f"params params: {self.model.get_num_params():,}",) + + def _load_audio(self, audio_path: Path) -> Tensor: + waveform, sample_rate = torchaudio.load_with_torchcodec(audio_path) + + if sample_rate != self.sample_rate: + waveform = Resample(sample_rate, self.sample_rate)(waveform) + + if waveform.shape[0] > 1: + waveform = waveform.mean(dim=0, keepdim=True) + + waveform = waveform / (waveform.abs().max() + 1e-8) + return waveform + + def transcribe(self, waveform: Tensor) -> str: + waveform = waveform.to(device=self.device) # [1, time] + waveform_length = torch.tensor([waveform.shape[1]], dtype=torch.long, device=self.device) + + with no_grad(): + log_probs, _ = self.model(waveforms=waveform, waveform_lengths=waveform_length) # [1, T, vocab] + + text = self.tokenizer.ctc_greedy_decode(log_probs=log_probs[0]) + return text + + def transcribe_batch(self, audio_paths: list[Path]) -> list[str]: + results = [] + + for audio_path in audio_paths: + text = self.transcribe(audio_path=audio_path) + results.append(text) + + return results + + def create(self, audio_path: Path, threshold_ms: int = 20000): + def merge_timestamps(timestamps: int, threshold_ms: int, sample_rate: int): + if not timestamps: + return [] + threshold_samples = (threshold_ms / 1000) * sample_rate + merged = [] + curr_start = timestamps[0]['start'] + curr_end = timestamps[0]['end'] + + for i in range(1, len(timestamps)): + # 如果当前积攒的长度不到 2 秒，就一直合并到当前的 end 上 + if (curr_end - curr_start) < threshold_samples: + curr_end = timestamps[i]['end'] + else: + merged.append({'start': curr_start, 'end': curr_end}) + curr_start = timestamps[i]['start'] + curr_end = timestamps[i]['end'] + merged.append({'start': curr_start, 'end': curr_end}) + return merged + + vad_model = load_silero_vad(onnx=False) + waveform = self._load_audio(audio_path=audio_path) + speech_timestamps: list[TimestampsType] = get_speech_timestamps( + waveform, + vad_model, + sampling_rate=self.sample_rate, + threshold=0.5, # 可以根据需要调整阈值 + min_speech_duration_ms=100, # 最小语音持续时间，防止短噪音被误判 + min_silence_duration_ms=200, # 最小静音间隔，用于分割语音块 + speech_pad_ms=100, # 在语音块前后添加的填充时间 + ) + final_timestamps = merge_timestamps(timestamps=speech_timestamps, threshold_ms=threshold_ms, sample_rate=self.sample_rate) + for ts in final_timestamps: + ts: TimestampsType + start_sample = int(ts['start']) + end_sample = int(ts['end']) + + segment_waveform = waveform[:, start_sample:end_sample] + + segment_text = self.transcribe(waveform=segment_waveform) + print(segment_text, end=" ", flush=True) + print('\n') + +def main(): + workspace_dir = Path(__file__).parent.parent + device = torch.device('cuda:1') + + checkpoint = workspace_dir / ".checkpoints/best_wer_model.pt" + inference = ASRInference(model_path=checkpoint, vocab_path=workspace_dir / 'config/asr_vocab.json' , device=device) + + audio_path = workspace_dir / 'data/test/F001_001.wav' + waveform = inference._load_audio(audio_path=audio_path) + text = inference.transcribe(waveform=waveform) + print("transcribe:", text) + inference.create(audio_path=audio_path) + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/src/model.py b/src/model.py new file mode 100644 index 0000000..e339fdd --- /dev/null +++ b/src/model.py @@ -0,0 +1,84 @@ +from torch.nn import Module, Linear, functional, GELU, Conv1d, GroupNorm, ModuleList +from torch import Tensor +from torchaudio.models import Conformer + +class WaveformFilter(Module): + def __init__(self): + super().__init__() + + self.filters = ModuleList([ + Conv1d(in_channels=1, out_channels=512, kernel_size=10, stride=5), + GroupNorm(num_channels=512, num_groups=32), + GELU(), + Conv1d(in_channels=512, out_channels=512, kernel_size=3, stride=2), + GroupNorm(num_channels=512, num_groups=32), + GELU(), + Conv1d(in_channels=512, out_channels=512, kernel_size=3, stride=2), + GroupNorm(num_channels=512, num_groups=32), + GELU(), + Conv1d(in_channels=512, out_channels=512, kernel_size=3, stride=2), + GroupNorm(num_channels=512, num_groups=32), + GELU(), + Conv1d(in_channels=512, out_channels=512, kernel_size=3, stride=2), + GroupNorm(num_channels=512, num_groups=32), + GELU(), + Conv1d(in_channels=512, out_channels=512, kernel_size=2, stride=2), + GroupNorm(num_channels=512, num_groups=32), + GELU(), + Conv1d(in_channels=512, out_channels=512, kernel_size=2, stride=2), + GroupNorm(num_channels=512, num_groups=32), + GELU(), + ]) + + def compute_lengths(self, waveform_lengths: Tensor) -> Tensor: + """Accurately compute output lengths after all convolutions.""" + lengths = waveform_lengths + for module in self.filters: + if isinstance(module, Conv1d): + # Conv1d with padding=0, dilation=1: + # output = floor((input - kernel_size) / stride) + 1 + lengths = (lengths - module.kernel_size[0]) // module.stride[0] + 1 + return lengths + + def forward(self, x: Tensor) -> Tensor: + for filter in self.filters: + x = filter(x) + + return x + + +class ASRModel(Module): + def __init__(self, vocab_size: int, input_dim: int = 256, num_heads: int = 8, ffn_dim: int = 2048, num_layers: int = 6, dropout: float = 0.1) -> None: + super().__init__() + + self.feature_extractor = WaveformFilter() + self.proj = Linear(in_features=512, out_features=input_dim, bias=False) + + self.encoder = Conformer(input_dim=input_dim, num_heads=num_heads, ffn_dim=ffn_dim, num_layers=num_layers, depthwise_conv_kernel_size=31, dropout=dropout) + + self.ctc_head = Linear(in_features=input_dim, out_features=vocab_size, bias=False) + + def forward(self, waveforms: Tensor, waveform_lengths: Tensor) -> tuple[Tensor, Tensor]: + assert len(waveform_lengths.shape) == 1, "The waveform_lengths tensor must be shape of [B] tensor." + assert len(waveforms.shape) == 2, "The waveform tensor must be [B, time] tensor" + # waveforms: [B, time] + x: Tensor = waveforms.unsqueeze(1) # [B, 1, time] + #x: [B, 1, time] + x: Tensor = self.feature_extractor(x) + #x: [B, 512, time] + x = x.permute(0, 2, 1) + #x: [B, time, 512] + x = self.proj(x) + #x: [B, time, 256] + # lengths = torch.tensor([time] * batch, dtype=torch.long, device=x.device) + lengths = self.feature_extractor.compute_lengths(waveform_lengths) + + x, lengths = self.encoder(x, lengths) + + logits = self.ctc_head(x) # [B, time, vocab_size] + log_probs = functional.log_softmax(logits, dim=-1) + + return log_probs, lengths + + def get_num_params(self) -> int: + return sum(p.numel() for p in self.parameters()) \ No newline at end of file diff --git a/src/tokenizer.py b/src/tokenizer.py new file mode 100644 index 0000000..5159bc2 --- /dev/null +++ b/src/tokenizer.py @@ -0,0 +1,107 @@ +import json +from pathlib import Path +import re +import torch +from torch import Tensor + +from handle.text_handle import process_text +from handle.text_normalizer import UYGHUR_LETTERS + +class ASRTokenizer: + def __init__(self, vocab_path: Path) -> None: + self.vocabs: list[str] = [] + self.vocabs.extend([ + "", + "", + "" + ]) + for i in range(len(self.vocabs), 64): + self.vocabs.append(f"REVERSED_{i}") + + with open(vocab_path, 'r', encoding='utf-8') as file: + data: list[str] = json.load(file) + + for char in data: + if char not in [' ', '\t', '\n'] and char not in self.vocabs: + self.vocabs.append(char) + + self.vocab_to_id: dict[str, int] = {vocab:i for i, vocab in enumerate(self.vocabs)} + self.id_to_vocab: dict[int, str] = {i:vocab for i, vocab in enumerate(self.vocabs)} + + self._max_token_len = max((len(v) for v in self.vocabs if not v.startswith("<")), default=0) + + def vocab_size(self): + return len(self.vocabs) + + def _split_long_syllable(self, syll: str) -> list[str]: + """将不在词表中的长音节拆分为词表内的子词序列（最大正向匹配）""" + pieces = [] + start = 0 + n = len(syll) + while start < n: + # 从最大可能长度开始尝试匹配 + for length in range(min(self._max_token_len, n - start), 0, -1): + sub = syll[start:start + length] + if sub in self.vocab_to_id: + pieces.append(sub) + start += length + break + else: + # 理论上不会发生，因为单字母一定在词表 + pieces.append("") + start += 1 + return pieces + + def encode(self, text: str) -> list[int]: + tokens = process_text(text=text) + result: list[int] = [] + + for token in tokens: + if token == ' ': + result.append(self.vocab_to_id['']) + else: + token_id = self.vocab_to_id.get(token) + if token_id is not None: + result.append(token_id) + elif token in UYGHUR_LETTERS: + result.append(self.vocab_to_id.get(token, self.vocab_to_id[''])) + else: + sub_pieces = self._split_long_syllable(token) + for piece in sub_pieces: + result.append(self.vocab_to_id.get(piece, self.vocab_to_id[''])) + + return result + + def decode(self, ids: list[int] | Tensor, remove_blank: bool = True, remove_repeat: bool = True) -> str: + if isinstance(ids, Tensor): + ids = ids.tolist() + + result = [] + prev_id = None + + for token_id in ids: + # 跳过blank token + if remove_blank and token_id == self.vocab_to_id['']: + prev_id = None + continue + + # CTC解码：跳过连续重复的字符 + if remove_repeat and token_id == prev_id: + continue + + char = self.id_to_vocab.get(token_id, "") + + if char == '': + char = ' ' + + result.append(char) + prev_id = token_id + + return ''.join(result) + + def get_special_token_id(self, token: str) -> int: + return self.vocab_to_id.get(token, self.vocab_to_id['']) + + def ctc_greedy_decode(self, log_probs: Tensor) -> str: + """ CTC贪心解码 (log_probs: [seq_len, vocab_size] 的log概率) """ + return self.decode(torch.argmax(log_probs, dim=-1)) \ No newline at end of file diff --git a/src/train.py b/src/train.py new file mode 100644 index 0000000..68ffa01 --- /dev/null +++ b/src/train.py @@ -0,0 +1,367 @@ +import math + +import torch +from torch import Tensor, device, no_grad, cuda +from torch.optim import AdamW, Optimizer +from torch.optim.lr_scheduler import OneCycleLR +from torch.nn import CTCLoss, utils +from torch.utils.data import DataLoader +from torch.utils.tensorboard import SummaryWriter +from pathlib import Path +from tqdm import tqdm +from datetime import datetime +from torch.amp.grad_scaler import GradScaler +from tokenizer import ASRTokenizer +from dataset import Batch, create_dataloader +from model import ASRModel + + +# ============ 全局配置 ============ +CONFIG = { + # 数据配置 + 'batch_size': 32, + + # 训练配置 + 'num_epochs': 50, + 'learning_rate': 2e-4, + 'weight_decay': 1e-4, + 'grad_clip_norm': 1.0, + + # 模型配置 + 'input_dim': 256, + 'num_heads': 8, + 'ffn_dim': 2048, + 'num_layers': 8, + 'dropout': 0.1, + + # 保存和评估 + 'early_stopping_patience': 12, +} + + +def calculate_cer(pred: str, target: str) -> float: + """ 计算字符错误率 (Character Error Rate) 使用编辑距离算法""" + if len(target) == 0: + return 0.0 if len(pred) == 0 else 1.0 + + d = [[0] * (len(target) + 1) for _ in range(len(pred) + 1)] + + for i in range(len(pred) + 1): + d[i][0] = i + for j in range(len(target) + 1): + d[0][j] = j + + for i in range(1, len(pred) + 1): + for j in range(1, len(target) + 1): + if pred[i-1] == target[j-1]: + d[i][j] = d[i-1][j-1] + else: + d[i][j] = min(d[i-1][j], d[i][j-1], d[i-1][j-1]) + 1 + + return d[len(pred)][len(target)] / len(target) + + +def calculate_wer(pred: str, target: str) -> float: + """ 计算词错误率 (Word Error Rate) """ + pred_words = pred.split() + target_words = target.split() + + if len(target_words) == 0: + return 0.0 if len(pred_words) == 0 else 1.0 + + d = [[0] * (len(target_words) + 1) for _ in range(len(pred_words) + 1)] + + for i in range(len(pred_words) + 1): + d[i][0] = i + for j in range(len(target_words) + 1): + d[0][j] = j + + for i in range(1, len(pred_words) + 1): + for j in range(1, len(target_words) + 1): + if pred_words[i-1] == target_words[j-1]: + d[i][j] = d[i-1][j-1] + else: + d[i][j] = min(d[i-1][j], d[i][j-1], d[i-1][j-1]) + 1 + + return d[len(pred_words)][len(target_words)] / len(target_words) + +def train_one_epoch(model: ASRModel, dataloader: DataLoader, criterion: CTCLoss, optimizer: Optimizer, scheduler: OneCycleLR, device: device, epoch: int, writer: SummaryWriter, global_step: int, scaler: GradScaler) -> tuple[float, int]: + model.train() + num_batches = 0 + total_train_loss = 0 + + progress_bar = tqdm(dataloader, desc=f"Epoch {epoch}") + for batch_index, batch in enumerate(progress_bar): + batch: Batch + waveforms = batch['waveforms'].to(device) + targets = batch['targets'].to(device) + waveform_lengths = batch['waveform_lengths'].to(device) + target_lengths = batch['target_lengths'].to(device) + + optimizer.zero_grad() + + with torch.autocast(device_type='cuda', dtype=torch.bfloat16): + log_probs, lengths = model(waveforms=waveforms, waveform_lengths=waveform_lengths) + log_probs: Tensor + log_probs_ctc = log_probs.permute(1, 0, 2) + loss: Tensor = criterion(log_probs=log_probs_ctc, targets=targets, input_lengths=lengths, target_lengths=target_lengths) + + scaler.scale(loss).backward() + scaler.unscale_(optimizer) + utils.clip_grad_norm_(model.parameters(), max_norm=CONFIG['grad_clip_norm']) + scaler.step(optimizer) + scaler.update() + scheduler.step() + + total_train_loss += loss.item() + num_batches += 1 + global_step += 1 + + writer.add_scalar('Train/Loss', loss.item(), global_step) + writer.add_scalar('Train/LearningRate', optimizer.param_groups[0]['lr'], global_step) + progress_bar.set_postfix({'epoch': f"{epoch}/{CONFIG['num_epochs']}",'loss': f'{loss.item():.4f}', 'step': global_step}) + + train_avg_loss = total_train_loss / num_batches + return train_avg_loss, global_step + +def validate(model: ASRModel, dataloader: DataLoader, criterion: CTCLoss, device: device, tokenizer: ASRTokenizer, writer: SummaryWriter, global_step: int) -> tuple[float, float, float]: + model.eval() + total_loss = 0 + total_cer = 0 + total_wer = 0 + num_samples = 0 + num_batches = 0 + examples = [] + + with no_grad(): + progress_bar = tqdm(dataloader, desc="Validate", leave=False) + for batch in progress_bar: + batch: Batch + waveforms = batch['waveforms'].to(device) + targets = batch['targets'].to(device) + waveform_lengths = batch['waveform_lengths'].to(device) + target_lengths = batch['target_lengths'].to(device) + + with torch.autocast(device_type='cuda', dtype=torch.bfloat16): + log_probs, lengths = model(waveforms=waveforms, waveform_lengths=waveform_lengths) + log_probs: Tensor + log_probs_ctc = log_probs.permute(1, 0, 2) + loss: Tensor = criterion(log_probs=log_probs_ctc, targets=targets, input_lengths=lengths, target_lengths=target_lengths) + + total_loss += loss.item() + + for i in range(log_probs.shape[0]): + pred_text = tokenizer.ctc_greedy_decode(log_probs=log_probs[i]) + true_text = batch['target_texts'][i] + cer = calculate_cer(pred=pred_text, target=true_text) + wer = calculate_wer(pred=pred_text, target=true_text) + total_cer += cer + total_wer += wer + num_samples += 1 + + if len(examples) < 3: + examples.append((true_text, pred_text, cer, wer)) + + num_batches += 1 + + avg_loss = total_loss / num_batches + avg_cer = total_cer / num_samples + avg_wer = total_wer / num_samples + + writer.add_scalar('Val/Loss', avg_loss, global_step) + writer.add_scalar('Val/CER', avg_cer, global_step) + writer.add_scalar('Val/WER', avg_wer, global_step) + + for index, (true_text, pred_text, cer, wer) in enumerate(examples): + writer.add_text(f'Val/Example_{index}', f'True: {true_text}\nPred: {pred_text}\nCER: {cer:.4f} | WER: {wer:.4f}', global_step) + + model.train() + return avg_loss, avg_cer, avg_wer + +def save_checkpoint(model: ASRModel, optimizer: Optimizer, scheduler: OneCycleLR, global_step: int, epoch: int, train_loss: float, val_loss: float, cer: float, wer: float, save_path: Path): + checkpoint = { + 'model_state_dict': model.state_dict(), + 'optimizer_state_dict': optimizer.state_dict(), + 'scheduler_state_dict': scheduler.state_dict(), + 'global_step': global_step, + 'train_loss': train_loss, + 'val_loss': val_loss, + 'epoch': epoch, + 'cer': cer, + 'wer': wer, + } + torch.save(checkpoint, save_path) + +def find_latest_checkpoint(checkpoint_dir: Path) -> Path | None: + checkpoints = sorted(checkpoint_dir.glob('checkpoint_epoch_*.pt'), key=lambda p: int(p.stem.split('_')[-1])) + return checkpoints[-1] if checkpoints else None + +def load_checkpoint(file_path: Path, model: ASRModel, optimizer: AdamW, scheduler: OneCycleLR): + checkpoint = torch.load(file_path, weights_only=False) + model.load_state_dict(checkpoint['model_state_dict']) + optimizer.load_state_dict(checkpoint['optimizer_state_dict']) + scheduler.load_state_dict(checkpoint['scheduler_state_dict']) + + epoch = checkpoint['epoch'] + global_step = checkpoint['global_step'] + best_cer = checkpoint['cer'] + best_wer = checkpoint['wer'] + return epoch, global_step, best_cer, best_wer + +def main(): + workspace_dir = Path(__file__).parent.parent + device = torch.device('cuda:0') + tokenizer = ASRTokenizer(workspace_dir / 'config/asr_vocab.json') + final_prob = 0.5 + warmup_epochs = 8 + current_prob = 0.0 + + # ============ 创建数据加载器 ============ + train_loader = create_dataloader( + tsv_path=workspace_dir / '.data/ug/train_new.tsv', + audio_dir=workspace_dir / '.data/ug/clips', + noise_dir='/mnt/dataset/dataset/audio/noise', + tokenizer=tokenizer, + batch_size=CONFIG['batch_size'], + shuffle=True, + augment=True, + augment_prob=current_prob + ) + + val_loader = create_dataloader( + tsv_path=workspace_dir / '.data/ug/val_new.tsv', + audio_dir=workspace_dir / '.data/ug/clips', + noise_dir='/mnt/dataset/dataset/audio/noise', + tokenizer=tokenizer, + batch_size=CONFIG['batch_size'], + shuffle=False, + augment=False + ) + + # ============ 初始化模型 ============ + model = ASRModel( + vocab_size=tokenizer.vocab_size(), + input_dim=CONFIG['input_dim'], + num_heads=CONFIG['num_heads'], + ffn_dim=CONFIG['ffn_dim'], + num_layers=CONFIG['num_layers'], + dropout=CONFIG['dropout'], + ).to(device) + print(f"🤖 模型参数量: {model.get_num_params() / 1e6:.2f}M") + + + criterion = CTCLoss(blank=tokenizer.get_special_token_id(''), zero_infinity=True) + optimizer = AdamW(model.parameters(), lr=CONFIG['learning_rate'], weight_decay=CONFIG['weight_decay'], foreach=True) + + # 使用 OneCycleLR：自动处理 warmup 和衰减 + scheduler = OneCycleLR( + optimizer, + max_lr=CONFIG['learning_rate'], + epochs=CONFIG['num_epochs'], + steps_per_epoch=len(train_loader), + pct_start=0.15, + anneal_strategy='cos', + div_factor=10.0, # 初始 lr = max_lr / 10 + final_div_factor=1e4, # 最终 lr = max_lr / 10000 + ) + scaler = GradScaler() + + # ============ TensorBoard ============ + log_dir = workspace_dir / 'runs' / datetime.now().strftime('%Y%m%d_%H%M%S') + writer = SummaryWriter(log_dir) + + config_text = '\n'.join([f'{k}: {v}' for k, v in CONFIG.items()]) + writer.add_text('Config', config_text, 0) + print(f"📊 TensorBoard 日志: {log_dir}") + + checkpoint_dir = workspace_dir / '.checkpoints' + checkpoint_dir.mkdir(exist_ok=True) + + # ============ 训练循环 ============ + best_cer = float('inf') + best_wer = float('inf') + patience_counter = 0 + global_step = 0 + start_epoch = 0 + + latest = find_latest_checkpoint(checkpoint_dir) + if latest: + start_epoch, global_step, best_cer, best_wer = load_checkpoint(latest, model, optimizer, scheduler) + start_epoch += 1 # 从下一个 epoch 开始 + print(f"✅ 恢复训练: 从 epoch={start_epoch} 开始, global_step={global_step}") + else: + start_epoch = 0 + print("🆕 从头开始训练\n") + + for epoch in range(start_epoch, CONFIG['num_epochs']): + current_prob = final_prob * (1 - math.cos(math.pi * epoch / warmup_epochs)) / 2 + train_loss, global_step = train_one_epoch( + model=model, + dataloader=train_loader, + criterion=criterion, + optimizer=optimizer, + scheduler=scheduler, + device=device, + epoch=epoch, + writer=writer, + global_step=global_step, + scaler=scaler, + ) + + val_loss, val_cer, val_wer = validate(model=model, dataloader=val_loader, criterion=criterion, device=device, tokenizer=tokenizer, writer=writer, global_step=global_step) + print(f"\n📊 Step {global_step} | Val Loss: {val_loss:.4f} | Val CER: {val_cer:.4f} | Val WER: {val_wer:.4f}") + + # 保存常规 checkpoint + checkpoint_path = checkpoint_dir / f'checkpoint_epoch_{epoch}.pt' + save_checkpoint(model=model, optimizer=optimizer, scheduler=scheduler, epoch=epoch, global_step=global_step, train_loss=train_loss, val_loss=val_loss, cer=val_cer, wer=val_wer, save_path=checkpoint_path) + + # 分别保存最佳 CER 和 WER 模型 + improved = False + if val_cer < best_cer: + best_cer = val_cer + best_cer_path = checkpoint_dir / 'best_cer_model.pt' + save_checkpoint(model=model, optimizer=optimizer, scheduler=scheduler, epoch=epoch, global_step=global_step, train_loss=train_loss, val_loss=val_loss, cer=val_cer, wer=val_wer, save_path=best_cer_path) + improved = True + + if val_wer < best_wer: + best_wer = val_wer + best_wer_path = checkpoint_dir / 'best_wer_model.pt' + save_checkpoint(model=model, optimizer=optimizer, scheduler=scheduler, epoch=epoch, global_step=global_step, train_loss=train_loss, val_loss=val_loss, cer=val_cer, wer=val_wer, save_path=best_wer_path) + improved = True + + # Early Stopping 逻辑 + if improved: + patience_counter = 0 + else: + patience_counter += 1 + print(f"⚠️ 验证指标未改善，patience: {patience_counter}/{CONFIG['early_stopping_patience']}") + + # 删除旧的 checkpoint（保留最近3个） + old_checkpoints = sorted(checkpoint_dir.glob('checkpoint_epoch_*.pt'), key=lambda p: int(p.stem.split('_')[-1])) + for old in old_checkpoints[:-3]: + old.unlink() + + cuda.empty_cache() + + writer.add_scalar('Val/EpochLoss', val_loss, epoch) + writer.add_scalar('Train/EpochLoss', train_loss, epoch) + print(f"✅ Epoch {epoch} 完成 | Train Avg Loss: {train_loss:.4f} | Val Avg Loss: {val_loss:.4f} | Best CER: {best_cer:.4f} | Best WER: {best_wer:.4f}\n") + + # Early Stopping 检查 + if patience_counter >= CONFIG['early_stopping_patience']: + print(f"\n🛑 Early Stopping: 验证指标连续 {CONFIG['early_stopping_patience']} 次没有改善") + print(f"🏆 最佳 CER: {best_cer:.4f}") + print(f"🏆 最佳 WER: {best_wer:.4f}") + break + + writer.close() + print(f"\n{'='*60}") + print(f"🎉 训练完成！") + print(f"🏆 最佳 CER: {best_cer:.4f}") + print(f"🏆 最佳 WER: {best_wer:.4f}") + print(f"📊 TensorBoard: tensorboard --logdir={workspace_dir / 'runs'}") + print(f"{'='*60}\n") + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/uv.lock b/uv.lock new file mode 100644 index 0000000..39fd3c1 --- /dev/null +++ b/uv.lock @@ -0,0 +1,2168 @@ +version = 1 +revision = 3 +requires-python = ">=3.11" +resolution-markers = [ + "python_full_version >= '3.14' and sys_platform == 'win32'", + "python_full_version >= '3.14' and sys_platform == 'emscripten'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.13.*' and sys_platform == 'win32'", + "python_full_version == '3.13.*' and sys_platform == 'emscripten'", + "python_full_version == '3.13.*' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.12.*' and sys_platform == 'win32'", + "python_full_version == '3.12.*' and sys_platform == 'emscripten'", + "python_full_version == '3.12.*' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version < '3.12' and sys_platform == 'win32'", + "python_full_version < '3.12' and sys_platform == 'emscripten'", + "python_full_version < '3.12' and sys_platform != 'emscripten' and sys_platform != 'win32'", +] + +[[package]] +name = "absl-py" +version = "2.4.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/64/c7/8de93764ad66968d19329a7e0c147a2bb3c7054c554d4a119111b8f9440f/absl_py-2.4.0.tar.gz", hash = "sha256:8c6af82722b35cf71e0f4d1d47dcaebfff286e27110a99fc359349b247dfb5d4", size = 116543, upload-time = "2026-01-28T10:17:05.322Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/18/a6/907a406bb7d359e6a63f99c313846d9eec4f7e6f7437809e03aa00fa3074/absl_py-2.4.0-py3-none-any.whl", hash = "sha256:88476fd881ca8aab94ffa78b7b6c632a782ab3ba1cd19c9bd423abc4fb4cd28d", size = 135750, upload-time = "2026-01-28T10:17:04.19Z" }, +] + +[[package]] +name = "asttokens" +version = "3.0.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/be/a5/8e3f9b6771b0b408517c82d97aed8f2036509bc247d46114925e32fe33f0/asttokens-3.0.1.tar.gz", hash = "sha256:71a4ee5de0bde6a31d64f6b13f2293ac190344478f081c3d1bccfcf5eacb0cb7", size = 62308, upload-time = "2025-11-15T16:43:48.578Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d2/39/e7eaf1799466a4aef85b6a4fe7bd175ad2b1c6345066aa33f1f58d4b18d0/asttokens-3.0.1-py3-none-any.whl", hash = "sha256:15a3ebc0f43c2d0a50eeafea25e19046c68398e487b9f1f5b517f7c0f40f976a", size = 27047, upload-time = "2025-11-15T16:43:16.109Z" }, +] + +[[package]] +name = "audioop-lts" +version = "0.2.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/38/53/946db57842a50b2da2e0c1e34bd37f36f5aadba1a929a3971c5d7841dbca/audioop_lts-0.2.2.tar.gz", hash = "sha256:64d0c62d88e67b98a1a5e71987b7aa7b5bcffc7dcee65b635823dbdd0a8dbbd0", size = 30686, upload-time = "2025-08-05T16:43:17.409Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/de/d4/94d277ca941de5a507b07f0b592f199c22454eeaec8f008a286b3fbbacd6/audioop_lts-0.2.2-cp313-abi3-macosx_10_13_universal2.whl", hash = "sha256:fd3d4602dc64914d462924a08c1a9816435a2155d74f325853c1f1ac3b2d9800", size = 46523, upload-time = "2025-08-05T16:42:20.836Z" }, + { url = "https://files.pythonhosted.org/packages/f8/5a/656d1c2da4b555920ce4177167bfeb8623d98765594af59702c8873f60ec/audioop_lts-0.2.2-cp313-abi3-macosx_10_13_x86_64.whl", hash = "sha256:550c114a8df0aafe9a05442a1162dfc8fec37e9af1d625ae6060fed6e756f303", size = 27455, upload-time = "2025-08-05T16:42:22.283Z" }, + { url = "https://files.pythonhosted.org/packages/1b/83/ea581e364ce7b0d41456fb79d6ee0ad482beda61faf0cab20cbd4c63a541/audioop_lts-0.2.2-cp313-abi3-macosx_11_0_arm64.whl", hash = "sha256:9a13dc409f2564de15dd68be65b462ba0dde01b19663720c68c1140c782d1d75", size = 26997, upload-time = "2025-08-05T16:42:23.849Z" }, + { url = "https://files.pythonhosted.org/packages/b8/3b/e8964210b5e216e5041593b7d33e97ee65967f17c282e8510d19c666dab4/audioop_lts-0.2.2-cp313-abi3-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:51c916108c56aa6e426ce611946f901badac950ee2ddaf302b7ed35d9958970d", size = 85844, upload-time = "2025-08-05T16:42:25.208Z" }, + { url = "https://files.pythonhosted.org/packages/c7/2e/0a1c52faf10d51def20531a59ce4c706cb7952323b11709e10de324d6493/audioop_lts-0.2.2-cp313-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:47eba38322370347b1c47024defbd36374a211e8dd5b0dcbce7b34fdb6f8847b", size = 85056, upload-time = "2025-08-05T16:42:26.559Z" }, + { url = "https://files.pythonhosted.org/packages/75/e8/cd95eef479656cb75ab05dfece8c1f8c395d17a7c651d88f8e6e291a63ab/audioop_lts-0.2.2-cp313-abi3-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ba7c3a7e5f23e215cb271516197030c32aef2e754252c4c70a50aaff7031a2c8", size = 93892, upload-time = "2025-08-05T16:42:27.902Z" }, + { url = "https://files.pythonhosted.org/packages/5c/1e/a0c42570b74f83efa5cca34905b3eef03f7ab09fe5637015df538a7f3345/audioop_lts-0.2.2-cp313-abi3-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:def246fe9e180626731b26e89816e79aae2276f825420a07b4a647abaa84becc", size = 96660, upload-time = "2025-08-05T16:42:28.9Z" }, + { url = "https://files.pythonhosted.org/packages/50/d5/8a0ae607ca07dbb34027bac8db805498ee7bfecc05fd2c148cc1ed7646e7/audioop_lts-0.2.2-cp313-abi3-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e160bf9df356d841bb6c180eeeea1834085464626dc1b68fa4e1d59070affdc3", size = 79143, upload-time = "2025-08-05T16:42:29.929Z" }, + { url = "https://files.pythonhosted.org/packages/12/17/0d28c46179e7910bfb0bb62760ccb33edb5de973052cb2230b662c14ca2e/audioop_lts-0.2.2-cp313-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:4b4cd51a57b698b2d06cb9993b7ac8dfe89a3b2878e96bc7948e9f19ff51dba6", size = 84313, upload-time = "2025-08-05T16:42:30.949Z" }, + { url = "https://files.pythonhosted.org/packages/84/ba/bd5d3806641564f2024e97ca98ea8f8811d4e01d9b9f9831474bc9e14f9e/audioop_lts-0.2.2-cp313-abi3-musllinux_1_2_ppc64le.whl", hash = "sha256:4a53aa7c16a60a6857e6b0b165261436396ef7293f8b5c9c828a3a203147ed4a", size = 93044, upload-time = "2025-08-05T16:42:31.959Z" }, + { url = "https://files.pythonhosted.org/packages/f9/5e/435ce8d5642f1f7679540d1e73c1c42d933331c0976eb397d1717d7f01a3/audioop_lts-0.2.2-cp313-abi3-musllinux_1_2_riscv64.whl", hash = "sha256:3fc38008969796f0f689f1453722a0f463da1b8a6fbee11987830bfbb664f623", size = 78766, upload-time = "2025-08-05T16:42:33.302Z" }, + { url = "https://files.pythonhosted.org/packages/ae/3b/b909e76b606cbfd53875693ec8c156e93e15a1366a012f0b7e4fb52d3c34/audioop_lts-0.2.2-cp313-abi3-musllinux_1_2_s390x.whl", hash = "sha256:15ab25dd3e620790f40e9ead897f91e79c0d3ce65fe193c8ed6c26cffdd24be7", size = 87640, upload-time = "2025-08-05T16:42:34.854Z" }, + { url = "https://files.pythonhosted.org/packages/30/e7/8f1603b4572d79b775f2140d7952f200f5e6c62904585d08a01f0a70393a/audioop_lts-0.2.2-cp313-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:03f061a1915538fd96272bac9551841859dbb2e3bf73ebe4a23ef043766f5449", size = 86052, upload-time = "2025-08-05T16:42:35.839Z" }, + { url = "https://files.pythonhosted.org/packages/b5/96/c37846df657ccdda62ba1ae2b6534fa90e2e1b1742ca8dcf8ebd38c53801/audioop_lts-0.2.2-cp313-abi3-win32.whl", hash = "sha256:3bcddaaf6cc5935a300a8387c99f7a7fbbe212a11568ec6cf6e4bc458c048636", size = 26185, upload-time = "2025-08-05T16:42:37.04Z" }, + { url = "https://files.pythonhosted.org/packages/34/a5/9d78fdb5b844a83da8a71226c7bdae7cc638861085fff7a1d707cb4823fa/audioop_lts-0.2.2-cp313-abi3-win_amd64.whl", hash = "sha256:a2c2a947fae7d1062ef08c4e369e0ba2086049a5e598fda41122535557012e9e", size = 30503, upload-time = "2025-08-05T16:42:38.427Z" }, + { url = "https://files.pythonhosted.org/packages/34/25/20d8fde083123e90c61b51afb547bb0ea7e77bab50d98c0ab243d02a0e43/audioop_lts-0.2.2-cp313-abi3-win_arm64.whl", hash = "sha256:5f93a5db13927a37d2d09637ccca4b2b6b48c19cd9eda7b17a2e9f77edee6a6f", size = 24173, upload-time = "2025-08-05T16:42:39.704Z" }, + { url = "https://files.pythonhosted.org/packages/58/a7/0a764f77b5c4ac58dc13c01a580f5d32ae8c74c92020b961556a43e26d02/audioop_lts-0.2.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:73f80bf4cd5d2ca7814da30a120de1f9408ee0619cc75da87d0641273d202a09", size = 47096, upload-time = "2025-08-05T16:42:40.684Z" }, + { url = "https://files.pythonhosted.org/packages/aa/ed/ebebedde1a18848b085ad0fa54b66ceb95f1f94a3fc04f1cd1b5ccb0ed42/audioop_lts-0.2.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:106753a83a25ee4d6f473f2be6b0966fc1c9af7e0017192f5531a3e7463dce58", size = 27748, upload-time = "2025-08-05T16:42:41.992Z" }, + { url = "https://files.pythonhosted.org/packages/cb/6e/11ca8c21af79f15dbb1c7f8017952ee8c810c438ce4e2b25638dfef2b02c/audioop_lts-0.2.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:fbdd522624141e40948ab3e8cdae6e04c748d78710e9f0f8d4dae2750831de19", size = 27329, upload-time = "2025-08-05T16:42:42.987Z" }, + { url = "https://files.pythonhosted.org/packages/84/52/0022f93d56d85eec5da6b9da6a958a1ef09e80c39f2cc0a590c6af81dcbb/audioop_lts-0.2.2-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:143fad0311e8209ece30a8dbddab3b65ab419cbe8c0dde6e8828da25999be911", size = 92407, upload-time = "2025-08-05T16:42:44.336Z" }, + { url = "https://files.pythonhosted.org/packages/87/1d/48a889855e67be8718adbc7a01f3c01d5743c325453a5e81cf3717664aad/audioop_lts-0.2.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dfbbc74ec68a0fd08cfec1f4b5e8cca3d3cd7de5501b01c4b5d209995033cde9", size = 91811, upload-time = "2025-08-05T16:42:45.325Z" }, + { url = "https://files.pythonhosted.org/packages/98/a6/94b7213190e8077547ffae75e13ed05edc488653c85aa5c41472c297d295/audioop_lts-0.2.2-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:cfcac6aa6f42397471e4943e0feb2244549db5c5d01efcd02725b96af417f3fe", size = 100470, upload-time = "2025-08-05T16:42:46.468Z" }, + { url = "https://files.pythonhosted.org/packages/e9/e9/78450d7cb921ede0cfc33426d3a8023a3bda755883c95c868ee36db8d48d/audioop_lts-0.2.2-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:752d76472d9804ac60f0078c79cdae8b956f293177acd2316cd1e15149aee132", size = 103878, upload-time = "2025-08-05T16:42:47.576Z" }, + { url = "https://files.pythonhosted.org/packages/4f/e2/cd5439aad4f3e34ae1ee852025dc6aa8f67a82b97641e390bf7bd9891d3e/audioop_lts-0.2.2-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:83c381767e2cc10e93e40281a04852facc4cd9334550e0f392f72d1c0a9c5753", size = 84867, upload-time = "2025-08-05T16:42:49.003Z" }, + { url = "https://files.pythonhosted.org/packages/68/4b/9d853e9076c43ebba0d411e8d2aa19061083349ac695a7d082540bad64d0/audioop_lts-0.2.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:c0022283e9556e0f3643b7c3c03f05063ca72b3063291834cca43234f20c60bb", size = 90001, upload-time = "2025-08-05T16:42:50.038Z" }, + { url = "https://files.pythonhosted.org/packages/58/26/4bae7f9d2f116ed5593989d0e521d679b0d583973d203384679323d8fa85/audioop_lts-0.2.2-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:a2d4f1513d63c795e82948e1305f31a6d530626e5f9f2605408b300ae6095093", size = 99046, upload-time = "2025-08-05T16:42:51.111Z" }, + { url = "https://files.pythonhosted.org/packages/b2/67/a9f4fb3e250dda9e9046f8866e9fa7d52664f8985e445c6b4ad6dfb55641/audioop_lts-0.2.2-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:c9c8e68d8b4a56fda8c025e538e639f8c5953f5073886b596c93ec9b620055e7", size = 84788, upload-time = "2025-08-05T16:42:52.198Z" }, + { url = "https://files.pythonhosted.org/packages/70/f7/3de86562db0121956148bcb0fe5b506615e3bcf6e63c4357a612b910765a/audioop_lts-0.2.2-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:96f19de485a2925314f5020e85911fb447ff5fbef56e8c7c6927851b95533a1c", size = 94472, upload-time = "2025-08-05T16:42:53.59Z" }, + { url = "https://files.pythonhosted.org/packages/f1/32/fd772bf9078ae1001207d2df1eef3da05bea611a87dd0e8217989b2848fa/audioop_lts-0.2.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:e541c3ef484852ef36545f66209444c48b28661e864ccadb29daddb6a4b8e5f5", size = 92279, upload-time = "2025-08-05T16:42:54.632Z" }, + { url = "https://files.pythonhosted.org/packages/4f/41/affea7181592ab0ab560044632571a38edaf9130b84928177823fbf3176a/audioop_lts-0.2.2-cp313-cp313t-win32.whl", hash = "sha256:d5e73fa573e273e4f2e5ff96f9043858a5e9311e94ffefd88a3186a910c70917", size = 26568, upload-time = "2025-08-05T16:42:55.627Z" }, + { url = "https://files.pythonhosted.org/packages/28/2b/0372842877016641db8fc54d5c88596b542eec2f8f6c20a36fb6612bf9ee/audioop_lts-0.2.2-cp313-cp313t-win_amd64.whl", hash = "sha256:9191d68659eda01e448188f60364c7763a7ca6653ed3f87ebb165822153a8547", size = 30942, upload-time = "2025-08-05T16:42:56.674Z" }, + { url = "https://files.pythonhosted.org/packages/ee/ca/baf2b9cc7e96c179bb4a54f30fcd83e6ecb340031bde68f486403f943768/audioop_lts-0.2.2-cp313-cp313t-win_arm64.whl", hash = "sha256:c174e322bb5783c099aaf87faeb240c8d210686b04bd61dfd05a8e5a83d88969", size = 24603, upload-time = "2025-08-05T16:42:57.571Z" }, + { url = "https://files.pythonhosted.org/packages/5c/73/413b5a2804091e2c7d5def1d618e4837f1cb82464e230f827226278556b7/audioop_lts-0.2.2-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:f9ee9b52f5f857fbaf9d605a360884f034c92c1c23021fb90b2e39b8e64bede6", size = 47104, upload-time = "2025-08-05T16:42:58.518Z" }, + { url = "https://files.pythonhosted.org/packages/ae/8c/daa3308dc6593944410c2c68306a5e217f5c05b70a12e70228e7dd42dc5c/audioop_lts-0.2.2-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:49ee1a41738a23e98d98b937a0638357a2477bc99e61b0f768a8f654f45d9b7a", size = 27754, upload-time = "2025-08-05T16:43:00.132Z" }, + { url = "https://files.pythonhosted.org/packages/4e/86/c2e0f627168fcf61781a8f72cab06b228fe1da4b9fa4ab39cfb791b5836b/audioop_lts-0.2.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5b00be98ccd0fc123dcfad31d50030d25fcf31488cde9e61692029cd7394733b", size = 27332, upload-time = "2025-08-05T16:43:01.666Z" }, + { url = "https://files.pythonhosted.org/packages/c7/bd/35dce665255434f54e5307de39e31912a6f902d4572da7c37582809de14f/audioop_lts-0.2.2-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:a6d2e0f9f7a69403e388894d4ca5ada5c47230716a03f2847cfc7bd1ecb589d6", size = 92396, upload-time = "2025-08-05T16:43:02.991Z" }, + { url = "https://files.pythonhosted.org/packages/2d/d2/deeb9f51def1437b3afa35aeb729d577c04bcd89394cb56f9239a9f50b6f/audioop_lts-0.2.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f9b0b8a03ef474f56d1a842af1a2e01398b8f7654009823c6d9e0ecff4d5cfbf", size = 91811, upload-time = "2025-08-05T16:43:04.096Z" }, + { url = "https://files.pythonhosted.org/packages/76/3b/09f8b35b227cee28cc8231e296a82759ed80c1a08e349811d69773c48426/audioop_lts-0.2.2-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2b267b70747d82125f1a021506565bdc5609a2b24bcb4773c16d79d2bb260bbd", size = 100483, upload-time = "2025-08-05T16:43:05.085Z" }, + { url = "https://files.pythonhosted.org/packages/0b/15/05b48a935cf3b130c248bfdbdea71ce6437f5394ee8533e0edd7cfd93d5e/audioop_lts-0.2.2-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0337d658f9b81f4cd0fdb1f47635070cc084871a3d4646d9de74fdf4e7c3d24a", size = 103885, upload-time = "2025-08-05T16:43:06.197Z" }, + { url = "https://files.pythonhosted.org/packages/83/80/186b7fce6d35b68d3d739f228dc31d60b3412105854edb975aa155a58339/audioop_lts-0.2.2-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:167d3b62586faef8b6b2275c3218796b12621a60e43f7e9d5845d627b9c9b80e", size = 84899, upload-time = "2025-08-05T16:43:07.291Z" }, + { url = "https://files.pythonhosted.org/packages/49/89/c78cc5ac6cb5828f17514fb12966e299c850bc885e80f8ad94e38d450886/audioop_lts-0.2.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:0d9385e96f9f6da847f4d571ce3cb15b5091140edf3db97276872647ce37efd7", size = 89998, upload-time = "2025-08-05T16:43:08.335Z" }, + { url = "https://files.pythonhosted.org/packages/4c/4b/6401888d0c010e586c2ca50fce4c903d70a6bb55928b16cfbdfd957a13da/audioop_lts-0.2.2-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:48159d96962674eccdca9a3df280e864e8ac75e40a577cc97c5c42667ffabfc5", size = 99046, upload-time = "2025-08-05T16:43:09.367Z" }, + { url = "https://files.pythonhosted.org/packages/de/f8/c874ca9bb447dae0e2ef2e231f6c4c2b0c39e31ae684d2420b0f9e97ee68/audioop_lts-0.2.2-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:8fefe5868cd082db1186f2837d64cfbfa78b548ea0d0543e9b28935ccce81ce9", size = 84843, upload-time = "2025-08-05T16:43:10.749Z" }, + { url = "https://files.pythonhosted.org/packages/3e/c0/0323e66f3daebc13fd46b36b30c3be47e3fc4257eae44f1e77eb828c703f/audioop_lts-0.2.2-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:58cf54380c3884fb49fdd37dfb7a772632b6701d28edd3e2904743c5e1773602", size = 94490, upload-time = "2025-08-05T16:43:12.131Z" }, + { url = "https://files.pythonhosted.org/packages/98/6b/acc7734ac02d95ab791c10c3f17ffa3584ccb9ac5c18fd771c638ed6d1f5/audioop_lts-0.2.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:088327f00488cdeed296edd9215ca159f3a5a5034741465789cad403fcf4bec0", size = 92297, upload-time = "2025-08-05T16:43:13.139Z" }, + { url = "https://files.pythonhosted.org/packages/13/c3/c3dc3f564ce6877ecd2a05f8d751b9b27a8c320c2533a98b0c86349778d0/audioop_lts-0.2.2-cp314-cp314t-win32.whl", hash = "sha256:068aa17a38b4e0e7de771c62c60bbca2455924b67a8814f3b0dee92b5820c0b3", size = 27331, upload-time = "2025-08-05T16:43:14.19Z" }, + { url = "https://files.pythonhosted.org/packages/72/bb/b4608537e9ffcb86449091939d52d24a055216a36a8bf66b936af8c3e7ac/audioop_lts-0.2.2-cp314-cp314t-win_amd64.whl", hash = "sha256:a5bf613e96f49712073de86f20dbdd4014ca18efd4d34ed18c75bd808337851b", size = 31697, upload-time = "2025-08-05T16:43:15.193Z" }, + { url = "https://files.pythonhosted.org/packages/f6/22/91616fe707a5c5510de2cac9b046a30defe7007ba8a0c04f9c08f27df312/audioop_lts-0.2.2-cp314-cp314t-win_arm64.whl", hash = "sha256:b492c3b040153e68b9fdaff5913305aaaba5bb433d8a7f73d5cf6a64ed3cc1dd", size = 25206, upload-time = "2025-08-05T16:43:16.444Z" }, +] + +[[package]] +name = "audioread" +version = "3.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "standard-aifc", marker = "python_full_version >= '3.13'" }, + { name = "standard-sunau", marker = "python_full_version >= '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a1/4a/874ecf9b472f998130c2b5e145dcdb9f6131e84786111489103b66772143/audioread-3.1.0.tar.gz", hash = "sha256:1c4ab2f2972764c896a8ac61ac53e261c8d29f0c6ccd652f84e18f08a4cab190", size = 20082, upload-time = "2025-10-26T19:44:13.484Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/16/fbe8e1e185a45042f7cd3a282def5bb8d95bb69ab9e9ef6a5368aa17e426/audioread-3.1.0-py3-none-any.whl", hash = "sha256:b30d1df6c5d3de5dcef0fb0e256f6ea17bdcf5f979408df0297d8a408e2971b4", size = 23143, upload-time = "2025-10-26T19:44:12.016Z" }, +] + +[[package]] +name = "certifi" +version = "2026.4.22" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/25/ee/6caf7a40c36a1220410afe15a1cc64993a1f864871f698c0f93acb72842a/certifi-2026.4.22.tar.gz", hash = "sha256:8d455352a37b71bf76a79caa83a3d6c25afee4a385d632127b6afb3963f1c580", size = 137077, upload-time = "2026-04-22T11:26:11.191Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/22/30/7cd8fdcdfbc5b869528b079bfb76dcdf6056b1a2097a662e5e8c04f42965/certifi-2026.4.22-py3-none-any.whl", hash = "sha256:3cb2210c8f88ba2318d29b0388d1023c8492ff72ecdde4ebdaddbb13a31b1c4a", size = 135707, upload-time = "2026-04-22T11:26:09.372Z" }, +] + +[[package]] +name = "cffi" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pycparser", marker = "implementation_name != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", hash = "sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529", size = 523588, upload-time = "2025-09-08T23:24:04.541Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/12/4a/3dfd5f7850cbf0d06dc84ba9aa00db766b52ca38d8b86e3a38314d52498c/cffi-2.0.0-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:b4c854ef3adc177950a8dfc81a86f5115d2abd545751a304c5bcf2c2c7283cfe", size = 184344, upload-time = "2025-09-08T23:22:26.456Z" }, + { url = "https://files.pythonhosted.org/packages/4f/8b/f0e4c441227ba756aafbe78f117485b25bb26b1c059d01f137fa6d14896b/cffi-2.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2de9a304e27f7596cd03d16f1b7c72219bd944e99cc52b84d0145aefb07cbd3c", size = 180560, upload-time = "2025-09-08T23:22:28.197Z" }, + { url = "https://files.pythonhosted.org/packages/b1/b7/1200d354378ef52ec227395d95c2576330fd22a869f7a70e88e1447eb234/cffi-2.0.0-cp311-cp311-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:baf5215e0ab74c16e2dd324e8ec067ef59e41125d3eade2b863d294fd5035c92", size = 209613, upload-time = "2025-09-08T23:22:29.475Z" }, + { url = "https://files.pythonhosted.org/packages/b8/56/6033f5e86e8cc9bb629f0077ba71679508bdf54a9a5e112a3c0b91870332/cffi-2.0.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:730cacb21e1bdff3ce90babf007d0a0917cc3e6492f336c2f0134101e0944f93", size = 216476, upload-time = "2025-09-08T23:22:31.063Z" }, + { url = "https://files.pythonhosted.org/packages/dc/7f/55fecd70f7ece178db2f26128ec41430d8720f2d12ca97bf8f0a628207d5/cffi-2.0.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:6824f87845e3396029f3820c206e459ccc91760e8fa24422f8b0c3d1731cbec5", size = 203374, upload-time = "2025-09-08T23:22:32.507Z" }, + { url = "https://files.pythonhosted.org/packages/84/ef/a7b77c8bdc0f77adc3b46888f1ad54be8f3b7821697a7b89126e829e676a/cffi-2.0.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:9de40a7b0323d889cf8d23d1ef214f565ab154443c42737dfe52ff82cf857664", size = 202597, upload-time = "2025-09-08T23:22:34.132Z" }, + { url = "https://files.pythonhosted.org/packages/d7/91/500d892b2bf36529a75b77958edfcd5ad8e2ce4064ce2ecfeab2125d72d1/cffi-2.0.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8941aaadaf67246224cee8c3803777eed332a19d909b47e29c9842ef1e79ac26", size = 215574, upload-time = "2025-09-08T23:22:35.443Z" }, + { url = "https://files.pythonhosted.org/packages/44/64/58f6255b62b101093d5df22dcb752596066c7e89dd725e0afaed242a61be/cffi-2.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:a05d0c237b3349096d3981b727493e22147f934b20f6f125a3eba8f994bec4a9", size = 218971, upload-time = "2025-09-08T23:22:36.805Z" }, + { url = "https://files.pythonhosted.org/packages/ab/49/fa72cebe2fd8a55fbe14956f9970fe8eb1ac59e5df042f603ef7c8ba0adc/cffi-2.0.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:94698a9c5f91f9d138526b48fe26a199609544591f859c870d477351dc7b2414", size = 211972, upload-time = "2025-09-08T23:22:38.436Z" }, + { url = "https://files.pythonhosted.org/packages/0b/28/dd0967a76aab36731b6ebfe64dec4e981aff7e0608f60c2d46b46982607d/cffi-2.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:5fed36fccc0612a53f1d4d9a816b50a36702c28a2aa880cb8a122b3466638743", size = 217078, upload-time = "2025-09-08T23:22:39.776Z" }, + { url = "https://files.pythonhosted.org/packages/2b/c0/015b25184413d7ab0a410775fdb4a50fca20f5589b5dab1dbbfa3baad8ce/cffi-2.0.0-cp311-cp311-win32.whl", hash = "sha256:c649e3a33450ec82378822b3dad03cc228b8f5963c0c12fc3b1e0ab940f768a5", size = 172076, upload-time = "2025-09-08T23:22:40.95Z" }, + { url = "https://files.pythonhosted.org/packages/ae/8f/dc5531155e7070361eb1b7e4c1a9d896d0cb21c49f807a6c03fd63fc877e/cffi-2.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:66f011380d0e49ed280c789fbd08ff0d40968ee7b665575489afa95c98196ab5", size = 182820, upload-time = "2025-09-08T23:22:42.463Z" }, + { url = "https://files.pythonhosted.org/packages/95/5c/1b493356429f9aecfd56bc171285a4c4ac8697f76e9bbbbb105e537853a1/cffi-2.0.0-cp311-cp311-win_arm64.whl", hash = "sha256:c6638687455baf640e37344fe26d37c404db8b80d037c3d29f58fe8d1c3b194d", size = 177635, upload-time = "2025-09-08T23:22:43.623Z" }, + { url = "https://files.pythonhosted.org/packages/ea/47/4f61023ea636104d4f16ab488e268b93008c3d0bb76893b1b31db1f96802/cffi-2.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6d02d6655b0e54f54c4ef0b94eb6be0607b70853c45ce98bd278dc7de718be5d", size = 185271, upload-time = "2025-09-08T23:22:44.795Z" }, + { url = "https://files.pythonhosted.org/packages/df/a2/781b623f57358e360d62cdd7a8c681f074a71d445418a776eef0aadb4ab4/cffi-2.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8eca2a813c1cb7ad4fb74d368c2ffbbb4789d377ee5bb8df98373c2cc0dee76c", size = 181048, upload-time = "2025-09-08T23:22:45.938Z" }, + { url = "https://files.pythonhosted.org/packages/ff/df/a4f0fbd47331ceeba3d37c2e51e9dfc9722498becbeec2bd8bc856c9538a/cffi-2.0.0-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:21d1152871b019407d8ac3985f6775c079416c282e431a4da6afe7aefd2bccbe", size = 212529, upload-time = "2025-09-08T23:22:47.349Z" }, + { url = "https://files.pythonhosted.org/packages/d5/72/12b5f8d3865bf0f87cf1404d8c374e7487dcf097a1c91c436e72e6badd83/cffi-2.0.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b21e08af67b8a103c71a250401c78d5e0893beff75e28c53c98f4de42f774062", size = 220097, upload-time = "2025-09-08T23:22:48.677Z" }, + { url = "https://files.pythonhosted.org/packages/c2/95/7a135d52a50dfa7c882ab0ac17e8dc11cec9d55d2c18dda414c051c5e69e/cffi-2.0.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:1e3a615586f05fc4065a8b22b8152f0c1b00cdbc60596d187c2a74f9e3036e4e", size = 207983, upload-time = "2025-09-08T23:22:50.06Z" }, + { url = "https://files.pythonhosted.org/packages/3a/c8/15cb9ada8895957ea171c62dc78ff3e99159ee7adb13c0123c001a2546c1/cffi-2.0.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:81afed14892743bbe14dacb9e36d9e0e504cd204e0b165062c488942b9718037", size = 206519, upload-time = "2025-09-08T23:22:51.364Z" }, + { url = "https://files.pythonhosted.org/packages/78/2d/7fa73dfa841b5ac06c7b8855cfc18622132e365f5b81d02230333ff26e9e/cffi-2.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3e17ed538242334bf70832644a32a7aae3d83b57567f9fd60a26257e992b79ba", size = 219572, upload-time = "2025-09-08T23:22:52.902Z" }, + { url = "https://files.pythonhosted.org/packages/07/e0/267e57e387b4ca276b90f0434ff88b2c2241ad72b16d31836adddfd6031b/cffi-2.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3925dd22fa2b7699ed2617149842d2e6adde22b262fcbfada50e3d195e4b3a94", size = 222963, upload-time = "2025-09-08T23:22:54.518Z" }, + { url = "https://files.pythonhosted.org/packages/b6/75/1f2747525e06f53efbd878f4d03bac5b859cbc11c633d0fb81432d98a795/cffi-2.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2c8f814d84194c9ea681642fd164267891702542f028a15fc97d4674b6206187", size = 221361, upload-time = "2025-09-08T23:22:55.867Z" }, + { url = "https://files.pythonhosted.org/packages/7b/2b/2b6435f76bfeb6bbf055596976da087377ede68df465419d192acf00c437/cffi-2.0.0-cp312-cp312-win32.whl", hash = "sha256:da902562c3e9c550df360bfa53c035b2f241fed6d9aef119048073680ace4a18", size = 172932, upload-time = "2025-09-08T23:22:57.188Z" }, + { url = "https://files.pythonhosted.org/packages/f8/ed/13bd4418627013bec4ed6e54283b1959cf6db888048c7cf4b4c3b5b36002/cffi-2.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:da68248800ad6320861f129cd9c1bf96ca849a2771a59e0344e88681905916f5", size = 183557, upload-time = "2025-09-08T23:22:58.351Z" }, + { url = "https://files.pythonhosted.org/packages/95/31/9f7f93ad2f8eff1dbc1c3656d7ca5bfd8fb52c9d786b4dcf19b2d02217fa/cffi-2.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:4671d9dd5ec934cb9a73e7ee9676f9362aba54f7f34910956b84d727b0d73fb6", size = 177762, upload-time = "2025-09-08T23:22:59.668Z" }, + { url = "https://files.pythonhosted.org/packages/4b/8d/a0a47a0c9e413a658623d014e91e74a50cdd2c423f7ccfd44086ef767f90/cffi-2.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:00bdf7acc5f795150faa6957054fbbca2439db2f775ce831222b66f192f03beb", size = 185230, upload-time = "2025-09-08T23:23:00.879Z" }, + { url = "https://files.pythonhosted.org/packages/4a/d2/a6c0296814556c68ee32009d9c2ad4f85f2707cdecfd7727951ec228005d/cffi-2.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:45d5e886156860dc35862657e1494b9bae8dfa63bf56796f2fb56e1679fc0bca", size = 181043, upload-time = "2025-09-08T23:23:02.231Z" }, + { url = "https://files.pythonhosted.org/packages/b0/1e/d22cc63332bd59b06481ceaac49d6c507598642e2230f201649058a7e704/cffi-2.0.0-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:07b271772c100085dd28b74fa0cd81c8fb1a3ba18b21e03d7c27f3436a10606b", size = 212446, upload-time = "2025-09-08T23:23:03.472Z" }, + { url = "https://files.pythonhosted.org/packages/a9/f5/a2c23eb03b61a0b8747f211eb716446c826ad66818ddc7810cc2cc19b3f2/cffi-2.0.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d48a880098c96020b02d5a1f7d9251308510ce8858940e6fa99ece33f610838b", size = 220101, upload-time = "2025-09-08T23:23:04.792Z" }, + { url = "https://files.pythonhosted.org/packages/f2/7f/e6647792fc5850d634695bc0e6ab4111ae88e89981d35ac269956605feba/cffi-2.0.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:f93fd8e5c8c0a4aa1f424d6173f14a892044054871c771f8566e4008eaa359d2", size = 207948, upload-time = "2025-09-08T23:23:06.127Z" }, + { url = "https://files.pythonhosted.org/packages/cb/1e/a5a1bd6f1fb30f22573f76533de12a00bf274abcdc55c8edab639078abb6/cffi-2.0.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:dd4f05f54a52fb558f1ba9f528228066954fee3ebe629fc1660d874d040ae5a3", size = 206422, upload-time = "2025-09-08T23:23:07.753Z" }, + { url = "https://files.pythonhosted.org/packages/98/df/0a1755e750013a2081e863e7cd37e0cdd02664372c754e5560099eb7aa44/cffi-2.0.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c8d3b5532fc71b7a77c09192b4a5a200ea992702734a2e9279a37f2478236f26", size = 219499, upload-time = "2025-09-08T23:23:09.648Z" }, + { url = "https://files.pythonhosted.org/packages/50/e1/a969e687fcf9ea58e6e2a928ad5e2dd88cc12f6f0ab477e9971f2309b57c/cffi-2.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d9b29c1f0ae438d5ee9acb31cadee00a58c46cc9c0b2f9038c6b0b3470877a8c", size = 222928, upload-time = "2025-09-08T23:23:10.928Z" }, + { url = "https://files.pythonhosted.org/packages/36/54/0362578dd2c9e557a28ac77698ed67323ed5b9775ca9d3fe73fe191bb5d8/cffi-2.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6d50360be4546678fc1b79ffe7a66265e28667840010348dd69a314145807a1b", size = 221302, upload-time = "2025-09-08T23:23:12.42Z" }, + { url = "https://files.pythonhosted.org/packages/eb/6d/bf9bda840d5f1dfdbf0feca87fbdb64a918a69bca42cfa0ba7b137c48cb8/cffi-2.0.0-cp313-cp313-win32.whl", hash = "sha256:74a03b9698e198d47562765773b4a8309919089150a0bb17d829ad7b44b60d27", size = 172909, upload-time = "2025-09-08T23:23:14.32Z" }, + { url = "https://files.pythonhosted.org/packages/37/18/6519e1ee6f5a1e579e04b9ddb6f1676c17368a7aba48299c3759bbc3c8b3/cffi-2.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:19f705ada2530c1167abacb171925dd886168931e0a7b78f5bffcae5c6b5be75", size = 183402, upload-time = "2025-09-08T23:23:15.535Z" }, + { url = "https://files.pythonhosted.org/packages/cb/0e/02ceeec9a7d6ee63bb596121c2c8e9b3a9e150936f4fbef6ca1943e6137c/cffi-2.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:256f80b80ca3853f90c21b23ee78cd008713787b1b1e93eae9f3d6a7134abd91", size = 177780, upload-time = "2025-09-08T23:23:16.761Z" }, + { url = "https://files.pythonhosted.org/packages/92/c4/3ce07396253a83250ee98564f8d7e9789fab8e58858f35d07a9a2c78de9f/cffi-2.0.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fc33c5141b55ed366cfaad382df24fe7dcbc686de5be719b207bb248e3053dc5", size = 185320, upload-time = "2025-09-08T23:23:18.087Z" }, + { url = "https://files.pythonhosted.org/packages/59/dd/27e9fa567a23931c838c6b02d0764611c62290062a6d4e8ff7863daf9730/cffi-2.0.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c654de545946e0db659b3400168c9ad31b5d29593291482c43e3564effbcee13", size = 181487, upload-time = "2025-09-08T23:23:19.622Z" }, + { url = "https://files.pythonhosted.org/packages/d6/43/0e822876f87ea8a4ef95442c3d766a06a51fc5298823f884ef87aaad168c/cffi-2.0.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:24b6f81f1983e6df8db3adc38562c83f7d4a0c36162885ec7f7b77c7dcbec97b", size = 220049, upload-time = "2025-09-08T23:23:20.853Z" }, + { url = "https://files.pythonhosted.org/packages/b4/89/76799151d9c2d2d1ead63c2429da9ea9d7aac304603de0c6e8764e6e8e70/cffi-2.0.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:12873ca6cb9b0f0d3a0da705d6086fe911591737a59f28b7936bdfed27c0d47c", size = 207793, upload-time = "2025-09-08T23:23:22.08Z" }, + { url = "https://files.pythonhosted.org/packages/bb/dd/3465b14bb9e24ee24cb88c9e3730f6de63111fffe513492bf8c808a3547e/cffi-2.0.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:d9b97165e8aed9272a6bb17c01e3cc5871a594a446ebedc996e2397a1c1ea8ef", size = 206300, upload-time = "2025-09-08T23:23:23.314Z" }, + { url = "https://files.pythonhosted.org/packages/47/d9/d83e293854571c877a92da46fdec39158f8d7e68da75bf73581225d28e90/cffi-2.0.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:afb8db5439b81cf9c9d0c80404b60c3cc9c3add93e114dcae767f1477cb53775", size = 219244, upload-time = "2025-09-08T23:23:24.541Z" }, + { url = "https://files.pythonhosted.org/packages/2b/0f/1f177e3683aead2bb00f7679a16451d302c436b5cbf2505f0ea8146ef59e/cffi-2.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:737fe7d37e1a1bffe70bd5754ea763a62a066dc5913ca57e957824b72a85e205", size = 222828, upload-time = "2025-09-08T23:23:26.143Z" }, + { url = "https://files.pythonhosted.org/packages/c6/0f/cafacebd4b040e3119dcb32fed8bdef8dfe94da653155f9d0b9dc660166e/cffi-2.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:38100abb9d1b1435bc4cc340bb4489635dc2f0da7456590877030c9b3d40b0c1", size = 220926, upload-time = "2025-09-08T23:23:27.873Z" }, + { url = "https://files.pythonhosted.org/packages/3e/aa/df335faa45b395396fcbc03de2dfcab242cd61a9900e914fe682a59170b1/cffi-2.0.0-cp314-cp314-win32.whl", hash = "sha256:087067fa8953339c723661eda6b54bc98c5625757ea62e95eb4898ad5e776e9f", size = 175328, upload-time = "2025-09-08T23:23:44.61Z" }, + { url = "https://files.pythonhosted.org/packages/bb/92/882c2d30831744296ce713f0feb4c1cd30f346ef747b530b5318715cc367/cffi-2.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:203a48d1fb583fc7d78a4c6655692963b860a417c0528492a6bc21f1aaefab25", size = 185650, upload-time = "2025-09-08T23:23:45.848Z" }, + { url = "https://files.pythonhosted.org/packages/9f/2c/98ece204b9d35a7366b5b2c6539c350313ca13932143e79dc133ba757104/cffi-2.0.0-cp314-cp314-win_arm64.whl", hash = "sha256:dbd5c7a25a7cb98f5ca55d258b103a2054f859a46ae11aaf23134f9cc0d356ad", size = 180687, upload-time = "2025-09-08T23:23:47.105Z" }, + { url = "https://files.pythonhosted.org/packages/3e/61/c768e4d548bfa607abcda77423448df8c471f25dbe64fb2ef6d555eae006/cffi-2.0.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:9a67fc9e8eb39039280526379fb3a70023d77caec1852002b4da7e8b270c4dd9", size = 188773, upload-time = "2025-09-08T23:23:29.347Z" }, + { url = "https://files.pythonhosted.org/packages/2c/ea/5f76bce7cf6fcd0ab1a1058b5af899bfbef198bea4d5686da88471ea0336/cffi-2.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7a66c7204d8869299919db4d5069a82f1561581af12b11b3c9f48c584eb8743d", size = 185013, upload-time = "2025-09-08T23:23:30.63Z" }, + { url = "https://files.pythonhosted.org/packages/be/b4/c56878d0d1755cf9caa54ba71e5d049479c52f9e4afc230f06822162ab2f/cffi-2.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7cc09976e8b56f8cebd752f7113ad07752461f48a58cbba644139015ac24954c", size = 221593, upload-time = "2025-09-08T23:23:31.91Z" }, + { url = "https://files.pythonhosted.org/packages/e0/0d/eb704606dfe8033e7128df5e90fee946bbcb64a04fcdaa97321309004000/cffi-2.0.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:92b68146a71df78564e4ef48af17551a5ddd142e5190cdf2c5624d0c3ff5b2e8", size = 209354, upload-time = "2025-09-08T23:23:33.214Z" }, + { url = "https://files.pythonhosted.org/packages/d8/19/3c435d727b368ca475fb8742ab97c9cb13a0de600ce86f62eab7fa3eea60/cffi-2.0.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:b1e74d11748e7e98e2f426ab176d4ed720a64412b6a15054378afdb71e0f37dc", size = 208480, upload-time = "2025-09-08T23:23:34.495Z" }, + { url = "https://files.pythonhosted.org/packages/d0/44/681604464ed9541673e486521497406fadcc15b5217c3e326b061696899a/cffi-2.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:28a3a209b96630bca57cce802da70c266eb08c6e97e5afd61a75611ee6c64592", size = 221584, upload-time = "2025-09-08T23:23:36.096Z" }, + { url = "https://files.pythonhosted.org/packages/25/8e/342a504ff018a2825d395d44d63a767dd8ebc927ebda557fecdaca3ac33a/cffi-2.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7553fb2090d71822f02c629afe6042c299edf91ba1bf94951165613553984512", size = 224443, upload-time = "2025-09-08T23:23:37.328Z" }, + { url = "https://files.pythonhosted.org/packages/e1/5e/b666bacbbc60fbf415ba9988324a132c9a7a0448a9a8f125074671c0f2c3/cffi-2.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6c6c373cfc5c83a975506110d17457138c8c63016b563cc9ed6e056a82f13ce4", size = 223437, upload-time = "2025-09-08T23:23:38.945Z" }, + { url = "https://files.pythonhosted.org/packages/a0/1d/ec1a60bd1a10daa292d3cd6bb0b359a81607154fb8165f3ec95fe003b85c/cffi-2.0.0-cp314-cp314t-win32.whl", hash = "sha256:1fc9ea04857caf665289b7a75923f2c6ed559b8298a1b8c49e59f7dd95c8481e", size = 180487, upload-time = "2025-09-08T23:23:40.423Z" }, + { url = "https://files.pythonhosted.org/packages/bf/41/4c1168c74fac325c0c8156f04b6749c8b6a8f405bbf91413ba088359f60d/cffi-2.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:d68b6cef7827e8641e8ef16f4494edda8b36104d79773a334beaa1e3521430f6", size = 191726, upload-time = "2025-09-08T23:23:41.742Z" }, + { url = "https://files.pythonhosted.org/packages/ae/3a/dbeec9d1ee0844c679f6bb5d6ad4e9f198b1224f4e7a32825f47f6192b0c/cffi-2.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0a1527a803f0a659de1af2e1fd700213caba79377e27e4693648c2923da066f9", size = 184195, upload-time = "2025-09-08T23:23:43.004Z" }, +] + +[[package]] +name = "charset-normalizer" +version = "3.4.7" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e7/a1/67fe25fac3c7642725500a3f6cfe5821ad557c3abb11c9d20d12c7008d3e/charset_normalizer-3.4.7.tar.gz", hash = "sha256:ae89db9e5f98a11a4bf50407d4363e7b09b31e55bc117b4f7d80aab97ba009e5", size = 144271, upload-time = "2026-04-02T09:28:39.342Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c2/d7/b5b7020a0565c2e9fa8c09f4b5fa6232feb326b8c20081ccded47ea368fd/charset_normalizer-3.4.7-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:7641bb8895e77f921102f72833904dcd9901df5d6d72a2ab8f31d04b7e51e4e7", size = 309705, upload-time = "2026-04-02T09:26:02.191Z" }, + { url = "https://files.pythonhosted.org/packages/5a/53/58c29116c340e5456724ecd2fff4196d236b98f3da97b404bc5e51ac3493/charset_normalizer-3.4.7-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:202389074300232baeb53ae2569a60901f7efadd4245cf3a3bf0617d60b439d7", size = 206419, upload-time = "2026-04-02T09:26:03.583Z" }, + { url = "https://files.pythonhosted.org/packages/b2/02/e8146dc6591a37a00e5144c63f29fb7c97a734ea8a111190783c0e60ab63/charset_normalizer-3.4.7-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:30b8d1d8c52a48c2c5690e152c169b673487a2a58de1ec7393196753063fcd5e", size = 227901, upload-time = "2026-04-02T09:26:04.738Z" }, + { url = "https://files.pythonhosted.org/packages/fb/73/77486c4cd58f1267bf17db420e930c9afa1b3be3fe8c8b8ebbebc9624359/charset_normalizer-3.4.7-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:532bc9bf33a68613fd7d65e4b1c71a6a38d7d42604ecf239c77392e9b4e8998c", size = 222742, upload-time = "2026-04-02T09:26:06.36Z" }, + { url = "https://files.pythonhosted.org/packages/a1/fa/f74eb381a7d94ded44739e9d94de18dc5edc9c17fb8c11f0a6890696c0a9/charset_normalizer-3.4.7-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2fe249cb4651fd12605b7288b24751d8bfd46d35f12a20b1ba33dea122e690df", size = 214061, upload-time = "2026-04-02T09:26:08.347Z" }, + { url = "https://files.pythonhosted.org/packages/dc/92/42bd3cefcf7687253fb86694b45f37b733c97f59af3724f356fa92b8c344/charset_normalizer-3.4.7-cp311-cp311-manylinux_2_31_armv7l.whl", hash = "sha256:65bcd23054beab4d166035cabbc868a09c1a49d1efe458fe8e4361215df40265", size = 199239, upload-time = "2026-04-02T09:26:09.823Z" }, + { url = "https://files.pythonhosted.org/packages/4c/3d/069e7184e2aa3b3cddc700e3dd267413dc259854adc3380421c805c6a17d/charset_normalizer-3.4.7-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:08e721811161356f97b4059a9ba7bafb23ea5ee2255402c42881c214e173c6b4", size = 210173, upload-time = "2026-04-02T09:26:10.953Z" }, + { url = "https://files.pythonhosted.org/packages/62/51/9d56feb5f2e7074c46f93e0ebdbe61f0848ee246e2f0d89f8e20b89ebb8f/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:e060d01aec0a910bdccb8be71faf34e7799ce36950f8294c8bf612cba65a2c9e", size = 209841, upload-time = "2026-04-02T09:26:12.142Z" }, + { url = "https://files.pythonhosted.org/packages/d2/59/893d8f99cc4c837dda1fe2f1139079703deb9f321aabcb032355de13b6c7/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:38c0109396c4cfc574d502df99742a45c72c08eff0a36158b6f04000043dbf38", size = 200304, upload-time = "2026-04-02T09:26:13.711Z" }, + { url = "https://files.pythonhosted.org/packages/7d/1d/ee6f3be3464247578d1ed5c46de545ccc3d3ff933695395c402c21fa6b77/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:1c2a768fdd44ee4a9339a9b0b130049139b8ce3c01d2ce09f67f5a68048d477c", size = 229455, upload-time = "2026-04-02T09:26:14.941Z" }, + { url = "https://files.pythonhosted.org/packages/54/bb/8fb0a946296ea96a488928bdce8ef99023998c48e4713af533e9bb98ef07/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:1a87ca9d5df6fe460483d9a5bbf2b18f620cbed41b432e2bddb686228282d10b", size = 210036, upload-time = "2026-04-02T09:26:16.478Z" }, + { url = "https://files.pythonhosted.org/packages/9a/bc/015b2387f913749f82afd4fcba07846d05b6d784dd16123cb66860e0237d/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:d635aab80466bc95771bb78d5370e74d36d1fe31467b6b29b8b57b2a3cd7d22c", size = 224739, upload-time = "2026-04-02T09:26:17.751Z" }, + { url = "https://files.pythonhosted.org/packages/17/ab/63133691f56baae417493cba6b7c641571a2130eb7bceba6773367ab9ec5/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ae196f021b5e7c78e918242d217db021ed2a6ace2bc6ae94c0fc596221c7f58d", size = 216277, upload-time = "2026-04-02T09:26:18.981Z" }, + { url = "https://files.pythonhosted.org/packages/06/6d/3be70e827977f20db77c12a97e6a9f973631a45b8d186c084527e53e77a4/charset_normalizer-3.4.7-cp311-cp311-win32.whl", hash = "sha256:adb2597b428735679446b46c8badf467b4ca5f5056aae4d51a19f9570301b1ad", size = 147819, upload-time = "2026-04-02T09:26:20.295Z" }, + { url = "https://files.pythonhosted.org/packages/20/d9/5f67790f06b735d7c7637171bbfd89882ad67201891b7275e51116ed8207/charset_normalizer-3.4.7-cp311-cp311-win_amd64.whl", hash = "sha256:8e385e4267ab76874ae30db04c627faaaf0b509e1ccc11a95b3fc3e83f855c00", size = 159281, upload-time = "2026-04-02T09:26:21.74Z" }, + { url = "https://files.pythonhosted.org/packages/ca/83/6413f36c5a34afead88ce6f66684d943d91f233d76dd083798f9602b75ae/charset_normalizer-3.4.7-cp311-cp311-win_arm64.whl", hash = "sha256:d4a48e5b3c2a489fae013b7589308a40146ee081f6f509e047e0e096084ceca1", size = 147843, upload-time = "2026-04-02T09:26:22.901Z" }, + { url = "https://files.pythonhosted.org/packages/0c/eb/4fc8d0a7110eb5fc9cc161723a34a8a6c200ce3b4fbf681bc86feee22308/charset_normalizer-3.4.7-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:eca9705049ad3c7345d574e3510665cb2cf844c2f2dcfe675332677f081cbd46", size = 311328, upload-time = "2026-04-02T09:26:24.331Z" }, + { url = "https://files.pythonhosted.org/packages/f8/e3/0fadc706008ac9d7b9b5be6dc767c05f9d3e5df51744ce4cc9605de7b9f4/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6178f72c5508bfc5fd446a5905e698c6212932f25bcdd4b47a757a50605a90e2", size = 208061, upload-time = "2026-04-02T09:26:25.568Z" }, + { url = "https://files.pythonhosted.org/packages/42/f0/3dd1045c47f4a4604df85ec18ad093912ae1344ac706993aff91d38773a2/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e1421b502d83040e6d7fb2fb18dff63957f720da3d77b2fbd3187ceb63755d7b", size = 229031, upload-time = "2026-04-02T09:26:26.865Z" }, + { url = "https://files.pythonhosted.org/packages/dc/67/675a46eb016118a2fbde5a277a5d15f4f69d5f3f5f338e5ee2f8948fcf43/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:edac0f1ab77644605be2cbba52e6b7f630731fc42b34cb0f634be1a6eface56a", size = 225239, upload-time = "2026-04-02T09:26:28.044Z" }, + { url = "https://files.pythonhosted.org/packages/4b/f8/d0118a2f5f23b02cd166fa385c60f9b0d4f9194f574e2b31cef350ad7223/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5649fd1c7bade02f320a462fdefd0b4bd3ce036065836d4f42e0de958038e116", size = 216589, upload-time = "2026-04-02T09:26:29.239Z" }, + { url = "https://files.pythonhosted.org/packages/b1/f1/6d2b0b261b6c4ceef0fcb0d17a01cc5bc53586c2d4796fa04b5c540bc13d/charset_normalizer-3.4.7-cp312-cp312-manylinux_2_31_armv7l.whl", hash = "sha256:203104ed3e428044fd943bc4bf45fa73c0730391f9621e37fe39ecf477b128cb", size = 202733, upload-time = "2026-04-02T09:26:30.5Z" }, + { url = "https://files.pythonhosted.org/packages/6f/c0/7b1f943f7e87cc3db9626ba17807d042c38645f0a1d4415c7a14afb5591f/charset_normalizer-3.4.7-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:298930cec56029e05497a76988377cbd7457ba864beeea92ad7e844fe74cd1f1", size = 212652, upload-time = "2026-04-02T09:26:31.709Z" }, + { url = "https://files.pythonhosted.org/packages/38/dd/5a9ab159fe45c6e72079398f277b7d2b523e7f716acc489726115a910097/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:708838739abf24b2ceb208d0e22403dd018faeef86ddac04319a62ae884c4f15", size = 211229, upload-time = "2026-04-02T09:26:33.282Z" }, + { url = "https://files.pythonhosted.org/packages/d5/ff/531a1cad5ca855d1c1a8b69cb71abfd6d85c0291580146fda7c82857caa1/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:0f7eb884681e3938906ed0434f20c63046eacd0111c4ba96f27b76084cd679f5", size = 203552, upload-time = "2026-04-02T09:26:34.845Z" }, + { url = "https://files.pythonhosted.org/packages/c1/4c/a5fb52d528a8ca41f7598cb619409ece30a169fbdf9cdce592e53b46c3a6/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:4dc1e73c36828f982bfe79fadf5919923f8a6f4df2860804db9a98c48824ce8d", size = 230806, upload-time = "2026-04-02T09:26:36.152Z" }, + { url = "https://files.pythonhosted.org/packages/59/7a/071feed8124111a32b316b33ae4de83d36923039ef8cf48120266844285b/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:aed52fea0513bac0ccde438c188c8a471c4e0f457c2dd20cdbf6ea7a450046c7", size = 212316, upload-time = "2026-04-02T09:26:37.672Z" }, + { url = "https://files.pythonhosted.org/packages/fd/35/f7dba3994312d7ba508e041eaac39a36b120f32d4c8662b8814dab876431/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:fea24543955a6a729c45a73fe90e08c743f0b3334bbf3201e6c4bc1b0c7fa464", size = 227274, upload-time = "2026-04-02T09:26:38.93Z" }, + { url = "https://files.pythonhosted.org/packages/8a/2d/a572df5c9204ab7688ec1edc895a73ebded3b023bb07364710b05dd1c9be/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:bb6d88045545b26da47aa879dd4a89a71d1dce0f0e549b1abcb31dfe4a8eac49", size = 218468, upload-time = "2026-04-02T09:26:40.17Z" }, + { url = "https://files.pythonhosted.org/packages/86/eb/890922a8b03a568ca2f336c36585a4713c55d4d67bf0f0c78924be6315ca/charset_normalizer-3.4.7-cp312-cp312-win32.whl", hash = "sha256:2257141f39fe65a3fdf38aeccae4b953e5f3b3324f4ff0daf9f15b8518666a2c", size = 148460, upload-time = "2026-04-02T09:26:41.416Z" }, + { url = "https://files.pythonhosted.org/packages/35/d9/0e7dffa06c5ab081f75b1b786f0aefc88365825dfcd0ac544bdb7b2b6853/charset_normalizer-3.4.7-cp312-cp312-win_amd64.whl", hash = "sha256:5ed6ab538499c8644b8a3e18debabcd7ce684f3fa91cf867521a7a0279cab2d6", size = 159330, upload-time = "2026-04-02T09:26:42.554Z" }, + { url = "https://files.pythonhosted.org/packages/9e/5d/481bcc2a7c88ea6b0878c299547843b2521ccbc40980cb406267088bc701/charset_normalizer-3.4.7-cp312-cp312-win_arm64.whl", hash = "sha256:56be790f86bfb2c98fb742ce566dfb4816e5a83384616ab59c49e0604d49c51d", size = 147828, upload-time = "2026-04-02T09:26:44.075Z" }, + { url = "https://files.pythonhosted.org/packages/c1/3b/66777e39d3ae1ddc77ee606be4ec6d8cbd4c801f65e5a1b6f2b11b8346dd/charset_normalizer-3.4.7-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:f496c9c3cc02230093d8330875c4c3cdfc3b73612a5fd921c65d39cbcef08063", size = 309627, upload-time = "2026-04-02T09:26:45.198Z" }, + { url = "https://files.pythonhosted.org/packages/2e/4e/b7f84e617b4854ade48a1b7915c8ccfadeba444d2a18c291f696e37f0d3b/charset_normalizer-3.4.7-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0ea948db76d31190bf08bd371623927ee1339d5f2a0b4b1b4a4439a65298703c", size = 207008, upload-time = "2026-04-02T09:26:46.824Z" }, + { url = "https://files.pythonhosted.org/packages/c4/bb/ec73c0257c9e11b268f018f068f5d00aa0ef8c8b09f7753ebd5f2880e248/charset_normalizer-3.4.7-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a277ab8928b9f299723bc1a2dabb1265911b1a76341f90a510368ca44ad9ab66", size = 228303, upload-time = "2026-04-02T09:26:48.397Z" }, + { url = "https://files.pythonhosted.org/packages/85/fb/32d1f5033484494619f701e719429c69b766bfc4dbc61aa9e9c8c166528b/charset_normalizer-3.4.7-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3bec022aec2c514d9cf199522a802bd007cd588ab17ab2525f20f9c34d067c18", size = 224282, upload-time = "2026-04-02T09:26:49.684Z" }, + { url = "https://files.pythonhosted.org/packages/fa/07/330e3a0dda4c404d6da83b327270906e9654a24f6c546dc886a0eb0ffb23/charset_normalizer-3.4.7-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e044c39e41b92c845bc815e5ae4230804e8e7bc29e399b0437d64222d92809dd", size = 215595, upload-time = "2026-04-02T09:26:50.915Z" }, + { url = "https://files.pythonhosted.org/packages/e3/7c/fc890655786e423f02556e0216d4b8c6bcb6bdfa890160dc66bf52dee468/charset_normalizer-3.4.7-cp313-cp313-manylinux_2_31_armv7l.whl", hash = "sha256:f495a1652cf3fbab2eb0639776dad966c2fb874d79d87ca07f9d5f059b8bd215", size = 201986, upload-time = "2026-04-02T09:26:52.197Z" }, + { url = "https://files.pythonhosted.org/packages/d8/97/bfb18b3db2aed3b90cf54dc292ad79fdd5ad65c4eae454099475cbeadd0d/charset_normalizer-3.4.7-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e712b419df8ba5e42b226c510472b37bd57b38e897d3eca5e8cfd410a29fa859", size = 211711, upload-time = "2026-04-02T09:26:53.49Z" }, + { url = "https://files.pythonhosted.org/packages/6f/a5/a581c13798546a7fd557c82614a5c65a13df2157e9ad6373166d2a3e645d/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:7804338df6fcc08105c7745f1502ba68d900f45fd770d5bdd5288ddccb8a42d8", size = 210036, upload-time = "2026-04-02T09:26:54.975Z" }, + { url = "https://files.pythonhosted.org/packages/8c/bf/b3ab5bcb478e4193d517644b0fb2bf5497fbceeaa7a1bc0f4d5b50953861/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:481551899c856c704d58119b5025793fa6730adda3571971af568f66d2424bb5", size = 202998, upload-time = "2026-04-02T09:26:56.303Z" }, + { url = "https://files.pythonhosted.org/packages/e7/4e/23efd79b65d314fa320ec6017b4b5834d5c12a58ba4610aa353af2e2f577/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:f59099f9b66f0d7145115e6f80dd8b1d847176df89b234a5a6b3f00437aa0832", size = 230056, upload-time = "2026-04-02T09:26:57.554Z" }, + { url = "https://files.pythonhosted.org/packages/b9/9f/1e1941bc3f0e01df116e68dc37a55c4d249df5e6fa77f008841aef68264f/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:f59ad4c0e8f6bba240a9bb85504faa1ab438237199d4cce5f622761507b8f6a6", size = 211537, upload-time = "2026-04-02T09:26:58.843Z" }, + { url = "https://files.pythonhosted.org/packages/80/0f/088cbb3020d44428964a6c97fe1edfb1b9550396bf6d278330281e8b709c/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:3dedcc22d73ec993f42055eff4fcfed9318d1eeb9a6606c55892a26964964e48", size = 226176, upload-time = "2026-04-02T09:27:00.437Z" }, + { url = "https://files.pythonhosted.org/packages/6a/9f/130394f9bbe06f4f63e22641d32fc9b202b7e251c9aef4db044324dac493/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:64f02c6841d7d83f832cd97ccf8eb8a906d06eb95d5276069175c696b024b60a", size = 217723, upload-time = "2026-04-02T09:27:02.021Z" }, + { url = "https://files.pythonhosted.org/packages/73/55/c469897448a06e49f8fa03f6caae97074fde823f432a98f979cc42b90e69/charset_normalizer-3.4.7-cp313-cp313-win32.whl", hash = "sha256:4042d5c8f957e15221d423ba781e85d553722fc4113f523f2feb7b188cc34c5e", size = 148085, upload-time = "2026-04-02T09:27:03.192Z" }, + { url = "https://files.pythonhosted.org/packages/5d/78/1b74c5bbb3f99b77a1715c91b3e0b5bdb6fe302d95ace4f5b1bec37b0167/charset_normalizer-3.4.7-cp313-cp313-win_amd64.whl", hash = "sha256:3946fa46a0cf3e4c8cb1cc52f56bb536310d34f25f01ca9b6c16afa767dab110", size = 158819, upload-time = "2026-04-02T09:27:04.454Z" }, + { url = "https://files.pythonhosted.org/packages/68/86/46bd42279d323deb8687c4a5a811fd548cb7d1de10cf6535d099877a9a9f/charset_normalizer-3.4.7-cp313-cp313-win_arm64.whl", hash = "sha256:80d04837f55fc81da168b98de4f4b797ef007fc8a79ab71c6ec9bc4dd662b15b", size = 147915, upload-time = "2026-04-02T09:27:05.971Z" }, + { url = "https://files.pythonhosted.org/packages/97/c8/c67cb8c70e19ef1960b97b22ed2a1567711de46c4ddf19799923adc836c2/charset_normalizer-3.4.7-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:c36c333c39be2dbca264d7803333c896ab8fa7d4d6f0ab7edb7dfd7aea6e98c0", size = 309234, upload-time = "2026-04-02T09:27:07.194Z" }, + { url = "https://files.pythonhosted.org/packages/99/85/c091fdee33f20de70d6c8b522743b6f831a2f1cd3ff86de4c6a827c48a76/charset_normalizer-3.4.7-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1c2aed2e5e41f24ea8ef1590b8e848a79b56f3a5564a65ceec43c9d692dc7d8a", size = 208042, upload-time = "2026-04-02T09:27:08.749Z" }, + { url = "https://files.pythonhosted.org/packages/87/1c/ab2ce611b984d2fd5d86a5a8a19c1ae26acac6bad967da4967562c75114d/charset_normalizer-3.4.7-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:54523e136b8948060c0fa0bc7b1b50c32c186f2fceee897a495406bb6e311d2b", size = 228706, upload-time = "2026-04-02T09:27:09.951Z" }, + { url = "https://files.pythonhosted.org/packages/a8/29/2b1d2cb00bf085f59d29eb773ce58ec2d325430f8c216804a0a5cd83cbca/charset_normalizer-3.4.7-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:715479b9a2802ecac752a3b0efa2b0b60285cf962ee38414211abdfccc233b41", size = 224727, upload-time = "2026-04-02T09:27:11.175Z" }, + { url = "https://files.pythonhosted.org/packages/47/5c/032c2d5a07fe4d4855fea851209cca2b6f03ebeb6d4e3afdb3358386a684/charset_normalizer-3.4.7-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bd6c2a1c7573c64738d716488d2cdd3c00e340e4835707d8fdb8dc1a66ef164e", size = 215882, upload-time = "2026-04-02T09:27:12.446Z" }, + { url = "https://files.pythonhosted.org/packages/2c/c2/356065d5a8b78ed04499cae5f339f091946a6a74f91e03476c33f0ab7100/charset_normalizer-3.4.7-cp314-cp314-manylinux_2_31_armv7l.whl", hash = "sha256:c45e9440fb78f8ddabcf714b68f936737a121355bf59f3907f4e17721b9d1aae", size = 200860, upload-time = "2026-04-02T09:27:13.721Z" }, + { url = "https://files.pythonhosted.org/packages/0c/cd/a32a84217ced5039f53b29f460962abb2d4420def55afabe45b1c3c7483d/charset_normalizer-3.4.7-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3534e7dcbdcf757da6b85a0bbf5b6868786d5982dd959b065e65481644817a18", size = 211564, upload-time = "2026-04-02T09:27:15.272Z" }, + { url = "https://files.pythonhosted.org/packages/44/86/58e6f13ce26cc3b8f4a36b94a0f22ae2f00a72534520f4ae6857c4b81f89/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:e8ac484bf18ce6975760921bb6148041faa8fef0547200386ea0b52b5d27bf7b", size = 211276, upload-time = "2026-04-02T09:27:16.834Z" }, + { url = "https://files.pythonhosted.org/packages/8f/fe/d17c32dc72e17e155e06883efa84514ca375f8a528ba2546bee73fc4df81/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:a5fe03b42827c13cdccd08e6c0247b6a6d4b5e3cdc53fd1749f5896adcdc2356", size = 201238, upload-time = "2026-04-02T09:27:18.229Z" }, + { url = "https://files.pythonhosted.org/packages/6a/29/f33daa50b06525a237451cdb6c69da366c381a3dadcd833fa5676bc468b3/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:2d6eb928e13016cea4f1f21d1e10c1cebd5a421bc57ddf5b1142ae3f86824fab", size = 230189, upload-time = "2026-04-02T09:27:19.445Z" }, + { url = "https://files.pythonhosted.org/packages/b6/6e/52c84015394a6a0bdcd435210a7e944c5f94ea1055f5cc5d56c5fe368e7b/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:e74327fb75de8986940def6e8dee4f127cc9752bee7355bb323cc5b2659b6d46", size = 211352, upload-time = "2026-04-02T09:27:20.79Z" }, + { url = "https://files.pythonhosted.org/packages/8c/d7/4353be581b373033fb9198bf1da3cf8f09c1082561e8e922aa7b39bf9fe8/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:d6038d37043bced98a66e68d3aa2b6a35505dc01328cd65217cefe82f25def44", size = 227024, upload-time = "2026-04-02T09:27:22.063Z" }, + { url = "https://files.pythonhosted.org/packages/30/45/99d18aa925bd1740098ccd3060e238e21115fffbfdcb8f3ece837d0ace6c/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:7579e913a5339fb8fa133f6bbcfd8e6749696206cf05acdbdca71a1b436d8e72", size = 217869, upload-time = "2026-04-02T09:27:23.486Z" }, + { url = "https://files.pythonhosted.org/packages/5c/05/5ee478aa53f4bb7996482153d4bfe1b89e0f087f0ab6b294fcf92d595873/charset_normalizer-3.4.7-cp314-cp314-win32.whl", hash = "sha256:5b77459df20e08151cd6f8b9ef8ef1f961ef73d85c21a555c7eed5b79410ec10", size = 148541, upload-time = "2026-04-02T09:27:25.146Z" }, + { url = "https://files.pythonhosted.org/packages/48/77/72dcb0921b2ce86420b2d79d454c7022bf5be40202a2a07906b9f2a35c97/charset_normalizer-3.4.7-cp314-cp314-win_amd64.whl", hash = "sha256:92a0a01ead5e668468e952e4238cccd7c537364eb7d851ab144ab6627dbbe12f", size = 159634, upload-time = "2026-04-02T09:27:26.642Z" }, + { url = "https://files.pythonhosted.org/packages/c6/a3/c2369911cd72f02386e4e340770f6e158c7980267da16af8f668217abaa0/charset_normalizer-3.4.7-cp314-cp314-win_arm64.whl", hash = "sha256:67f6279d125ca0046a7fd386d01b311c6363844deac3e5b069b514ba3e63c246", size = 148384, upload-time = "2026-04-02T09:27:28.271Z" }, + { url = "https://files.pythonhosted.org/packages/94/09/7e8a7f73d24dba1f0035fbbf014d2c36828fc1bf9c88f84093e57d315935/charset_normalizer-3.4.7-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:effc3f449787117233702311a1b7d8f59cba9ced946ba727bdc329ec69028e24", size = 330133, upload-time = "2026-04-02T09:27:29.474Z" }, + { url = "https://files.pythonhosted.org/packages/8d/da/96975ddb11f8e977f706f45cddd8540fd8242f71ecdb5d18a80723dcf62c/charset_normalizer-3.4.7-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fbccdc05410c9ee21bbf16a35f4c1d16123dcdeb8a1d38f33654fa21d0234f79", size = 216257, upload-time = "2026-04-02T09:27:30.793Z" }, + { url = "https://files.pythonhosted.org/packages/e5/e8/1d63bf8ef2d388e95c64b2098f45f84758f6d102a087552da1485912637b/charset_normalizer-3.4.7-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:733784b6d6def852c814bce5f318d25da2ee65dd4839a0718641c696e09a2960", size = 234851, upload-time = "2026-04-02T09:27:32.44Z" }, + { url = "https://files.pythonhosted.org/packages/9b/40/e5ff04233e70da2681fa43969ad6f66ca5611d7e669be0246c4c7aaf6dc8/charset_normalizer-3.4.7-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a89c23ef8d2c6b27fd200a42aa4ac72786e7c60d40efdc76e6011260b6e949c4", size = 233393, upload-time = "2026-04-02T09:27:34.03Z" }, + { url = "https://files.pythonhosted.org/packages/be/c1/06c6c49d5a5450f76899992f1ee40b41d076aee9279b49cf9974d2f313d5/charset_normalizer-3.4.7-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6c114670c45346afedc0d947faf3c7f701051d2518b943679c8ff88befe14f8e", size = 223251, upload-time = "2026-04-02T09:27:35.369Z" }, + { url = "https://files.pythonhosted.org/packages/2b/9f/f2ff16fb050946169e3e1f82134d107e5d4ae72647ec8a1b1446c148480f/charset_normalizer-3.4.7-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:a180c5e59792af262bf263b21a3c49353f25945d8d9f70628e73de370d55e1e1", size = 206609, upload-time = "2026-04-02T09:27:36.661Z" }, + { url = "https://files.pythonhosted.org/packages/69/d5/a527c0cd8d64d2eab7459784fb4169a0ac76e5a6fc5237337982fd61347e/charset_normalizer-3.4.7-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3c9a494bc5ec77d43cea229c4f6db1e4d8fe7e1bbffa8b6f0f0032430ff8ab44", size = 220014, upload-time = "2026-04-02T09:27:38.019Z" }, + { url = "https://files.pythonhosted.org/packages/7e/80/8a7b8104a3e203074dc9aa2c613d4b726c0e136bad1cc734594b02867972/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8d828b6667a32a728a1ad1d93957cdf37489c57b97ae6c4de2860fa749b8fc1e", size = 218979, upload-time = "2026-04-02T09:27:39.37Z" }, + { url = "https://files.pythonhosted.org/packages/02/9a/b759b503d507f375b2b5c153e4d2ee0a75aa215b7f2489cf314f4541f2c0/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:cf1493cd8607bec4d8a7b9b004e699fcf8f9103a9284cc94962cb73d20f9d4a3", size = 209238, upload-time = "2026-04-02T09:27:40.722Z" }, + { url = "https://files.pythonhosted.org/packages/c2/4e/0f3f5d47b86bdb79256e7290b26ac847a2832d9a4033f7eb2cd4bcf4bb5b/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:0c96c3b819b5c3e9e165495db84d41914d6894d55181d2d108cc1a69bfc9cce0", size = 236110, upload-time = "2026-04-02T09:27:42.33Z" }, + { url = "https://files.pythonhosted.org/packages/96/23/bce28734eb3ed2c91dcf93abeb8a5cf393a7b2749725030bb630e554fdd8/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:752a45dc4a6934060b3b0dab47e04edc3326575f82be64bc4fc293914566503e", size = 219824, upload-time = "2026-04-02T09:27:43.924Z" }, + { url = "https://files.pythonhosted.org/packages/2c/6f/6e897c6984cc4d41af319b077f2f600fc8214eb2fe2d6bcb79141b882400/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:8778f0c7a52e56f75d12dae53ae320fae900a8b9b4164b981b9c5ce059cd1fcb", size = 233103, upload-time = "2026-04-02T09:27:45.348Z" }, + { url = "https://files.pythonhosted.org/packages/76/22/ef7bd0fe480a0ae9b656189ec00744b60933f68b4f42a7bb06589f6f576a/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ce3412fbe1e31eb81ea42f4169ed94861c56e643189e1e75f0041f3fe7020abe", size = 225194, upload-time = "2026-04-02T09:27:46.706Z" }, + { url = "https://files.pythonhosted.org/packages/c5/a7/0e0ab3e0b5bc1219bd80a6a0d4d72ca74d9250cb2382b7c699c147e06017/charset_normalizer-3.4.7-cp314-cp314t-win32.whl", hash = "sha256:c03a41a8784091e67a39648f70c5f97b5b6a37f216896d44d2cdcb82615339a0", size = 159827, upload-time = "2026-04-02T09:27:48.053Z" }, + { url = "https://files.pythonhosted.org/packages/7a/1d/29d32e0fb40864b1f878c7f5a0b343ae676c6e2b271a2d55cc3a152391da/charset_normalizer-3.4.7-cp314-cp314t-win_amd64.whl", hash = "sha256:03853ed82eeebbce3c2abfdbc98c96dc205f32a79627688ac9a27370ea61a49c", size = 174168, upload-time = "2026-04-02T09:27:49.795Z" }, + { url = "https://files.pythonhosted.org/packages/de/32/d92444ad05c7a6e41fb2036749777c163baf7a0301a040cb672d6b2b1ae9/charset_normalizer-3.4.7-cp314-cp314t-win_arm64.whl", hash = "sha256:c35abb8bfff0185efac5878da64c45dafd2b37fb0383add1be155a763c1f083d", size = 153018, upload-time = "2026-04-02T09:27:51.116Z" }, + { url = "https://files.pythonhosted.org/packages/db/8f/61959034484a4a7c527811f4721e75d02d653a35afb0b6054474d8185d4c/charset_normalizer-3.4.7-py3-none-any.whl", hash = "sha256:3dce51d0f5e7951f8bb4900c257dad282f49190fdbebecd4ba99bcc41fef404d", size = 61958, upload-time = "2026-04-02T09:28:37.794Z" }, +] + +[[package]] +name = "colorama" +version = "0.4.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" }, +] + +[[package]] +name = "contourpy" +version = "1.3.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/58/01/1253e6698a07380cd31a736d248a3f2a50a7c88779a1813da27503cadc2a/contourpy-1.3.3.tar.gz", hash = "sha256:083e12155b210502d0bca491432bb04d56dc3432f95a979b429f2848c3dbe880", size = 13466174, upload-time = "2025-07-26T12:03:12.549Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/91/2e/c4390a31919d8a78b90e8ecf87cd4b4c4f05a5b48d05ec17db8e5404c6f4/contourpy-1.3.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:709a48ef9a690e1343202916450bc48b9e51c049b089c7f79a267b46cffcdaa1", size = 288773, upload-time = "2025-07-26T12:01:02.277Z" }, + { url = "https://files.pythonhosted.org/packages/0d/44/c4b0b6095fef4dc9c420e041799591e3b63e9619e3044f7f4f6c21c0ab24/contourpy-1.3.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:23416f38bfd74d5d28ab8429cc4d63fa67d5068bd711a85edb1c3fb0c3e2f381", size = 270149, upload-time = "2025-07-26T12:01:04.072Z" }, + { url = "https://files.pythonhosted.org/packages/30/2e/dd4ced42fefac8470661d7cb7e264808425e6c5d56d175291e93890cce09/contourpy-1.3.3-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:929ddf8c4c7f348e4c0a5a3a714b5c8542ffaa8c22954862a46ca1813b667ee7", size = 329222, upload-time = "2025-07-26T12:01:05.688Z" }, + { url = "https://files.pythonhosted.org/packages/f2/74/cc6ec2548e3d276c71389ea4802a774b7aa3558223b7bade3f25787fafc2/contourpy-1.3.3-cp311-cp311-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9e999574eddae35f1312c2b4b717b7885d4edd6cb46700e04f7f02db454e67c1", size = 377234, upload-time = "2025-07-26T12:01:07.054Z" }, + { url = "https://files.pythonhosted.org/packages/03/b3/64ef723029f917410f75c09da54254c5f9ea90ef89b143ccadb09df14c15/contourpy-1.3.3-cp311-cp311-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0bf67e0e3f482cb69779dd3061b534eb35ac9b17f163d851e2a547d56dba0a3a", size = 380555, upload-time = "2025-07-26T12:01:08.801Z" }, + { url = "https://files.pythonhosted.org/packages/5f/4b/6157f24ca425b89fe2eb7e7be642375711ab671135be21e6faa100f7448c/contourpy-1.3.3-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:51e79c1f7470158e838808d4a996fa9bac72c498e93d8ebe5119bc1e6becb0db", size = 355238, upload-time = "2025-07-26T12:01:10.319Z" }, + { url = "https://files.pythonhosted.org/packages/98/56/f914f0dd678480708a04cfd2206e7c382533249bc5001eb9f58aa693e200/contourpy-1.3.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:598c3aaece21c503615fd59c92a3598b428b2f01bfb4b8ca9c4edeecc2438620", size = 1326218, upload-time = "2025-07-26T12:01:12.659Z" }, + { url = "https://files.pythonhosted.org/packages/fb/d7/4a972334a0c971acd5172389671113ae82aa7527073980c38d5868ff1161/contourpy-1.3.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:322ab1c99b008dad206d406bb61d014cf0174df491ae9d9d0fac6a6fda4f977f", size = 1392867, upload-time = "2025-07-26T12:01:15.533Z" }, + { url = "https://files.pythonhosted.org/packages/75/3e/f2cc6cd56dc8cff46b1a56232eabc6feea52720083ea71ab15523daab796/contourpy-1.3.3-cp311-cp311-win32.whl", hash = "sha256:fd907ae12cd483cd83e414b12941c632a969171bf90fc937d0c9f268a31cafff", size = 183677, upload-time = "2025-07-26T12:01:17.088Z" }, + { url = "https://files.pythonhosted.org/packages/98/4b/9bd370b004b5c9d8045c6c33cf65bae018b27aca550a3f657cdc99acdbd8/contourpy-1.3.3-cp311-cp311-win_amd64.whl", hash = "sha256:3519428f6be58431c56581f1694ba8e50626f2dd550af225f82fb5f5814d2a42", size = 225234, upload-time = "2025-07-26T12:01:18.256Z" }, + { url = "https://files.pythonhosted.org/packages/d9/b6/71771e02c2e004450c12b1120a5f488cad2e4d5b590b1af8bad060360fe4/contourpy-1.3.3-cp311-cp311-win_arm64.whl", hash = "sha256:15ff10bfada4bf92ec8b31c62bf7c1834c244019b4a33095a68000d7075df470", size = 193123, upload-time = "2025-07-26T12:01:19.848Z" }, + { url = "https://files.pythonhosted.org/packages/be/45/adfee365d9ea3d853550b2e735f9d66366701c65db7855cd07621732ccfc/contourpy-1.3.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b08a32ea2f8e42cf1d4be3169a98dd4be32bafe4f22b6c4cb4ba810fa9e5d2cb", size = 293419, upload-time = "2025-07-26T12:01:21.16Z" }, + { url = "https://files.pythonhosted.org/packages/53/3e/405b59cfa13021a56bba395a6b3aca8cec012b45bf177b0eaf7a202cde2c/contourpy-1.3.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:556dba8fb6f5d8742f2923fe9457dbdd51e1049c4a43fd3986a0b14a1d815fc6", size = 273979, upload-time = "2025-07-26T12:01:22.448Z" }, + { url = "https://files.pythonhosted.org/packages/d4/1c/a12359b9b2ca3a845e8f7f9ac08bdf776114eb931392fcad91743e2ea17b/contourpy-1.3.3-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92d9abc807cf7d0e047b95ca5d957cf4792fcd04e920ca70d48add15c1a90ea7", size = 332653, upload-time = "2025-07-26T12:01:24.155Z" }, + { url = "https://files.pythonhosted.org/packages/63/12/897aeebfb475b7748ea67b61e045accdfcf0d971f8a588b67108ed7f5512/contourpy-1.3.3-cp312-cp312-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b2e8faa0ed68cb29af51edd8e24798bb661eac3bd9f65420c1887b6ca89987c8", size = 379536, upload-time = "2025-07-26T12:01:25.91Z" }, + { url = "https://files.pythonhosted.org/packages/43/8a/a8c584b82deb248930ce069e71576fc09bd7174bbd35183b7943fb1064fd/contourpy-1.3.3-cp312-cp312-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:626d60935cf668e70a5ce6ff184fd713e9683fb458898e4249b63be9e28286ea", size = 384397, upload-time = "2025-07-26T12:01:27.152Z" }, + { url = "https://files.pythonhosted.org/packages/cc/8f/ec6289987824b29529d0dfda0d74a07cec60e54b9c92f3c9da4c0ac732de/contourpy-1.3.3-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4d00e655fcef08aba35ec9610536bfe90267d7ab5ba944f7032549c55a146da1", size = 362601, upload-time = "2025-07-26T12:01:28.808Z" }, + { url = "https://files.pythonhosted.org/packages/05/0a/a3fe3be3ee2dceb3e615ebb4df97ae6f3828aa915d3e10549ce016302bd1/contourpy-1.3.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:451e71b5a7d597379ef572de31eeb909a87246974d960049a9848c3bc6c41bf7", size = 1331288, upload-time = "2025-07-26T12:01:31.198Z" }, + { url = "https://files.pythonhosted.org/packages/33/1d/acad9bd4e97f13f3e2b18a3977fe1b4a37ecf3d38d815333980c6c72e963/contourpy-1.3.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:459c1f020cd59fcfe6650180678a9993932d80d44ccde1fa1868977438f0b411", size = 1403386, upload-time = "2025-07-26T12:01:33.947Z" }, + { url = "https://files.pythonhosted.org/packages/cf/8f/5847f44a7fddf859704217a99a23a4f6417b10e5ab1256a179264561540e/contourpy-1.3.3-cp312-cp312-win32.whl", hash = "sha256:023b44101dfe49d7d53932be418477dba359649246075c996866106da069af69", size = 185018, upload-time = "2025-07-26T12:01:35.64Z" }, + { url = "https://files.pythonhosted.org/packages/19/e8/6026ed58a64563186a9ee3f29f41261fd1828f527dd93d33b60feca63352/contourpy-1.3.3-cp312-cp312-win_amd64.whl", hash = "sha256:8153b8bfc11e1e4d75bcb0bff1db232f9e10b274e0929de9d608027e0d34ff8b", size = 226567, upload-time = "2025-07-26T12:01:36.804Z" }, + { url = "https://files.pythonhosted.org/packages/d1/e2/f05240d2c39a1ed228d8328a78b6f44cd695f7ef47beb3e684cf93604f86/contourpy-1.3.3-cp312-cp312-win_arm64.whl", hash = "sha256:07ce5ed73ecdc4a03ffe3e1b3e3c1166db35ae7584be76f65dbbe28a7791b0cc", size = 193655, upload-time = "2025-07-26T12:01:37.999Z" }, + { url = "https://files.pythonhosted.org/packages/68/35/0167aad910bbdb9599272bd96d01a9ec6852f36b9455cf2ca67bd4cc2d23/contourpy-1.3.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:177fb367556747a686509d6fef71d221a4b198a3905fe824430e5ea0fda54eb5", size = 293257, upload-time = "2025-07-26T12:01:39.367Z" }, + { url = "https://files.pythonhosted.org/packages/96/e4/7adcd9c8362745b2210728f209bfbcf7d91ba868a2c5f40d8b58f54c509b/contourpy-1.3.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d002b6f00d73d69333dac9d0b8d5e84d9724ff9ef044fd63c5986e62b7c9e1b1", size = 274034, upload-time = "2025-07-26T12:01:40.645Z" }, + { url = "https://files.pythonhosted.org/packages/73/23/90e31ceeed1de63058a02cb04b12f2de4b40e3bef5e082a7c18d9c8ae281/contourpy-1.3.3-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:348ac1f5d4f1d66d3322420f01d42e43122f43616e0f194fc1c9f5d830c5b286", size = 334672, upload-time = "2025-07-26T12:01:41.942Z" }, + { url = "https://files.pythonhosted.org/packages/ed/93/b43d8acbe67392e659e1d984700e79eb67e2acb2bd7f62012b583a7f1b55/contourpy-1.3.3-cp313-cp313-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:655456777ff65c2c548b7c454af9c6f33f16c8884f11083244b5819cc214f1b5", size = 381234, upload-time = "2025-07-26T12:01:43.499Z" }, + { url = "https://files.pythonhosted.org/packages/46/3b/bec82a3ea06f66711520f75a40c8fc0b113b2a75edb36aa633eb11c4f50f/contourpy-1.3.3-cp313-cp313-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:644a6853d15b2512d67881586bd03f462c7ab755db95f16f14d7e238f2852c67", size = 385169, upload-time = "2025-07-26T12:01:45.219Z" }, + { url = "https://files.pythonhosted.org/packages/4b/32/e0f13a1c5b0f8572d0ec6ae2f6c677b7991fafd95da523159c19eff0696a/contourpy-1.3.3-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4debd64f124ca62069f313a9cb86656ff087786016d76927ae2cf37846b006c9", size = 362859, upload-time = "2025-07-26T12:01:46.519Z" }, + { url = "https://files.pythonhosted.org/packages/33/71/e2a7945b7de4e58af42d708a219f3b2f4cff7386e6b6ab0a0fa0033c49a9/contourpy-1.3.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a15459b0f4615b00bbd1e91f1b9e19b7e63aea7483d03d804186f278c0af2659", size = 1332062, upload-time = "2025-07-26T12:01:48.964Z" }, + { url = "https://files.pythonhosted.org/packages/12/fc/4e87ac754220ccc0e807284f88e943d6d43b43843614f0a8afa469801db0/contourpy-1.3.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ca0fdcd73925568ca027e0b17ab07aad764be4706d0a925b89227e447d9737b7", size = 1403932, upload-time = "2025-07-26T12:01:51.979Z" }, + { url = "https://files.pythonhosted.org/packages/a6/2e/adc197a37443f934594112222ac1aa7dc9a98faf9c3842884df9a9d8751d/contourpy-1.3.3-cp313-cp313-win32.whl", hash = "sha256:b20c7c9a3bf701366556e1b1984ed2d0cedf999903c51311417cf5f591d8c78d", size = 185024, upload-time = "2025-07-26T12:01:53.245Z" }, + { url = "https://files.pythonhosted.org/packages/18/0b/0098c214843213759692cc638fce7de5c289200a830e5035d1791d7a2338/contourpy-1.3.3-cp313-cp313-win_amd64.whl", hash = "sha256:1cadd8b8969f060ba45ed7c1b714fe69185812ab43bd6b86a9123fe8f99c3263", size = 226578, upload-time = "2025-07-26T12:01:54.422Z" }, + { url = "https://files.pythonhosted.org/packages/8a/9a/2f6024a0c5995243cd63afdeb3651c984f0d2bc727fd98066d40e141ad73/contourpy-1.3.3-cp313-cp313-win_arm64.whl", hash = "sha256:fd914713266421b7536de2bfa8181aa8c699432b6763a0ea64195ebe28bff6a9", size = 193524, upload-time = "2025-07-26T12:01:55.73Z" }, + { url = "https://files.pythonhosted.org/packages/c0/b3/f8a1a86bd3298513f500e5b1f5fd92b69896449f6cab6a146a5d52715479/contourpy-1.3.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:88df9880d507169449d434c293467418b9f6cbe82edd19284aa0409e7fdb933d", size = 306730, upload-time = "2025-07-26T12:01:57.051Z" }, + { url = "https://files.pythonhosted.org/packages/3f/11/4780db94ae62fc0c2053909b65dc3246bd7cecfc4f8a20d957ad43aa4ad8/contourpy-1.3.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:d06bb1f751ba5d417047db62bca3c8fde202b8c11fb50742ab3ab962c81e8216", size = 287897, upload-time = "2025-07-26T12:01:58.663Z" }, + { url = "https://files.pythonhosted.org/packages/ae/15/e59f5f3ffdd6f3d4daa3e47114c53daabcb18574a26c21f03dc9e4e42ff0/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e4e6b05a45525357e382909a4c1600444e2a45b4795163d3b22669285591c1ae", size = 326751, upload-time = "2025-07-26T12:02:00.343Z" }, + { url = "https://files.pythonhosted.org/packages/0f/81/03b45cfad088e4770b1dcf72ea78d3802d04200009fb364d18a493857210/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ab3074b48c4e2cf1a960e6bbeb7f04566bf36b1861d5c9d4d8ac04b82e38ba20", size = 375486, upload-time = "2025-07-26T12:02:02.128Z" }, + { url = "https://files.pythonhosted.org/packages/0c/ba/49923366492ffbdd4486e970d421b289a670ae8cf539c1ea9a09822b371a/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6c3d53c796f8647d6deb1abe867daeb66dcc8a97e8455efa729516b997b8ed99", size = 388106, upload-time = "2025-07-26T12:02:03.615Z" }, + { url = "https://files.pythonhosted.org/packages/9f/52/5b00ea89525f8f143651f9f03a0df371d3cbd2fccd21ca9b768c7a6500c2/contourpy-1.3.3-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50ed930df7289ff2a8d7afeb9603f8289e5704755c7e5c3bbd929c90c817164b", size = 352548, upload-time = "2025-07-26T12:02:05.165Z" }, + { url = "https://files.pythonhosted.org/packages/32/1d/a209ec1a3a3452d490f6b14dd92e72280c99ae3d1e73da74f8277d4ee08f/contourpy-1.3.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:4feffb6537d64b84877da813a5c30f1422ea5739566abf0bd18065ac040e120a", size = 1322297, upload-time = "2025-07-26T12:02:07.379Z" }, + { url = "https://files.pythonhosted.org/packages/bc/9e/46f0e8ebdd884ca0e8877e46a3f4e633f6c9c8c4f3f6e72be3fe075994aa/contourpy-1.3.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:2b7e9480ffe2b0cd2e787e4df64270e3a0440d9db8dc823312e2c940c167df7e", size = 1391023, upload-time = "2025-07-26T12:02:10.171Z" }, + { url = "https://files.pythonhosted.org/packages/b9/70/f308384a3ae9cd2209e0849f33c913f658d3326900d0ff5d378d6a1422d2/contourpy-1.3.3-cp313-cp313t-win32.whl", hash = "sha256:283edd842a01e3dcd435b1c5116798d661378d83d36d337b8dde1d16a5fc9ba3", size = 196157, upload-time = "2025-07-26T12:02:11.488Z" }, + { url = "https://files.pythonhosted.org/packages/b2/dd/880f890a6663b84d9e34a6f88cded89d78f0091e0045a284427cb6b18521/contourpy-1.3.3-cp313-cp313t-win_amd64.whl", hash = "sha256:87acf5963fc2b34825e5b6b048f40e3635dd547f590b04d2ab317c2619ef7ae8", size = 240570, upload-time = "2025-07-26T12:02:12.754Z" }, + { url = "https://files.pythonhosted.org/packages/80/99/2adc7d8ffead633234817ef8e9a87115c8a11927a94478f6bb3d3f4d4f7d/contourpy-1.3.3-cp313-cp313t-win_arm64.whl", hash = "sha256:3c30273eb2a55024ff31ba7d052dde990d7d8e5450f4bbb6e913558b3d6c2301", size = 199713, upload-time = "2025-07-26T12:02:14.4Z" }, + { url = "https://files.pythonhosted.org/packages/72/8b/4546f3ab60f78c514ffb7d01a0bd743f90de36f0019d1be84d0a708a580a/contourpy-1.3.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fde6c716d51c04b1c25d0b90364d0be954624a0ee9d60e23e850e8d48353d07a", size = 292189, upload-time = "2025-07-26T12:02:16.095Z" }, + { url = "https://files.pythonhosted.org/packages/fd/e1/3542a9cb596cadd76fcef413f19c79216e002623158befe6daa03dbfa88c/contourpy-1.3.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:cbedb772ed74ff5be440fa8eee9bd49f64f6e3fc09436d9c7d8f1c287b121d77", size = 273251, upload-time = "2025-07-26T12:02:17.524Z" }, + { url = "https://files.pythonhosted.org/packages/b1/71/f93e1e9471d189f79d0ce2497007731c1e6bf9ef6d1d61b911430c3db4e5/contourpy-1.3.3-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:22e9b1bd7a9b1d652cd77388465dc358dafcd2e217d35552424aa4f996f524f5", size = 335810, upload-time = "2025-07-26T12:02:18.9Z" }, + { url = "https://files.pythonhosted.org/packages/91/f9/e35f4c1c93f9275d4e38681a80506b5510e9327350c51f8d4a5a724d178c/contourpy-1.3.3-cp314-cp314-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a22738912262aa3e254e4f3cb079a95a67132fc5a063890e224393596902f5a4", size = 382871, upload-time = "2025-07-26T12:02:20.418Z" }, + { url = "https://files.pythonhosted.org/packages/b5/71/47b512f936f66a0a900d81c396a7e60d73419868fba959c61efed7a8ab46/contourpy-1.3.3-cp314-cp314-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:afe5a512f31ee6bd7d0dda52ec9864c984ca3d66664444f2d72e0dc4eb832e36", size = 386264, upload-time = "2025-07-26T12:02:21.916Z" }, + { url = "https://files.pythonhosted.org/packages/04/5f/9ff93450ba96b09c7c2b3f81c94de31c89f92292f1380261bd7195bea4ea/contourpy-1.3.3-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f64836de09927cba6f79dcd00fdd7d5329f3fccc633468507079c829ca4db4e3", size = 363819, upload-time = "2025-07-26T12:02:23.759Z" }, + { url = "https://files.pythonhosted.org/packages/3e/a6/0b185d4cc480ee494945cde102cb0149ae830b5fa17bf855b95f2e70ad13/contourpy-1.3.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:1fd43c3be4c8e5fd6e4f2baeae35ae18176cf2e5cced681cca908addf1cdd53b", size = 1333650, upload-time = "2025-07-26T12:02:26.181Z" }, + { url = "https://files.pythonhosted.org/packages/43/d7/afdc95580ca56f30fbcd3060250f66cedbde69b4547028863abd8aa3b47e/contourpy-1.3.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:6afc576f7b33cf00996e5c1102dc2a8f7cc89e39c0b55df93a0b78c1bd992b36", size = 1404833, upload-time = "2025-07-26T12:02:28.782Z" }, + { url = "https://files.pythonhosted.org/packages/e2/e2/366af18a6d386f41132a48f033cbd2102e9b0cf6345d35ff0826cd984566/contourpy-1.3.3-cp314-cp314-win32.whl", hash = "sha256:66c8a43a4f7b8df8b71ee1840e4211a3c8d93b214b213f590e18a1beca458f7d", size = 189692, upload-time = "2025-07-26T12:02:30.128Z" }, + { url = "https://files.pythonhosted.org/packages/7d/c2/57f54b03d0f22d4044b8afb9ca0e184f8b1afd57b4f735c2fa70883dc601/contourpy-1.3.3-cp314-cp314-win_amd64.whl", hash = "sha256:cf9022ef053f2694e31d630feaacb21ea24224be1c3ad0520b13d844274614fd", size = 232424, upload-time = "2025-07-26T12:02:31.395Z" }, + { url = "https://files.pythonhosted.org/packages/18/79/a9416650df9b525737ab521aa181ccc42d56016d2123ddcb7b58e926a42c/contourpy-1.3.3-cp314-cp314-win_arm64.whl", hash = "sha256:95b181891b4c71de4bb404c6621e7e2390745f887f2a026b2d99e92c17892339", size = 198300, upload-time = "2025-07-26T12:02:32.956Z" }, + { url = "https://files.pythonhosted.org/packages/1f/42/38c159a7d0f2b7b9c04c64ab317042bb6952b713ba875c1681529a2932fe/contourpy-1.3.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:33c82d0138c0a062380332c861387650c82e4cf1747aaa6938b9b6516762e772", size = 306769, upload-time = "2025-07-26T12:02:34.2Z" }, + { url = "https://files.pythonhosted.org/packages/c3/6c/26a8205f24bca10974e77460de68d3d7c63e282e23782f1239f226fcae6f/contourpy-1.3.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ea37e7b45949df430fe649e5de8351c423430046a2af20b1c1961cae3afcda77", size = 287892, upload-time = "2025-07-26T12:02:35.807Z" }, + { url = "https://files.pythonhosted.org/packages/66/06/8a475c8ab718ebfd7925661747dbb3c3ee9c82ac834ccb3570be49d129f4/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d304906ecc71672e9c89e87c4675dc5c2645e1f4269a5063b99b0bb29f232d13", size = 326748, upload-time = "2025-07-26T12:02:37.193Z" }, + { url = "https://files.pythonhosted.org/packages/b4/a3/c5ca9f010a44c223f098fccd8b158bb1cb287378a31ac141f04730dc49be/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ca658cd1a680a5c9ea96dc61cdbae1e85c8f25849843aa799dfd3cb370ad4fbe", size = 375554, upload-time = "2025-07-26T12:02:38.894Z" }, + { url = "https://files.pythonhosted.org/packages/80/5b/68bd33ae63fac658a4145088c1e894405e07584a316738710b636c6d0333/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ab2fd90904c503739a75b7c8c5c01160130ba67944a7b77bbf36ef8054576e7f", size = 388118, upload-time = "2025-07-26T12:02:40.642Z" }, + { url = "https://files.pythonhosted.org/packages/40/52/4c285a6435940ae25d7410a6c36bda5145839bc3f0beb20c707cda18b9d2/contourpy-1.3.3-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b7301b89040075c30e5768810bc96a8e8d78085b47d8be6e4c3f5a0b4ed478a0", size = 352555, upload-time = "2025-07-26T12:02:42.25Z" }, + { url = "https://files.pythonhosted.org/packages/24/ee/3e81e1dd174f5c7fefe50e85d0892de05ca4e26ef1c9a59c2a57e43b865a/contourpy-1.3.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:2a2a8b627d5cc6b7c41a4beff6c5ad5eb848c88255fda4a8745f7e901b32d8e4", size = 1322295, upload-time = "2025-07-26T12:02:44.668Z" }, + { url = "https://files.pythonhosted.org/packages/3c/b2/6d913d4d04e14379de429057cd169e5e00f6c2af3bb13e1710bcbdb5da12/contourpy-1.3.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:fd6ec6be509c787f1caf6b247f0b1ca598bef13f4ddeaa126b7658215529ba0f", size = 1391027, upload-time = "2025-07-26T12:02:47.09Z" }, + { url = "https://files.pythonhosted.org/packages/93/8a/68a4ec5c55a2971213d29a9374913f7e9f18581945a7a31d1a39b5d2dfe5/contourpy-1.3.3-cp314-cp314t-win32.whl", hash = "sha256:e74a9a0f5e3fff48fb5a7f2fd2b9b70a3fe014a67522f79b7cca4c0c7e43c9ae", size = 202428, upload-time = "2025-07-26T12:02:48.691Z" }, + { url = "https://files.pythonhosted.org/packages/fa/96/fd9f641ffedc4fa3ace923af73b9d07e869496c9cc7a459103e6e978992f/contourpy-1.3.3-cp314-cp314t-win_amd64.whl", hash = "sha256:13b68d6a62db8eafaebb8039218921399baf6e47bf85006fd8529f2a08ef33fc", size = 250331, upload-time = "2025-07-26T12:02:50.137Z" }, + { url = "https://files.pythonhosted.org/packages/ae/8c/469afb6465b853afff216f9528ffda78a915ff880ed58813ba4faf4ba0b6/contourpy-1.3.3-cp314-cp314t-win_arm64.whl", hash = "sha256:b7448cb5a725bb1e35ce88771b86fba35ef418952474492cf7c764059933ff8b", size = 203831, upload-time = "2025-07-26T12:02:51.449Z" }, + { url = "https://files.pythonhosted.org/packages/a5/29/8dcfe16f0107943fa92388c23f6e05cff0ba58058c4c95b00280d4c75a14/contourpy-1.3.3-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:cd5dfcaeb10f7b7f9dc8941717c6c2ade08f587be2226222c12b25f0483ed497", size = 278809, upload-time = "2025-07-26T12:02:52.74Z" }, + { url = "https://files.pythonhosted.org/packages/85/a9/8b37ef4f7dafeb335daee3c8254645ef5725be4d9c6aa70b50ec46ef2f7e/contourpy-1.3.3-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:0c1fc238306b35f246d61a1d416a627348b5cf0648648a031e14bb8705fcdfe8", size = 261593, upload-time = "2025-07-26T12:02:54.037Z" }, + { url = "https://files.pythonhosted.org/packages/0a/59/ebfb8c677c75605cc27f7122c90313fd2f375ff3c8d19a1694bda74aaa63/contourpy-1.3.3-pp311-pypy311_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:70f9aad7de812d6541d29d2bbf8feb22ff7e1c299523db288004e3157ff4674e", size = 302202, upload-time = "2025-07-26T12:02:55.947Z" }, + { url = "https://files.pythonhosted.org/packages/3c/37/21972a15834d90bfbfb009b9d004779bd5a07a0ec0234e5ba8f64d5736f4/contourpy-1.3.3-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5ed3657edf08512fc3fe81b510e35c2012fbd3081d2e26160f27ca28affec989", size = 329207, upload-time = "2025-07-26T12:02:57.468Z" }, + { url = "https://files.pythonhosted.org/packages/0c/58/bd257695f39d05594ca4ad60df5bcb7e32247f9951fd09a9b8edb82d1daa/contourpy-1.3.3-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:3d1a3799d62d45c18bafd41c5fa05120b96a28079f2393af559b843d1a966a77", size = 225315, upload-time = "2025-07-26T12:02:58.801Z" }, +] + +[[package]] +name = "cycler" +version = "0.12.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a9/95/a3dbbb5028f35eafb79008e7522a75244477d2838f38cbb722248dabc2a8/cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c", size = 7615, upload-time = "2023-10-07T05:32:18.335Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/05/c19819d5e3d95294a6f5947fb9b9629efb316b96de511b418c53d245aae6/cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30", size = 8321, upload-time = "2023-10-07T05:32:16.783Z" }, +] + +[[package]] +name = "decorator" +version = "5.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/43/fa/6d96a0978d19e17b68d634497769987b16c8f4cd0a7a05048bec693caa6b/decorator-5.2.1.tar.gz", hash = "sha256:65f266143752f734b0a7cc83c46f4618af75b8c5911b00ccb61d0ac9b6da0360", size = 56711, upload-time = "2025-02-24T04:41:34.073Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4e/8c/f3147f5c4b73e7550fe5f9352eaa956ae838d5c51eb58e7a25b9f3e2643b/decorator-5.2.1-py3-none-any.whl", hash = "sha256:d316bb415a2d9e2d2b3abcc4084c6502fc09240e292cd76a76afc106a1c8e04a", size = 9190, upload-time = "2025-02-24T04:41:32.565Z" }, +] + +[[package]] +name = "executing" +version = "2.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cc/28/c14e053b6762b1044f34a13aab6859bbf40456d37d23aa286ac24cfd9a5d/executing-2.2.1.tar.gz", hash = "sha256:3632cc370565f6648cc328b32435bd120a1e4ebb20c77e3fdde9a13cd1e533c4", size = 1129488, upload-time = "2025-09-01T09:48:10.866Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c1/ea/53f2148663b321f21b5a606bd5f191517cf40b7072c0497d3c92c4a13b1e/executing-2.2.1-py2.py3-none-any.whl", hash = "sha256:760643d3452b4d777d295bb167ccc74c64a81df23fb5e08eff250c425a4b2017", size = 28317, upload-time = "2025-09-01T09:48:08.5Z" }, +] + +[[package]] +name = "filelock" +version = "3.29.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b5/fe/997687a931ab51049acce6fa1f23e8f01216374ea81374ddee763c493db5/filelock-3.29.0.tar.gz", hash = "sha256:69974355e960702e789734cb4871f884ea6fe50bd8404051a3530bc07809cf90", size = 57571, upload-time = "2026-04-19T15:39:10.068Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/81/47/dd9a212ef6e343a6857485ffe25bba537304f1913bdbed446a23f7f592e1/filelock-3.29.0-py3-none-any.whl", hash = "sha256:96f5f6344709aa1572bbf631c640e4ebeeb519e08da902c39a001882f30ac258", size = 39812, upload-time = "2026-04-19T15:39:08.752Z" }, +] + +[[package]] +name = "fonttools" +version = "4.62.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/9a/08/7012b00a9a5874311b639c3920270c36ee0c445b69d9989a85e5c92ebcb0/fonttools-4.62.1.tar.gz", hash = "sha256:e54c75fd6041f1122476776880f7c3c3295ffa31962dc6ebe2543c00dca58b5d", size = 3580737, upload-time = "2026-03-13T13:54:25.52Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/88/39/23ff32561ec8d45a4d48578b4d241369d9270dc50926c017570e60893701/fonttools-4.62.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:40975849bac44fb0b9253d77420c6d8b523ac4dcdcefeff6e4d706838a5b80f7", size = 2871039, upload-time = "2026-03-13T13:52:33.127Z" }, + { url = "https://files.pythonhosted.org/packages/24/7f/66d3f8a9338a9b67fe6e1739f47e1cd5cee78bd3bc1206ef9b0b982289a5/fonttools-4.62.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:9dde91633f77fa576879a0c76b1d89de373cae751a98ddf0109d54e173b40f14", size = 2416346, upload-time = "2026-03-13T13:52:35.676Z" }, + { url = "https://files.pythonhosted.org/packages/aa/53/5276ceba7bff95da7793a07c5284e1da901cf00341ce5e2f3273056c0cca/fonttools-4.62.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6acb4109f8bee00fec985c8c7afb02299e35e9c94b57287f3ea542f28bd0b0a7", size = 5100897, upload-time = "2026-03-13T13:52:38.102Z" }, + { url = "https://files.pythonhosted.org/packages/cc/a1/40a5c4d8e28b0851d53a8eeeb46fbd73c325a2a9a165f290a5ed90e6c597/fonttools-4.62.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1c5c25671ce8805e0d080e2ffdeca7f1e86778c5cbfbeae86d7f866d8830517b", size = 5071078, upload-time = "2026-03-13T13:52:41.305Z" }, + { url = "https://files.pythonhosted.org/packages/e3/be/d378fca4c65ea1956fee6d90ace6e861776809cbbc5af22388a090c3c092/fonttools-4.62.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:a5d8825e1140f04e6c99bb7d37a9e31c172f3bc208afbe02175339e699c710e1", size = 5076908, upload-time = "2026-03-13T13:52:44.122Z" }, + { url = "https://files.pythonhosted.org/packages/f8/d9/ae6a1d0693a4185a84605679c8a1f719a55df87b9c6e8e817bfdd9ef5936/fonttools-4.62.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:268abb1cb221e66c014acc234e872b7870d8b5d4657a83a8f4205094c32d2416", size = 5202275, upload-time = "2026-03-13T13:52:46.591Z" }, + { url = "https://files.pythonhosted.org/packages/54/6c/af95d9c4efb15cabff22642b608342f2bd67137eea6107202d91b5b03184/fonttools-4.62.1-cp311-cp311-win32.whl", hash = "sha256:942b03094d7edbb99bdf1ae7e9090898cad7bf9030b3d21f33d7072dbcb51a53", size = 2293075, upload-time = "2026-03-13T13:52:48.711Z" }, + { url = "https://files.pythonhosted.org/packages/d3/97/bf54c5b3f2be34e1f143e6db838dfdc54f2ffa3e68c738934c82f3b2a08d/fonttools-4.62.1-cp311-cp311-win_amd64.whl", hash = "sha256:e8514f4924375f77084e81467e63238b095abda5107620f49421c368a6017ed2", size = 2344593, upload-time = "2026-03-13T13:52:50.725Z" }, + { url = "https://files.pythonhosted.org/packages/47/d4/dbacced3953544b9a93088cc10ef2b596d348c983d5c67a404fa41ec51ba/fonttools-4.62.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:90365821debbd7db678809c7491ca4acd1e0779b9624cdc6ddaf1f31992bf974", size = 2870219, upload-time = "2026-03-13T13:52:53.664Z" }, + { url = "https://files.pythonhosted.org/packages/66/9e/a769c8e99b81e5a87ab7e5e7236684de4e96246aae17274e5347d11ebd78/fonttools-4.62.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:12859ff0b47dd20f110804c3e0d0970f7b832f561630cd879969011541a464a9", size = 2414891, upload-time = "2026-03-13T13:52:56.493Z" }, + { url = "https://files.pythonhosted.org/packages/69/64/f19a9e3911968c37e1e620e14dfc5778299e1474f72f4e57c5ec771d9489/fonttools-4.62.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9c125ffa00c3d9003cdaaf7f2c79e6e535628093e14b5de1dccb08859b680936", size = 5033197, upload-time = "2026-03-13T13:52:59.179Z" }, + { url = "https://files.pythonhosted.org/packages/9b/8a/99c8b3c3888c5c474c08dbfd7c8899786de9604b727fcefb055b42c84bba/fonttools-4.62.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:149f7d84afca659d1a97e39a4778794a2f83bf344c5ee5134e09995086cc2392", size = 4988768, upload-time = "2026-03-13T13:53:02.761Z" }, + { url = "https://files.pythonhosted.org/packages/d1/c6/0f904540d3e6ab463c1243a0d803504826a11604c72dd58c2949796a1762/fonttools-4.62.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0aa72c43a601cfa9273bb1ae0518f1acadc01ee181a6fc60cd758d7fdadffc04", size = 4971512, upload-time = "2026-03-13T13:53:05.678Z" }, + { url = "https://files.pythonhosted.org/packages/29/0b/5cbef6588dc9bd6b5c9ad6a4d5a8ca384d0cea089da31711bbeb4f9654a6/fonttools-4.62.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:19177c8d96c7c36359266e571c5173bcee9157b59cfc8cb0153c5673dc5a3a7d", size = 5122723, upload-time = "2026-03-13T13:53:08.662Z" }, + { url = "https://files.pythonhosted.org/packages/4a/47/b3a5342d381595ef439adec67848bed561ab7fdb1019fa522e82101b7d9c/fonttools-4.62.1-cp312-cp312-win32.whl", hash = "sha256:a24decd24d60744ee8b4679d38e88b8303d86772053afc29b19d23bb8207803c", size = 2281278, upload-time = "2026-03-13T13:53:10.998Z" }, + { url = "https://files.pythonhosted.org/packages/28/b1/0c2ab56a16f409c6c8a68816e6af707827ad5d629634691ff60a52879792/fonttools-4.62.1-cp312-cp312-win_amd64.whl", hash = "sha256:9e7863e10b3de72376280b515d35b14f5eeed639d1aa7824f4cf06779ec65e42", size = 2331414, upload-time = "2026-03-13T13:53:13.992Z" }, + { url = "https://files.pythonhosted.org/packages/3b/56/6f389de21c49555553d6a5aeed5ac9767631497ac836c4f076273d15bd72/fonttools-4.62.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:c22b1014017111c401469e3acc5433e6acf6ebcc6aa9efb538a533c800971c79", size = 2865155, upload-time = "2026-03-13T13:53:16.132Z" }, + { url = "https://files.pythonhosted.org/packages/03/c5/0e3966edd5ec668d41dfe418787726752bc07e2f5fd8c8f208615e61fa89/fonttools-4.62.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:68959f5fc58ed4599b44aad161c2837477d7f35f5f79402d97439974faebfebe", size = 2412802, upload-time = "2026-03-13T13:53:18.878Z" }, + { url = "https://files.pythonhosted.org/packages/52/94/e6ac4b44026de7786fe46e3bfa0c87e51d5d70a841054065d49cd62bb909/fonttools-4.62.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ef46db46c9447103b8f3ff91e8ba009d5fe181b1920a83757a5762551e32bb68", size = 5013926, upload-time = "2026-03-13T13:53:21.379Z" }, + { url = "https://files.pythonhosted.org/packages/e2/98/8b1e801939839d405f1f122e7d175cebe9aeb4e114f95bfc45e3152af9a7/fonttools-4.62.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:6706d1cb1d5e6251a97ad3c1b9347505c5615c112e66047abbef0f8545fa30d1", size = 4964575, upload-time = "2026-03-13T13:53:23.857Z" }, + { url = "https://files.pythonhosted.org/packages/46/76/7d051671e938b1881670528fec69cc4044315edd71a229c7fd712eaa5119/fonttools-4.62.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:2e7abd2b1e11736f58c1de27819e1955a53267c21732e78243fa2fa2e5c1e069", size = 4953693, upload-time = "2026-03-13T13:53:26.569Z" }, + { url = "https://files.pythonhosted.org/packages/1f/ae/b41f8628ec0be3c1b934fc12b84f4576a5c646119db4d3bdd76a217c90b5/fonttools-4.62.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:403d28ce06ebfc547fbcb0cb8b7f7cc2f7a2d3e1a67ba9a34b14632df9e080f9", size = 5094920, upload-time = "2026-03-13T13:53:29.329Z" }, + { url = "https://files.pythonhosted.org/packages/f2/f6/53a1e9469331a23dcc400970a27a4caa3d9f6edbf5baab0260285238b884/fonttools-4.62.1-cp313-cp313-win32.whl", hash = "sha256:93c316e0f5301b2adbe6a5f658634307c096fd5aae60a5b3412e4f3e1728ab24", size = 2279928, upload-time = "2026-03-13T13:53:32.352Z" }, + { url = "https://files.pythonhosted.org/packages/38/60/35186529de1db3c01f5ad625bde07c1f576305eab6d86bbda4c58445f721/fonttools-4.62.1-cp313-cp313-win_amd64.whl", hash = "sha256:7aa21ff53e28a9c2157acbc44e5b401149d3c9178107130e82d74ceb500e5056", size = 2330514, upload-time = "2026-03-13T13:53:34.991Z" }, + { url = "https://files.pythonhosted.org/packages/36/f0/2888cdac391807d68d90dcb16ef858ddc1b5309bfc6966195a459dd326e2/fonttools-4.62.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:fa1d16210b6b10a826d71bed68dd9ec24a9e218d5a5e2797f37c573e7ec215ca", size = 2864442, upload-time = "2026-03-13T13:53:37.509Z" }, + { url = "https://files.pythonhosted.org/packages/4b/b2/e521803081f8dc35990816b82da6360fa668a21b44da4b53fc9e77efcd62/fonttools-4.62.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:aa69d10ed420d8121118e628ad47d86e4caa79ba37f968597b958f6cceab7eca", size = 2410901, upload-time = "2026-03-13T13:53:40.55Z" }, + { url = "https://files.pythonhosted.org/packages/00/a4/8c3511ff06e53110039358dbbdc1a65d72157a054638387aa2ada300a8b8/fonttools-4.62.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bd13b7999d59c5eb1c2b442eb2d0c427cb517a0b7a1f5798fc5c9e003f5ff782", size = 4999608, upload-time = "2026-03-13T13:53:42.798Z" }, + { url = "https://files.pythonhosted.org/packages/28/63/cd0c3b26afe60995a5295f37c246a93d454023726c3261cfbb3559969bb9/fonttools-4.62.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8d337fdd49a79b0d51c4da87bc38169d21c3abbf0c1aa9367eff5c6656fb6dae", size = 4912726, upload-time = "2026-03-13T13:53:45.405Z" }, + { url = "https://files.pythonhosted.org/packages/70/b9/ac677cb07c24c685cf34f64e140617d58789d67a3dd524164b63648c6114/fonttools-4.62.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:d241cdc4a67b5431c6d7f115fdf63335222414995e3a1df1a41e1182acd4bcc7", size = 4951422, upload-time = "2026-03-13T13:53:48.326Z" }, + { url = "https://files.pythonhosted.org/packages/e6/10/11c08419a14b85b7ca9a9faca321accccc8842dd9e0b1c8a72908de05945/fonttools-4.62.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:c05557a78f8fa514da0f869556eeda40887a8abc77c76ee3f74cf241778afd5a", size = 5060979, upload-time = "2026-03-13T13:53:51.366Z" }, + { url = "https://files.pythonhosted.org/packages/4e/3c/12eea4a4cf054e7ab058ed5ceada43b46809fce2bf319017c4d63ae55bb4/fonttools-4.62.1-cp314-cp314-win32.whl", hash = "sha256:49a445d2f544ce4a69338694cad575ba97b9a75fff02720da0882d1a73f12800", size = 2283733, upload-time = "2026-03-13T13:53:53.606Z" }, + { url = "https://files.pythonhosted.org/packages/6b/67/74b070029043186b5dd13462c958cb7c7f811be0d2e634309d9a1ffb1505/fonttools-4.62.1-cp314-cp314-win_amd64.whl", hash = "sha256:1eecc128c86c552fb963fe846ca4e011b1be053728f798185a1687502f6d398e", size = 2335663, upload-time = "2026-03-13T13:53:56.23Z" }, + { url = "https://files.pythonhosted.org/packages/42/c5/4d2ed3ca6e33617fc5624467da353337f06e7f637707478903c785bd8e20/fonttools-4.62.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:1596aeaddf7f78e21e68293c011316a25267b3effdaccaf4d59bc9159d681b82", size = 2947288, upload-time = "2026-03-13T13:53:59.397Z" }, + { url = "https://files.pythonhosted.org/packages/1f/e9/7ab11ddfda48ed0f89b13380e5595ba572619c27077be0b2c447a63ff351/fonttools-4.62.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:8f8fca95d3bb3208f59626a4b0ea6e526ee51f5a8ad5d91821c165903e8d9260", size = 2449023, upload-time = "2026-03-13T13:54:01.642Z" }, + { url = "https://files.pythonhosted.org/packages/b2/10/a800fa090b5e8819942e54e19b55fc7c21fe14a08757c3aa3ca8db358939/fonttools-4.62.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee91628c08e76f77b533d65feb3fbe6d9dad699f95be51cf0d022db94089cdc4", size = 5137599, upload-time = "2026-03-13T13:54:04.495Z" }, + { url = "https://files.pythonhosted.org/packages/37/dc/8ccd45033fffd74deb6912fa1ca524643f584b94c87a16036855b498a1ed/fonttools-4.62.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5f37df1cac61d906e7b836abe356bc2f34c99d4477467755c216b72aa3dc748b", size = 4920933, upload-time = "2026-03-13T13:54:07.557Z" }, + { url = "https://files.pythonhosted.org/packages/99/eb/e618adefb839598d25ac8136cd577925d6c513dc0d931d93b8af956210f0/fonttools-4.62.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:92bb00a947e666169c99b43753c4305fc95a890a60ef3aeb2a6963e07902cc87", size = 5016232, upload-time = "2026-03-13T13:54:10.611Z" }, + { url = "https://files.pythonhosted.org/packages/d9/5f/9b5c9bfaa8ec82def8d8168c4f13615990d6ce5996fe52bd49bfb5e05134/fonttools-4.62.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:bdfe592802ef939a0e33106ea4a318eeb17822c7ee168c290273cbd5fabd746c", size = 5042987, upload-time = "2026-03-13T13:54:13.569Z" }, + { url = "https://files.pythonhosted.org/packages/90/aa/dfbbe24c6a6afc5c203d90cc0343e24bcbb09e76d67c4d6eef8c2558d7ba/fonttools-4.62.1-cp314-cp314t-win32.whl", hash = "sha256:b820fcb92d4655513d8402d5b219f94481c4443d825b4372c75a2072aa4b357a", size = 2348021, upload-time = "2026-03-13T13:54:16.98Z" }, + { url = "https://files.pythonhosted.org/packages/13/6f/ae9c4e4dd417948407b680855c2c7790efb52add6009aaecff1e3bc50e8e/fonttools-4.62.1-cp314-cp314t-win_amd64.whl", hash = "sha256:59b372b4f0e113d3746b88985f1c796e7bf830dd54b28374cd85c2b8acd7583e", size = 2414147, upload-time = "2026-03-13T13:54:19.416Z" }, + { url = "https://files.pythonhosted.org/packages/fd/ba/56147c165442cc5ba7e82ecf301c9a68353cede498185869e6e02b4c264f/fonttools-4.62.1-py3-none-any.whl", hash = "sha256:7487782e2113861f4ddcc07c3436450659e3caa5e470b27dc2177cade2d8e7fd", size = 1152647, upload-time = "2026-03-13T13:54:22.735Z" }, +] + +[[package]] +name = "fsspec" +version = "2026.4.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d5/8d/1c51c094345df128ca4a990d633fe1a0ff28726c9e6b3c41ba65087bba1d/fsspec-2026.4.0.tar.gz", hash = "sha256:301d8ac70ae90ef3ad05dcf94d6c3754a097f9b5fe4667d2787aa359ec7df7e4", size = 312760, upload-time = "2026-04-29T20:42:38.635Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d5/0c/043d5e551459da400957a1395e0febbf771446ff34291afcbe3d8be2a279/fsspec-2026.4.0-py3-none-any.whl", hash = "sha256:11ef7bb35dab8a394fde6e608221d5cf3e8499401c249bebaeaad760a1a8dec2", size = 203402, upload-time = "2026-04-29T20:42:36.842Z" }, +] + +[[package]] +name = "grpcio" +version = "1.80.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b7/48/af6173dbca4454f4637a4678b67f52ca7e0c1ed7d5894d89d434fecede05/grpcio-1.80.0.tar.gz", hash = "sha256:29aca15edd0688c22ba01d7cc01cb000d72b2033f4a3c72a81a19b56fd143257", size = 12978905, upload-time = "2026-03-30T08:49:10.502Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5d/db/1d56e5f5823257b291962d6c0ce106146c6447f405b60b234c4f222a7cde/grpcio-1.80.0-cp311-cp311-linux_armv7l.whl", hash = "sha256:dfab85db094068ff42e2a3563f60ab3dddcc9d6488a35abf0132daec13209c8a", size = 6055009, upload-time = "2026-03-30T08:46:46.265Z" }, + { url = "https://files.pythonhosted.org/packages/6e/18/c83f3cad64c5ca63bca7e91e5e46b0d026afc5af9d0a9972472ceba294b3/grpcio-1.80.0-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:5c07e82e822e1161354e32da2662f741a4944ea955f9f580ec8fb409dd6f6060", size = 12035295, upload-time = "2026-03-30T08:46:49.099Z" }, + { url = "https://files.pythonhosted.org/packages/0f/8e/e14966b435be2dda99fbe89db9525ea436edc79780431a1c2875a3582644/grpcio-1.80.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ba0915d51fd4ced2db5ff719f84e270afe0e2d4c45a7bdb1e8d036e4502928c2", size = 6610297, upload-time = "2026-03-30T08:46:52.123Z" }, + { url = "https://files.pythonhosted.org/packages/cc/26/d5eb38f42ce0e3fdc8174ea4d52036ef8d58cc4426cb800f2610f625dd75/grpcio-1.80.0-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:3cb8130ba457d2aa09fa6b7c3ed6b6e4e6a2685fce63cb803d479576c4d80e21", size = 7300208, upload-time = "2026-03-30T08:46:54.859Z" }, + { url = "https://files.pythonhosted.org/packages/25/51/bd267c989f85a17a5b3eea65a6feb4ff672af41ca614e5a0279cc0ea381c/grpcio-1.80.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:09e5e478b3d14afd23f12e49e8b44c8684ac3c5f08561c43a5b9691c54d136ab", size = 6813442, upload-time = "2026-03-30T08:46:57.056Z" }, + { url = "https://files.pythonhosted.org/packages/9e/d9/d80eef735b19e9169e30164bbf889b46f9df9127598a83d174eb13a48b26/grpcio-1.80.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:00168469238b022500e486c1c33916acf2f2a9b2c022202cf8a1885d2e3073c1", size = 7414743, upload-time = "2026-03-30T08:46:59.682Z" }, + { url = "https://files.pythonhosted.org/packages/de/f2/567f5bd5054398ed6b0509b9a30900376dcf2786bd936812098808b49d8d/grpcio-1.80.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:8502122a3cc1714038e39a0b071acb1207ca7844208d5ea0d091317555ee7106", size = 8426046, upload-time = "2026-03-30T08:47:02.474Z" }, + { url = "https://files.pythonhosted.org/packages/62/29/73ef0141b4732ff5eacd68430ff2512a65c004696997f70476a83e548e7e/grpcio-1.80.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ce1794f4ea6cc3ca29463f42d665c32ba1b964b48958a66497917fe9069f26e6", size = 7851641, upload-time = "2026-03-30T08:47:05.462Z" }, + { url = "https://files.pythonhosted.org/packages/46/69/abbfa360eb229a8623bab5f5a4f8105e445bd38ce81a89514ba55d281ad0/grpcio-1.80.0-cp311-cp311-win32.whl", hash = "sha256:51b4a7189b0bef2aa30adce3c78f09c83526cf3dddb24c6a96555e3b97340440", size = 4154368, upload-time = "2026-03-30T08:47:08.027Z" }, + { url = "https://files.pythonhosted.org/packages/6f/d4/ae92206d01183b08613e846076115f5ac5991bae358d2a749fa864da5699/grpcio-1.80.0-cp311-cp311-win_amd64.whl", hash = "sha256:02e64bb0bb2da14d947a49e6f120a75e947250aebe65f9629b62bb1f5c14e6e9", size = 4894235, upload-time = "2026-03-30T08:47:10.839Z" }, + { url = "https://files.pythonhosted.org/packages/5c/e8/a2b749265eb3415abc94f2e619bbd9e9707bebdda787e61c593004ec927a/grpcio-1.80.0-cp312-cp312-linux_armv7l.whl", hash = "sha256:c624cc9f1008361014378c9d776de7182b11fe8b2e5a81bc69f23a295f2a1ad0", size = 6015616, upload-time = "2026-03-30T08:47:13.428Z" }, + { url = "https://files.pythonhosted.org/packages/3e/97/b1282161a15d699d1e90c360df18d19165a045ce1c343c7f313f5e8a0b77/grpcio-1.80.0-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:f49eddcac43c3bf350c0385366a58f36bed8cc2c0ec35ef7b74b49e56552c0c2", size = 12014204, upload-time = "2026-03-30T08:47:15.873Z" }, + { url = "https://files.pythonhosted.org/packages/6e/5e/d319c6e997b50c155ac5a8cb12f5173d5b42677510e886d250d50264949d/grpcio-1.80.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d334591df610ab94714048e0d5b4f3dd5ad1bee74dfec11eee344220077a79de", size = 6563866, upload-time = "2026-03-30T08:47:18.588Z" }, + { url = "https://files.pythonhosted.org/packages/ae/f6/fdd975a2cb4d78eb67769a7b3b3830970bfa2e919f1decf724ae4445f42c/grpcio-1.80.0-cp312-cp312-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:0cb517eb1d0d0aaf1d87af7cc5b801d686557c1d88b2619f5e31fab3c2315921", size = 7273060, upload-time = "2026-03-30T08:47:21.113Z" }, + { url = "https://files.pythonhosted.org/packages/db/f0/a3deb5feba60d9538a962913e37bd2e69a195f1c3376a3dd44fe0427e996/grpcio-1.80.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4e78c4ac0d97dc2e569b2f4bcbbb447491167cb358d1a389fc4af71ab6f70411", size = 6782121, upload-time = "2026-03-30T08:47:23.827Z" }, + { url = "https://files.pythonhosted.org/packages/ca/84/36c6dcfddc093e108141f757c407902a05085e0c328007cb090d56646cdf/grpcio-1.80.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2ed770b4c06984f3b47eb0517b1c69ad0b84ef3f40128f51448433be904634cd", size = 7383811, upload-time = "2026-03-30T08:47:26.517Z" }, + { url = "https://files.pythonhosted.org/packages/7c/ef/f3a77e3dc5b471a0ec86c564c98d6adfa3510d38f8ee99010410858d591e/grpcio-1.80.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:256507e2f524092f1473071a05e65a5b10d84b82e3ff24c5b571513cfaa61e2f", size = 8393860, upload-time = "2026-03-30T08:47:29.439Z" }, + { url = "https://files.pythonhosted.org/packages/9b/8d/9d4d27ed7f33d109c50d6b5ce578a9914aa68edab75d65869a17e630a8d1/grpcio-1.80.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:9a6284a5d907c37db53350645567c522be314bac859a64a7a5ca63b77bb7958f", size = 7830132, upload-time = "2026-03-30T08:47:33.254Z" }, + { url = "https://files.pythonhosted.org/packages/14/e4/9990b41c6d7a44e1e9dee8ac11d7a9802ba1378b40d77468a7761d1ad288/grpcio-1.80.0-cp312-cp312-win32.whl", hash = "sha256:c71309cfce2f22be26aa4a847357c502db6c621f1a49825ae98aa0907595b193", size = 4140904, upload-time = "2026-03-30T08:47:35.319Z" }, + { url = "https://files.pythonhosted.org/packages/2f/2c/296f6138caca1f4b92a31ace4ae1b87dab692fc16a7a3417af3bb3c805bf/grpcio-1.80.0-cp312-cp312-win_amd64.whl", hash = "sha256:9fe648599c0e37594c4809d81a9e77bd138cc82eb8baa71b6a86af65426723ff", size = 4880944, upload-time = "2026-03-30T08:47:37.831Z" }, + { url = "https://files.pythonhosted.org/packages/2f/3a/7c3c25789e3f069e581dc342e03613c5b1cb012c4e8c7d9d5cf960a75856/grpcio-1.80.0-cp313-cp313-linux_armv7l.whl", hash = "sha256:e9e408fc016dffd20661f0126c53d8a31c2821b5c13c5d67a0f5ed5de93319ad", size = 6017243, upload-time = "2026-03-30T08:47:40.075Z" }, + { url = "https://files.pythonhosted.org/packages/04/19/21a9806eb8240e174fd1ab0cd5b9aa948bb0e05c2f2f55f9d5d7405e6d08/grpcio-1.80.0-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:92d787312e613754d4d8b9ca6d3297e69994a7912a32fa38c4c4e01c272974b0", size = 12010840, upload-time = "2026-03-30T08:47:43.11Z" }, + { url = "https://files.pythonhosted.org/packages/18/3a/23347d35f76f639e807fb7a36fad3068aed100996849a33809591f26eca6/grpcio-1.80.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8ac393b58aa16991a2f1144ec578084d544038c12242da3a215966b512904d0f", size = 6567644, upload-time = "2026-03-30T08:47:46.806Z" }, + { url = "https://files.pythonhosted.org/packages/ff/40/96e07ecb604a6a67ae6ab151e3e35b132875d98bc68ec65f3e5ab3e781d7/grpcio-1.80.0-cp313-cp313-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:68e5851ac4b9afe07e7f84483803ad167852570d65326b34d54ca560bfa53fb6", size = 7277830, upload-time = "2026-03-30T08:47:49.643Z" }, + { url = "https://files.pythonhosted.org/packages/9b/e2/da1506ecea1f34a5e365964644b35edef53803052b763ca214ba3870c856/grpcio-1.80.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:873ff5d17d68992ef6605330127425d2fc4e77e612fa3c3e0ed4e668685e3140", size = 6783216, upload-time = "2026-03-30T08:47:52.817Z" }, + { url = "https://files.pythonhosted.org/packages/44/83/3b20ff58d0c3b7f6caaa3af9a4174d4023701df40a3f39f7f1c8e7c48f9d/grpcio-1.80.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:2bea16af2750fd0a899bf1abd9022244418b55d1f37da2202249ba4ba673838d", size = 7385866, upload-time = "2026-03-30T08:47:55.687Z" }, + { url = "https://files.pythonhosted.org/packages/47/45/55c507599c5520416de5eefecc927d6a0d7af55e91cfffb2e410607e5744/grpcio-1.80.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ba0db34f7e1d803a878284cd70e4c63cb6ae2510ba51937bf8f45ba997cefcf7", size = 8391602, upload-time = "2026-03-30T08:47:58.303Z" }, + { url = "https://files.pythonhosted.org/packages/10/bb/dd06f4c24c01db9cf11341b547d0a016b2c90ed7dbbb086a5710df7dd1d7/grpcio-1.80.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8eb613f02d34721f1acf3626dfdb3545bd3c8505b0e52bf8b5710a28d02e8aa7", size = 7826752, upload-time = "2026-03-30T08:48:01.311Z" }, + { url = "https://files.pythonhosted.org/packages/f9/1e/9d67992ba23371fd63d4527096eb8c6b76d74d52b500df992a3343fd7251/grpcio-1.80.0-cp313-cp313-win32.whl", hash = "sha256:93b6f823810720912fd131f561f91f5fed0fda372b6b7028a2681b8194d5d294", size = 4142310, upload-time = "2026-03-30T08:48:04.594Z" }, + { url = "https://files.pythonhosted.org/packages/cf/e6/283326a27da9e2c3038bc93eeea36fb118ce0b2d03922a9cda6688f53c5b/grpcio-1.80.0-cp313-cp313-win_amd64.whl", hash = "sha256:e172cf795a3ba5246d3529e4d34c53db70e888fa582a8ffebd2e6e48bc0cba50", size = 4882833, upload-time = "2026-03-30T08:48:07.363Z" }, + { url = "https://files.pythonhosted.org/packages/c5/6d/e65307ce20f5a09244ba9e9d8476e99fb039de7154f37fb85f26978b59c3/grpcio-1.80.0-cp314-cp314-linux_armv7l.whl", hash = "sha256:3d4147a97c8344d065d01bbf8b6acec2cf86fb0400d40696c8bdad34a64ffc0e", size = 6017376, upload-time = "2026-03-30T08:48:10.005Z" }, + { url = "https://files.pythonhosted.org/packages/69/10/9cef5d9650c72625a699c549940f0abb3c4bfdb5ed45a5ce431f92f31806/grpcio-1.80.0-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:d8e11f167935b3eb089ac9038e1a063e6d7dbe995c0bb4a661e614583352e76f", size = 12018133, upload-time = "2026-03-30T08:48:12.927Z" }, + { url = "https://files.pythonhosted.org/packages/04/82/983aabaad82ba26113caceeb9091706a0696b25da004fe3defb5b346e15b/grpcio-1.80.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f14b618fc30de822681ee986cfdcc2d9327229dc4c98aed16896761cacd468b9", size = 6574748, upload-time = "2026-03-30T08:48:16.386Z" }, + { url = "https://files.pythonhosted.org/packages/07/d7/031666ef155aa0bf399ed7e19439656c38bbd143779ae0861b038ce82abd/grpcio-1.80.0-cp314-cp314-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:4ed39fbdcf9b87370f6e8df4e39ca7b38b3e5e9d1b0013c7b6be9639d6578d14", size = 7277711, upload-time = "2026-03-30T08:48:19.627Z" }, + { url = "https://files.pythonhosted.org/packages/e8/43/f437a78f7f4f1d311804189e8f11fb311a01049b2e08557c1068d470cb2e/grpcio-1.80.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2dcc70e9f0ba987526e8e8603a610fb4f460e42899e74e7a518bf3c68fe1bf05", size = 6785372, upload-time = "2026-03-30T08:48:22.373Z" }, + { url = "https://files.pythonhosted.org/packages/93/3d/f6558e9c6296cb4227faa5c43c54a34c68d32654b829f53288313d16a86e/grpcio-1.80.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:448c884b668b868562b1bda833c5fce6272d26e1926ec46747cda05741d302c1", size = 7395268, upload-time = "2026-03-30T08:48:25.638Z" }, + { url = "https://files.pythonhosted.org/packages/06/21/0fdd77e84720b08843c371a2efa6f2e19dbebf56adc72df73d891f5506f0/grpcio-1.80.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:a1dc80fe55685b4a543555e6eef975303b36c8db1023b1599b094b92aa77965f", size = 8392000, upload-time = "2026-03-30T08:48:28.974Z" }, + { url = "https://files.pythonhosted.org/packages/f5/68/67f4947ed55d2e69f2cc199ab9fd85e0a0034d813bbeef84df6d2ba4d4b7/grpcio-1.80.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:31b9ac4ad1aa28ffee5503821fafd09e4da0a261ce1c1281c6c8da0423c83b6e", size = 7828477, upload-time = "2026-03-30T08:48:32.054Z" }, + { url = "https://files.pythonhosted.org/packages/44/b6/8d4096691b2e385e8271911a0de4f35f0a6c7d05aff7098e296c3de86939/grpcio-1.80.0-cp314-cp314-win32.whl", hash = "sha256:367ce30ba67d05e0592470428f0ec1c31714cab9ef19b8f2e37be1f4c7d32fae", size = 4218563, upload-time = "2026-03-30T08:48:34.538Z" }, + { url = "https://files.pythonhosted.org/packages/e5/8c/bbe6baf2557262834f2070cf668515fa308b2d38a4bbf771f8f7872a7036/grpcio-1.80.0-cp314-cp314-win_amd64.whl", hash = "sha256:3b01e1f5464c583d2f567b2e46ff0d516ef979978f72091fd81f5ab7fa6e2e7f", size = 5019457, upload-time = "2026-03-30T08:48:37.308Z" }, +] + +[[package]] +name = "idna" +version = "3.13" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ce/cc/762dfb036166873f0059f3b7de4565e1b5bc3d6f28a414c13da27e442f99/idna-3.13.tar.gz", hash = "sha256:585ea8fe5d69b9181ec1afba340451fba6ba764af97026f92a91d4eef164a242", size = 194210, upload-time = "2026-04-22T16:42:42.314Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5d/13/ad7d7ca3808a898b4612b6fe93cde56b53f3034dcde235acb1f0e1df24c6/idna-3.13-py3-none-any.whl", hash = "sha256:892ea0cde124a99ce773decba204c5552b69c3c67ffd5f232eb7696135bc8bb3", size = 68629, upload-time = "2026-04-22T16:42:40.909Z" }, +] + +[[package]] +name = "ipython" +version = "9.13.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "decorator" }, + { name = "ipython-pygments-lexers" }, + { name = "jedi" }, + { name = "matplotlib-inline" }, + { name = "pexpect", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, + { name = "prompt-toolkit" }, + { name = "psutil" }, + { name = "pygments" }, + { name = "stack-data" }, + { name = "traitlets" }, + { name = "typing-extensions", marker = "python_full_version < '3.12'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/cd/c4/87cda5842cf5c31837c06ddb588e11c3c35d8ece89b7a0108c06b8c9b00a/ipython-9.13.0.tar.gz", hash = "sha256:7e834b6afc99f020e3f05966ced34792f40267d64cb1ea9043886dab0dde5967", size = 4430549, upload-time = "2026-04-24T12:24:55.221Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b9/86/3060e8029b7cc505cce9a0137431dda81d0a3fde93a8f0f50ee0bf37a795/ipython-9.13.0-py3-none-any.whl", hash = "sha256:57f9d4639e20818d328d287c7b549af3d05f12486ea8f2e7f73e52a36ec4d201", size = 627274, upload-time = "2026-04-24T12:24:53.038Z" }, +] + +[[package]] +name = "ipython-pygments-lexers" +version = "1.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ef/4c/5dd1d8af08107f88c7f741ead7a40854b8ac24ddf9ae850afbcf698aa552/ipython_pygments_lexers-1.1.1.tar.gz", hash = "sha256:09c0138009e56b6854f9535736f4171d855c8c08a563a0dcd8022f78355c7e81", size = 8393, upload-time = "2025-01-17T11:24:34.505Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d9/33/1f075bf72b0b747cb3288d011319aaf64083cf2efef8354174e3ed4540e2/ipython_pygments_lexers-1.1.1-py3-none-any.whl", hash = "sha256:a9462224a505ade19a605f71f8fa63c2048833ce50abc86768a0d81d876dc81c", size = 8074, upload-time = "2025-01-17T11:24:33.271Z" }, +] + +[[package]] +name = "jedi" +version = "0.20.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "parso" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/46/b7/a3635f6a2d7cf5b5dd98064fc1d5fbbafcb25477bcea204a3a92145d158b/jedi-0.20.0.tar.gz", hash = "sha256:c3f4ccbd276696f4b19c54618d4fb18f9fc24b0aef02acf704b23f487daa1011", size = 3119416, upload-time = "2026-05-01T23:38:47.814Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9a/93/242e2eab5fe682ffcb8b0084bde703a41d51e17ee0f3a31ff0d9d813620a/jedi-0.20.0-py2.py3-none-any.whl", hash = "sha256:7bdd9c2634f56713299976f4cbd59cb3fa92165cc5e05ea811fb253480728b67", size = 4884812, upload-time = "2026-05-01T23:38:43.919Z" }, +] + +[[package]] +name = "jinja2" +version = "3.1.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markupsafe" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115, upload-time = "2025-03-05T20:05:02.478Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" }, +] + +[[package]] +name = "joblib" +version = "1.5.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/41/f2/d34e8b3a08a9cc79a50b2208a93dce981fe615b64d5a4d4abee421d898df/joblib-1.5.3.tar.gz", hash = "sha256:8561a3269e6801106863fd0d6d84bb737be9e7631e33aaed3fb9ce5953688da3", size = 331603, upload-time = "2025-12-15T08:41:46.427Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7b/91/984aca2ec129e2757d1e4e3c81c3fcda9d0f85b74670a094cc443d9ee949/joblib-1.5.3-py3-none-any.whl", hash = "sha256:5fc3c5039fc5ca8c0276333a188bbd59d6b7ab37fe6632daa76bc7f9ec18e713", size = 309071, upload-time = "2025-12-15T08:41:44.973Z" }, +] + +[[package]] +name = "julius" +version = "0.2.7" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "torch" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a1/19/c9e1596b5572c786b93428d0904280e964c930fae7e6c9368ed9e1b63922/julius-0.2.7.tar.gz", hash = "sha256:3c0f5f5306d7d6016fcc95196b274cae6f07e2c9596eed314e4e7641554fbb08", size = 59640, upload-time = "2022-09-19T16:13:34.2Z" } + +[[package]] +name = "kiwisolver" +version = "1.5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d0/67/9c61eccb13f0bdca9307614e782fec49ffdde0f7a2314935d489fa93cd9c/kiwisolver-1.5.0.tar.gz", hash = "sha256:d4193f3d9dc3f6f79aaed0e5637f45d98850ebf01f7ca20e69457f3e8946b66a", size = 103482, upload-time = "2026-03-09T13:15:53.382Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/12/dd/a495a9c104be1c476f0386e714252caf2b7eca883915422a64c50b88c6f5/kiwisolver-1.5.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:9eed0f7edbb274413b6ee781cca50541c8c0facd3d6fd289779e494340a2b85c", size = 122798, upload-time = "2026-03-09T13:12:58.963Z" }, + { url = "https://files.pythonhosted.org/packages/11/60/37b4047a2af0cf5ef6d8b4b26e91829ae6fc6a2d1f74524bcb0e7cd28a32/kiwisolver-1.5.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3c4923e404d6bcd91b6779c009542e5647fef32e4a5d75e115e3bbac6f2335eb", size = 66216, upload-time = "2026-03-09T13:13:00.155Z" }, + { url = "https://files.pythonhosted.org/packages/0a/aa/510dc933d87767584abfe03efa445889996c70c2990f6f87c3ebaa0a18c5/kiwisolver-1.5.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:0df54df7e686afa55e6f21fb86195224a6d9beb71d637e8d7920c95cf0f89aac", size = 63911, upload-time = "2026-03-09T13:13:01.671Z" }, + { url = "https://files.pythonhosted.org/packages/80/46/bddc13df6c2a40741e0cc7865bb1c9ed4796b6760bd04ce5fae3928ef917/kiwisolver-1.5.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2517e24d7315eb51c10664cdb865195df38ab74456c677df67bb47f12d088a27", size = 1438209, upload-time = "2026-03-09T13:13:03.385Z" }, + { url = "https://files.pythonhosted.org/packages/fd/d6/76621246f5165e5372f02f5e6f3f48ea336a8f9e96e43997d45b240ed8cd/kiwisolver-1.5.0-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ff710414307fefa903e0d9bdf300972f892c23477829f49504e59834f4195398", size = 1248888, upload-time = "2026-03-09T13:13:05.231Z" }, + { url = "https://files.pythonhosted.org/packages/b2/c1/31559ec6fb39a5b48035ce29bb63ade628f321785f38c384dee3e2c08bc1/kiwisolver-1.5.0-cp311-cp311-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6176c1811d9d5a04fa391c490cc44f451e240697a16977f11c6f722efb9041db", size = 1266304, upload-time = "2026-03-09T13:13:06.743Z" }, + { url = "https://files.pythonhosted.org/packages/5e/ef/1cb8276f2d29cc6a41e0a042f27946ca347d3a4a75acf85d0a16aa6dcc82/kiwisolver-1.5.0-cp311-cp311-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:50847dca5d197fcbd389c805aa1a1cf32f25d2e7273dc47ab181a517666b68cc", size = 1319650, upload-time = "2026-03-09T13:13:08.607Z" }, + { url = "https://files.pythonhosted.org/packages/4c/e4/5ba3cecd7ce6236ae4a80f67e5d5531287337d0e1f076ca87a5abe4cd5d0/kiwisolver-1.5.0-cp311-cp311-manylinux_2_39_riscv64.whl", hash = "sha256:01808c6d15f4c3e8559595d6d1fe6411c68e4a3822b4b9972b44473b24f4e679", size = 970949, upload-time = "2026-03-09T13:13:10.299Z" }, + { url = "https://files.pythonhosted.org/packages/5a/69/dc61f7ae9a2f071f26004ced87f078235b5507ab6e5acd78f40365655034/kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:f1f9f4121ec58628c96baa3de1a55a4e3a333c5102c8e94b64e23bf7b2083309", size = 2199125, upload-time = "2026-03-09T13:13:11.841Z" }, + { url = "https://files.pythonhosted.org/packages/e5/7b/abbe0f1b5afa85f8d084b73e90e5f801c0939eba16ac2e49af7c61a6c28d/kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:b7d335370ae48a780c6e6a6bbfa97342f563744c39c35562f3f367665f5c1de2", size = 2293783, upload-time = "2026-03-09T13:13:14.399Z" }, + { url = "https://files.pythonhosted.org/packages/8a/80/5908ae149d96d81580d604c7f8aefd0e98f4fd728cf172f477e9f2a81744/kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:800ee55980c18545af444d93fdd60c56b580db5cc54867d8cbf8a1dc0829938c", size = 1960726, upload-time = "2026-03-09T13:13:16.047Z" }, + { url = "https://files.pythonhosted.org/packages/84/08/a78cb776f8c085b7143142ce479859cfec086bd09ee638a317040b6ef420/kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:c438f6ca858697c9ab67eb28246c92508af972e114cac34e57a6d4ba17a3ac08", size = 2464738, upload-time = "2026-03-09T13:13:17.897Z" }, + { url = "https://files.pythonhosted.org/packages/b1/e1/65584da5356ed6cb12c63791a10b208860ac40a83de165cb6a6751a686e3/kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:8c63c91f95173f9c2a67c7c526b2cea976828a0e7fced9cdcead2802dc10f8a4", size = 2270718, upload-time = "2026-03-09T13:13:19.421Z" }, + { url = "https://files.pythonhosted.org/packages/be/6c/28f17390b62b8f2f520e2915095b3c94d88681ecf0041e75389d9667f202/kiwisolver-1.5.0-cp311-cp311-win_amd64.whl", hash = "sha256:beb7f344487cdcb9e1efe4b7a29681b74d34c08f0043a327a74da852a6749e7b", size = 73480, upload-time = "2026-03-09T13:13:20.818Z" }, + { url = "https://files.pythonhosted.org/packages/d8/0e/2ee5debc4f77a625778fec5501ff3e8036fe361b7ee28ae402a485bb9694/kiwisolver-1.5.0-cp311-cp311-win_arm64.whl", hash = "sha256:ad4ae4ffd1ee9cd11357b4c66b612da9888f4f4daf2f36995eda64bd45370cac", size = 64930, upload-time = "2026-03-09T13:13:21.997Z" }, + { url = "https://files.pythonhosted.org/packages/4d/b2/818b74ebea34dabe6d0c51cb1c572e046730e64844da6ed646d5298c40ce/kiwisolver-1.5.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:4e9750bc21b886308024f8a54ccb9a2cc38ac9fa813bf4348434e3d54f337ff9", size = 123158, upload-time = "2026-03-09T13:13:23.127Z" }, + { url = "https://files.pythonhosted.org/packages/bf/d9/405320f8077e8e1c5c4bd6adc45e1e6edf6d727b6da7f2e2533cf58bff71/kiwisolver-1.5.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:72ec46b7eba5b395e0a7b63025490d3214c11013f4aacb4f5e8d6c3041829588", size = 66388, upload-time = "2026-03-09T13:13:24.765Z" }, + { url = "https://files.pythonhosted.org/packages/99/9f/795fedf35634f746151ca8839d05681ceb6287fbed6cc1c9bf235f7887c2/kiwisolver-1.5.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ed3a984b31da7481b103f68776f7128a89ef26ed40f4dc41a2223cda7fb24819", size = 64068, upload-time = "2026-03-09T13:13:25.878Z" }, + { url = "https://files.pythonhosted.org/packages/c4/13/680c54afe3e65767bed7ec1a15571e1a2f1257128733851ade24abcefbcc/kiwisolver-1.5.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:bb5136fb5352d3f422df33f0c879a1b0c204004324150cc3b5e3c4f310c9049f", size = 1477934, upload-time = "2026-03-09T13:13:27.166Z" }, + { url = "https://files.pythonhosted.org/packages/c8/2f/cebfcdb60fd6a9b0f6b47a9337198bcbad6fbe15e68189b7011fd914911f/kiwisolver-1.5.0-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b2af221f268f5af85e776a73d62b0845fc8baf8ef0abfae79d29c77d0e776aaf", size = 1278537, upload-time = "2026-03-09T13:13:28.707Z" }, + { url = "https://files.pythonhosted.org/packages/f2/0d/9b782923aada3fafb1d6b84e13121954515c669b18af0c26e7d21f579855/kiwisolver-1.5.0-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b0f172dc8ffaccb8522d7c5d899de00133f2f1ca7b0a49b7da98e901de87bf2d", size = 1296685, upload-time = "2026-03-09T13:13:30.528Z" }, + { url = "https://files.pythonhosted.org/packages/27/70/83241b6634b04fe44e892688d5208332bde130f38e610c0418f9ede47ded/kiwisolver-1.5.0-cp312-cp312-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6ab8ba9152203feec73758dad83af9a0bbe05001eb4639e547207c40cfb52083", size = 1346024, upload-time = "2026-03-09T13:13:32.818Z" }, + { url = "https://files.pythonhosted.org/packages/e4/db/30ed226fb271ae1a6431fc0fe0edffb2efe23cadb01e798caeb9f2ceae8f/kiwisolver-1.5.0-cp312-cp312-manylinux_2_39_riscv64.whl", hash = "sha256:cdee07c4d7f6d72008d3f73b9bf027f4e11550224c7c50d8df1ae4a37c1402a6", size = 987241, upload-time = "2026-03-09T13:13:34.435Z" }, + { url = "https://files.pythonhosted.org/packages/ec/bd/c314595208e4c9587652d50959ead9e461995389664e490f4dce7ff0f782/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:7c60d3c9b06fb23bd9c6139281ccbdc384297579ae037f08ae90c69f6845c0b1", size = 2227742, upload-time = "2026-03-09T13:13:36.4Z" }, + { url = "https://files.pythonhosted.org/packages/c1/43/0499cec932d935229b5543d073c2b87c9c22846aab48881e9d8d6e742a2d/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:e315e5ec90d88e140f57696ff85b484ff68bb311e36f2c414aa4286293e6dee0", size = 2323966, upload-time = "2026-03-09T13:13:38.204Z" }, + { url = "https://files.pythonhosted.org/packages/3d/6f/79b0d760907965acfd9d61826a3d41f8f093c538f55cd2633d3f0db269f6/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:1465387ac63576c3e125e5337a6892b9e99e0627d52317f3ca79e6930d889d15", size = 1977417, upload-time = "2026-03-09T13:13:39.966Z" }, + { url = "https://files.pythonhosted.org/packages/ab/31/01d0537c41cb75a551a438c3c7a80d0c60d60b81f694dac83dd436aec0d0/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:530a3fd64c87cffa844d4b6b9768774763d9caa299e9b75d8eca6a4423b31314", size = 2491238, upload-time = "2026-03-09T13:13:41.698Z" }, + { url = "https://files.pythonhosted.org/packages/e4/34/8aefdd0be9cfd00a44509251ba864f5caf2991e36772e61c408007e7f417/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1d9daea4ea6b9be74fe2f01f7fbade8d6ffab263e781274cffca0dba9be9eec9", size = 2294947, upload-time = "2026-03-09T13:13:43.343Z" }, + { url = "https://files.pythonhosted.org/packages/ad/cf/0348374369ca588f8fe9c338fae49fa4e16eeb10ffb3d012f23a54578a9e/kiwisolver-1.5.0-cp312-cp312-win_amd64.whl", hash = "sha256:f18c2d9782259a6dc132fdc7a63c168cbc74b35284b6d75c673958982a378384", size = 73569, upload-time = "2026-03-09T13:13:45.792Z" }, + { url = "https://files.pythonhosted.org/packages/28/26/192b26196e2316e2bd29deef67e37cdf9870d9af8e085e521afff0fed526/kiwisolver-1.5.0-cp312-cp312-win_arm64.whl", hash = "sha256:f7c7553b13f69c1b29a5bde08ddc6d9d0c8bfb84f9ed01c30db25944aeb852a7", size = 64997, upload-time = "2026-03-09T13:13:46.878Z" }, + { url = "https://files.pythonhosted.org/packages/9d/69/024d6711d5ba575aa65d5538042e99964104e97fa153a9f10bc369182bc2/kiwisolver-1.5.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:fd40bb9cd0891c4c3cb1ddf83f8bbfa15731a248fdc8162669405451e2724b09", size = 123166, upload-time = "2026-03-09T13:13:48.032Z" }, + { url = "https://files.pythonhosted.org/packages/ce/48/adbb40df306f587054a348831220812b9b1d787aff714cfbc8556e38fccd/kiwisolver-1.5.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:c0e1403fd7c26d77c1f03e096dc58a5c726503fa0db0456678b8668f76f521e3", size = 66395, upload-time = "2026-03-09T13:13:49.365Z" }, + { url = "https://files.pythonhosted.org/packages/a8/3a/d0a972b34e1c63e2409413104216cd1caa02c5a37cb668d1687d466c1c45/kiwisolver-1.5.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:dda366d548e89a90d88a86c692377d18d8bd64b39c1fb2b92cb31370e2896bbd", size = 64065, upload-time = "2026-03-09T13:13:50.562Z" }, + { url = "https://files.pythonhosted.org/packages/2b/0a/7b98e1e119878a27ba8618ca1e18b14f992ff1eda40f47bccccf4de44121/kiwisolver-1.5.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:332b4f0145c30b5f5ad9374881133e5aa64320428a57c2c2b61e9d891a51c2f3", size = 1477903, upload-time = "2026-03-09T13:13:52.084Z" }, + { url = "https://files.pythonhosted.org/packages/18/d8/55638d89ffd27799d5cc3d8aa28e12f4ce7a64d67b285114dbedc8ea4136/kiwisolver-1.5.0-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0c50b89ffd3e1a911c69a1dd3de7173c0cd10b130f56222e57898683841e4f96", size = 1278751, upload-time = "2026-03-09T13:13:54.673Z" }, + { url = "https://files.pythonhosted.org/packages/b8/97/b4c8d0d18421ecceba20ad8701358453b88e32414e6f6950b5a4bad54e65/kiwisolver-1.5.0-cp313-cp313-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4db576bb8c3ef9365f8b40fe0f671644de6736ae2c27a2c62d7d8a1b4329f099", size = 1296793, upload-time = "2026-03-09T13:13:56.287Z" }, + { url = "https://files.pythonhosted.org/packages/c4/10/f862f94b6389d8957448ec9df59450b81bec4abb318805375c401a1e6892/kiwisolver-1.5.0-cp313-cp313-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0b85aad90cea8ac6797a53b5d5f2e967334fa4d1149f031c4537569972596cb8", size = 1346041, upload-time = "2026-03-09T13:13:58.269Z" }, + { url = "https://files.pythonhosted.org/packages/a3/6a/f1650af35821eaf09de398ec0bc2aefc8f211f0cda50204c9f1673741ba9/kiwisolver-1.5.0-cp313-cp313-manylinux_2_39_riscv64.whl", hash = "sha256:d36ca54cb4c6c4686f7cbb7b817f66f5911c12ddb519450bbe86707155028f87", size = 987292, upload-time = "2026-03-09T13:13:59.871Z" }, + { url = "https://files.pythonhosted.org/packages/de/19/d7fb82984b9238115fe629c915007be608ebd23dc8629703d917dbfaffd4/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:38f4a703656f493b0ad185211ccfca7f0386120f022066b018eb5296d8613e23", size = 2227865, upload-time = "2026-03-09T13:14:01.401Z" }, + { url = "https://files.pythonhosted.org/packages/7f/b9/46b7f386589fd222dac9e9de9c956ce5bcefe2ee73b4e79891381dda8654/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:3ac2360e93cb41be81121755c6462cff3beaa9967188c866e5fce5cf13170859", size = 2324369, upload-time = "2026-03-09T13:14:02.972Z" }, + { url = "https://files.pythonhosted.org/packages/92/8b/95e237cf3d9c642960153c769ddcbe278f182c8affb20cecc1cc983e7cc5/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c95cab08d1965db3d84a121f1c7ce7479bdd4072c9b3dafd8fecce48a2e6b902", size = 1977989, upload-time = "2026-03-09T13:14:04.503Z" }, + { url = "https://files.pythonhosted.org/packages/1b/95/980c9df53501892784997820136c01f62bc1865e31b82b9560f980c0e649/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:fc20894c3d21194d8041a28b65622d5b86db786da6e3cfe73f0c762951a61167", size = 2491645, upload-time = "2026-03-09T13:14:06.106Z" }, + { url = "https://files.pythonhosted.org/packages/cb/32/900647fd0840abebe1561792c6b31e6a7c0e278fc3973d30572a965ca14c/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:7a32f72973f0f950c1920475d5c5ea3d971b81b6f0ec53b8d0a956cc965f22e0", size = 2295237, upload-time = "2026-03-09T13:14:08.891Z" }, + { url = "https://files.pythonhosted.org/packages/be/8a/be60e3bbcf513cc5a50f4a3e88e1dcecebb79c1ad607a7222877becaa101/kiwisolver-1.5.0-cp313-cp313-win_amd64.whl", hash = "sha256:0bf3acf1419fa93064a4c2189ac0b58e3be7872bf6ee6177b0d4c63dc4cea276", size = 73573, upload-time = "2026-03-09T13:14:12.327Z" }, + { url = "https://files.pythonhosted.org/packages/4d/d2/64be2e429eb4fca7f7e1c52a91b12663aeaf25de3895e5cca0f47ef2a8d0/kiwisolver-1.5.0-cp313-cp313-win_arm64.whl", hash = "sha256:fa8eb9ecdb7efb0b226acec134e0d709e87a909fa4971a54c0c4f6e88635484c", size = 64998, upload-time = "2026-03-09T13:14:13.469Z" }, + { url = "https://files.pythonhosted.org/packages/b0/69/ce68dd0c85755ae2de490bf015b62f2cea5f6b14ff00a463f9d0774449ff/kiwisolver-1.5.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:db485b3847d182b908b483b2ed133c66d88d49cacf98fd278fadafe11b4478d1", size = 125700, upload-time = "2026-03-09T13:14:14.636Z" }, + { url = "https://files.pythonhosted.org/packages/74/aa/937aac021cf9d4349990d47eb319309a51355ed1dbdc9c077cdc9224cb11/kiwisolver-1.5.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:be12f931839a3bdfe28b584db0e640a65a8bcbc24560ae3fdb025a449b3d754e", size = 67537, upload-time = "2026-03-09T13:14:15.808Z" }, + { url = "https://files.pythonhosted.org/packages/ee/20/3a87fbece2c40ad0f6f0aefa93542559159c5f99831d596050e8afae7a9f/kiwisolver-1.5.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:16b85d37c2cbb3253226d26e64663f755d88a03439a9c47df6246b35defbdfb7", size = 65514, upload-time = "2026-03-09T13:14:18.035Z" }, + { url = "https://files.pythonhosted.org/packages/f0/7f/f943879cda9007c45e1f7dba216d705c3a18d6b35830e488b6c6a4e7cdf0/kiwisolver-1.5.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4432b835675f0ea7414aab3d37d119f7226d24869b7a829caeab49ebda407b0c", size = 1584848, upload-time = "2026-03-09T13:14:19.745Z" }, + { url = "https://files.pythonhosted.org/packages/37/f8/4d4f85cc1870c127c88d950913370dd76138482161cd07eabbc450deff01/kiwisolver-1.5.0-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b0feb50971481a2cc44d94e88bdb02cdd497618252ae226b8eb1201b957e368", size = 1391542, upload-time = "2026-03-09T13:14:21.54Z" }, + { url = "https://files.pythonhosted.org/packages/04/0b/65dd2916c84d252b244bd405303220f729e7c17c9d7d33dca6feeff9ffc4/kiwisolver-1.5.0-cp313-cp313t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:56fa888f10d0f367155e76ce849fa1166fc9730d13bd2d65a2aa13b6f5424489", size = 1404447, upload-time = "2026-03-09T13:14:23.205Z" }, + { url = "https://files.pythonhosted.org/packages/39/5c/2606a373247babce9b1d056c03a04b65f3cf5290a8eac5d7bdead0a17e21/kiwisolver-1.5.0-cp313-cp313t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:940dda65d5e764406b9fb92761cbf462e4e63f712ab60ed98f70552e496f3bf1", size = 1455918, upload-time = "2026-03-09T13:14:24.74Z" }, + { url = "https://files.pythonhosted.org/packages/d5/d1/c6078b5756670658e9192a2ef11e939c92918833d2745f85cd14a6004bdf/kiwisolver-1.5.0-cp313-cp313t-manylinux_2_39_riscv64.whl", hash = "sha256:89fc958c702ee9a745e4700378f5d23fddbc46ff89e8fdbf5395c24d5c1452a3", size = 1072856, upload-time = "2026-03-09T13:14:26.597Z" }, + { url = "https://files.pythonhosted.org/packages/cb/c8/7def6ddf16eb2b3741d8b172bdaa9af882b03c78e9b0772975408801fa63/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9027d773c4ff81487181a925945743413f6069634d0b122d0b37684ccf4f1e18", size = 2333580, upload-time = "2026-03-09T13:14:28.237Z" }, + { url = "https://files.pythonhosted.org/packages/9e/87/2ac1fce0eb1e616fcd3c35caa23e665e9b1948bb984f4764790924594128/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:5b233ea3e165e43e35dba1d2b8ecc21cf070b45b65ae17dd2747d2713d942021", size = 2423018, upload-time = "2026-03-09T13:14:30.018Z" }, + { url = "https://files.pythonhosted.org/packages/67/13/c6700ccc6cc218716bfcda4935e4b2997039869b4ad8a94f364c5a3b8e63/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:ce9bf03dad3b46408c08649c6fbd6ca28a9fce0eb32fdfffa6775a13103b5310", size = 2062804, upload-time = "2026-03-09T13:14:32.888Z" }, + { url = "https://files.pythonhosted.org/packages/1b/bd/877056304626943ff0f1f44c08f584300c199b887cb3176cd7e34f1515f1/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:fc4d3f1fb9ca0ae9f97b095963bc6326f1dbfd3779d6679a1e016b9baaa153d3", size = 2597482, upload-time = "2026-03-09T13:14:34.971Z" }, + { url = "https://files.pythonhosted.org/packages/75/19/c60626c47bf0f8ac5dcf72c6c98e266d714f2fbbfd50cf6dab5ede3aaa50/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:f443b4825c50a51ee68585522ab4a1d1257fac65896f282b4c6763337ac9f5d2", size = 2394328, upload-time = "2026-03-09T13:14:36.816Z" }, + { url = "https://files.pythonhosted.org/packages/47/84/6a6d5e5bb8273756c27b7d810d47f7ef2f1f9b9fd23c9ee9a3f8c75c9cef/kiwisolver-1.5.0-cp313-cp313t-win_arm64.whl", hash = "sha256:893ff3a711d1b515ba9da14ee090519bad4610ed1962fbe298a434e8c5f8db53", size = 68410, upload-time = "2026-03-09T13:14:38.695Z" }, + { url = "https://files.pythonhosted.org/packages/e4/d7/060f45052f2a01ad5762c8fdecd6d7a752b43400dc29ff75cd47225a40fd/kiwisolver-1.5.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:8df31fe574b8b3993cc61764f40941111b25c2d9fea13d3ce24a49907cd2d615", size = 123231, upload-time = "2026-03-09T13:14:41.323Z" }, + { url = "https://files.pythonhosted.org/packages/c2/a7/78da680eadd06ff35edef6ef68a1ad273bad3e2a0936c9a885103230aece/kiwisolver-1.5.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:1d49a49ac4cbfb7c1375301cd1ec90169dfeae55ff84710d782260ce77a75a02", size = 66489, upload-time = "2026-03-09T13:14:42.534Z" }, + { url = "https://files.pythonhosted.org/packages/49/b2/97980f3ad4fae37dd7fe31626e2bf75fbf8bdf5d303950ec1fab39a12da8/kiwisolver-1.5.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:0cbe94b69b819209a62cb27bdfa5dc2a8977d8de2f89dfd97ba4f53ed3af754e", size = 64063, upload-time = "2026-03-09T13:14:44.759Z" }, + { url = "https://files.pythonhosted.org/packages/e7/f9/b06c934a6aa8bc91f566bd2a214fd04c30506c2d9e2b6b171953216a65b6/kiwisolver-1.5.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:80aa065ffd378ff784822a6d7c3212f2d5f5e9c3589614b5c228b311fd3063ac", size = 1475913, upload-time = "2026-03-09T13:14:46.247Z" }, + { url = "https://files.pythonhosted.org/packages/6b/f0/f768ae564a710135630672981231320bc403cf9152b5596ec5289de0f106/kiwisolver-1.5.0-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4e7f886f47ab881692f278ae901039a234e4025a68e6dfab514263a0b1c4ae05", size = 1282782, upload-time = "2026-03-09T13:14:48.458Z" }, + { url = "https://files.pythonhosted.org/packages/e2/9f/1de7aad00697325f05238a5f2eafbd487fb637cc27a558b5367a5f37fb7f/kiwisolver-1.5.0-cp314-cp314-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5060731cc3ed12ca3a8b57acd4aeca5bbc2f49216dd0bec1650a1acd89486bcd", size = 1300815, upload-time = "2026-03-09T13:14:50.721Z" }, + { url = "https://files.pythonhosted.org/packages/5a/c2/297f25141d2e468e0ce7f7a7b92e0cf8918143a0cbd3422c1ad627e85a06/kiwisolver-1.5.0-cp314-cp314-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:7a4aa69609f40fce3cbc3f87b2061f042eee32f94b8f11db707b66a26461591a", size = 1347925, upload-time = "2026-03-09T13:14:52.304Z" }, + { url = "https://files.pythonhosted.org/packages/b9/d3/f4c73a02eb41520c47610207b21afa8cdd18fdbf64ffd94674ae21c4812d/kiwisolver-1.5.0-cp314-cp314-manylinux_2_39_riscv64.whl", hash = "sha256:d168fda2dbff7b9b5f38e693182d792a938c31db4dac3a80a4888de603c99554", size = 991322, upload-time = "2026-03-09T13:14:54.637Z" }, + { url = "https://files.pythonhosted.org/packages/7b/46/d3f2efef7732fcda98d22bf4ad5d3d71d545167a852ca710a494f4c15343/kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:413b820229730d358efd838ecbab79902fe97094565fdc80ddb6b0a18c18a581", size = 2232857, upload-time = "2026-03-09T13:14:56.471Z" }, + { url = "https://files.pythonhosted.org/packages/3f/ec/2d9756bf2b6d26ae4349b8d3662fb3993f16d80c1f971c179ce862b9dbae/kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:5124d1ea754509b09e53738ec185584cc609aae4a3b510aaf4ed6aa047ef9303", size = 2329376, upload-time = "2026-03-09T13:14:58.072Z" }, + { url = "https://files.pythonhosted.org/packages/8f/9f/876a0a0f2260f1bde92e002b3019a5fabc35e0939c7d945e0fa66185eb20/kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:e4415a8db000bf49a6dd1c478bf70062eaacff0f462b92b0ba68791a905861f9", size = 1982549, upload-time = "2026-03-09T13:14:59.668Z" }, + { url = "https://files.pythonhosted.org/packages/6c/4f/ba3624dfac23a64d54ac4179832860cb537c1b0af06024936e82ca4154a0/kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:d618fd27420381a4f6044faa71f46d8bfd911bd077c555f7138ed88729bfbe79", size = 2494680, upload-time = "2026-03-09T13:15:01.364Z" }, + { url = "https://files.pythonhosted.org/packages/39/b7/97716b190ab98911b20d10bf92eca469121ec483b8ce0edd314f51bc85af/kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5092eb5b1172947f57d6ea7d89b2f29650414e4293c47707eb499ec07a0ac796", size = 2297905, upload-time = "2026-03-09T13:15:03.925Z" }, + { url = "https://files.pythonhosted.org/packages/a3/36/4e551e8aa55c9188bca9abb5096805edbf7431072b76e2298e34fd3a3008/kiwisolver-1.5.0-cp314-cp314-win_amd64.whl", hash = "sha256:d76e2d8c75051d58177e762164d2e9ab92886534e3a12e795f103524f221dd8e", size = 75086, upload-time = "2026-03-09T13:15:07.775Z" }, + { url = "https://files.pythonhosted.org/packages/70/15/9b90f7df0e31a003c71649cf66ef61c3c1b862f48c81007fa2383c8bd8d7/kiwisolver-1.5.0-cp314-cp314-win_arm64.whl", hash = "sha256:fa6248cd194edff41d7ea9425ced8ca3a6f838bfb295f6f1d6e6bb694a8518df", size = 66577, upload-time = "2026-03-09T13:15:09.139Z" }, + { url = "https://files.pythonhosted.org/packages/17/01/7dc8c5443ff42b38e72731643ed7cf1ed9bf01691ae5cdca98501999ed83/kiwisolver-1.5.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:d1ffeb80b5676463d7a7d56acbe8e37a20ce725570e09549fe738e02ca6b7e1e", size = 125794, upload-time = "2026-03-09T13:15:10.525Z" }, + { url = "https://files.pythonhosted.org/packages/46/8a/b4ebe46ebaac6a303417fab10c2e165c557ddaff558f9699d302b256bc53/kiwisolver-1.5.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:bc4d8e252f532ab46a1de9349e2d27b91fce46736a9eedaa37beaca66f574ed4", size = 67646, upload-time = "2026-03-09T13:15:12.016Z" }, + { url = "https://files.pythonhosted.org/packages/60/35/10a844afc5f19d6f567359bf4789e26661755a2f36200d5d1ed8ad0126e5/kiwisolver-1.5.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:6783e069732715ad0c3ce96dbf21dbc2235ab0593f2baf6338101f70371f4028", size = 65511, upload-time = "2026-03-09T13:15:13.311Z" }, + { url = "https://files.pythonhosted.org/packages/f8/8a/685b297052dd041dcebce8e8787b58923b6e78acc6115a0dc9189011c44b/kiwisolver-1.5.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e7c4c09a490dc4d4a7f8cbee56c606a320f9dc28cf92a7157a39d1ce7676a657", size = 1584858, upload-time = "2026-03-09T13:15:15.103Z" }, + { url = "https://files.pythonhosted.org/packages/9e/80/04865e3d4638ac5bddec28908916df4a3075b8c6cc101786a96803188b96/kiwisolver-1.5.0-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2a075bd7bd19c70cf67c8badfa36cf7c5d8de3c9ddb8420c51e10d9c50e94920", size = 1392539, upload-time = "2026-03-09T13:15:16.661Z" }, + { url = "https://files.pythonhosted.org/packages/ba/01/77a19cacc0893fa13fafa46d1bba06fb4dc2360b3292baf4b56d8e067b24/kiwisolver-1.5.0-cp314-cp314t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:bdd3e53429ff02aa319ba59dfe4ceeec345bf46cf180ec2cf6fd5b942e7975e9", size = 1405310, upload-time = "2026-03-09T13:15:18.229Z" }, + { url = "https://files.pythonhosted.org/packages/53/39/bcaf5d0cca50e604cfa9b4e3ae1d64b50ca1ae5b754122396084599ef903/kiwisolver-1.5.0-cp314-cp314t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3cdcb35dc9d807259c981a85531048ede628eabcffb3239adf3d17463518992d", size = 1456244, upload-time = "2026-03-09T13:15:20.444Z" }, + { url = "https://files.pythonhosted.org/packages/d0/7a/72c187abc6975f6978c3e39b7cf67aeb8b3c0a8f9790aa7fd412855e9e1f/kiwisolver-1.5.0-cp314-cp314t-manylinux_2_39_riscv64.whl", hash = "sha256:70d593af6a6ca332d1df73d519fddb5148edb15cd90d5f0155e3746a6d4fcc65", size = 1073154, upload-time = "2026-03-09T13:15:22.039Z" }, + { url = "https://files.pythonhosted.org/packages/c7/ca/cf5b25783ebbd59143b4371ed0c8428a278abe68d6d0104b01865b1bbd0f/kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:377815a8616074cabbf3f53354e1d040c35815a134e01d7614b7692e4bf8acfa", size = 2334377, upload-time = "2026-03-09T13:15:23.741Z" }, + { url = "https://files.pythonhosted.org/packages/4a/e5/b1f492adc516796e88751282276745340e2a72dcd0d36cf7173e0daf3210/kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:0255a027391d52944eae1dbb5d4cc5903f57092f3674e8e544cdd2622826b3f0", size = 2425288, upload-time = "2026-03-09T13:15:25.789Z" }, + { url = "https://files.pythonhosted.org/packages/e6/e5/9b21fbe91a61b8f409d74a26498706e97a48008bfcd1864373d32a6ba31c/kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:012b1eb16e28718fa782b5e61dc6f2da1f0792ca73bd05d54de6cb9561665fc9", size = 2063158, upload-time = "2026-03-09T13:15:27.63Z" }, + { url = "https://files.pythonhosted.org/packages/b1/02/83f47986138310f95ea95531f851b2a62227c11cbc3e690ae1374fe49f0f/kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:0e3aafb33aed7479377e5e9a82e9d4bf87063741fc99fc7ae48b0f16e32bdd6f", size = 2597260, upload-time = "2026-03-09T13:15:29.421Z" }, + { url = "https://files.pythonhosted.org/packages/07/18/43a5f24608d8c313dd189cf838c8e68d75b115567c6279de7796197cfb6a/kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:e7a116ae737f0000343218c4edf5bd45893bfeaff0993c0b215d7124c9f77646", size = 2394403, upload-time = "2026-03-09T13:15:31.517Z" }, + { url = "https://files.pythonhosted.org/packages/3b/b5/98222136d839b8afabcaa943b09bd05888c2d36355b7e448550211d1fca4/kiwisolver-1.5.0-cp314-cp314t-win_amd64.whl", hash = "sha256:1dd9b0b119a350976a6d781e7278ec7aca0b201e1a9e2d23d9804afecb6ca681", size = 79687, upload-time = "2026-03-09T13:15:33.204Z" }, + { url = "https://files.pythonhosted.org/packages/99/a2/ca7dc962848040befed12732dff6acae7fb3c4f6fc4272b3f6c9a30b8713/kiwisolver-1.5.0-cp314-cp314t-win_arm64.whl", hash = "sha256:58f812017cd2985c21fbffb4864d59174d4903dd66fa23815e74bbc7a0e2dd57", size = 70032, upload-time = "2026-03-09T13:15:34.411Z" }, + { url = "https://files.pythonhosted.org/packages/1c/fa/2910df836372d8761bb6eff7d8bdcb1613b5c2e03f260efe7abe34d388a7/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-macosx_10_13_x86_64.whl", hash = "sha256:5ae8e62c147495b01a0f4765c878e9bfdf843412446a247e28df59936e99e797", size = 130262, upload-time = "2026-03-09T13:15:35.629Z" }, + { url = "https://files.pythonhosted.org/packages/0f/41/c5f71f9f00aabcc71fee8b7475e3f64747282580c2fe748961ba29b18385/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:f6764a4ccab3078db14a632420930f6186058750df066b8ea2a7106df91d3203", size = 138036, upload-time = "2026-03-09T13:15:36.894Z" }, + { url = "https://files.pythonhosted.org/packages/fa/06/7399a607f434119c6e1fdc8ec89a8d51ccccadf3341dee4ead6bd14caaf5/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c31c13da98624f957b0fb1b5bae5383b2333c2c3f6793d9825dd5ce79b525cb7", size = 194295, upload-time = "2026-03-09T13:15:38.22Z" }, + { url = "https://files.pythonhosted.org/packages/b5/91/53255615acd2a1eaca307ede3c90eb550bae9c94581f8c00081b6b1c8f44/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-win_amd64.whl", hash = "sha256:1f1489f769582498610e015a8ef2d36f28f505ab3096d0e16b4858a9ec214f57", size = 75987, upload-time = "2026-03-09T13:15:39.65Z" }, + { url = "https://files.pythonhosted.org/packages/e9/eb/5fcbbbf9a0e2c3a35effb88831a483345326bbc3a030a3b5b69aee647f84/kiwisolver-1.5.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:ec4c85dc4b687c7f7f15f553ff26a98bfe8c58f5f7f0ac8905f0ba4c7be60232", size = 59532, upload-time = "2026-03-09T13:15:47.047Z" }, + { url = "https://files.pythonhosted.org/packages/c3/9b/e17104555bb4db148fd52327feea1e96be4b88e8e008b029002c281a21ab/kiwisolver-1.5.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:12e91c215a96e39f57989c8912ae761286ac5a9584d04030ceb3368a357f017a", size = 57420, upload-time = "2026-03-09T13:15:48.199Z" }, + { url = "https://files.pythonhosted.org/packages/48/44/2b5b95b7aa39fb2d8d9d956e0f3d5d45aef2ae1d942d4c3ffac2f9cfed1a/kiwisolver-1.5.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:be4a51a55833dc29ab5d7503e7bcb3b3af3402d266018137127450005cdfe737", size = 79892, upload-time = "2026-03-09T13:15:49.694Z" }, + { url = "https://files.pythonhosted.org/packages/52/7d/7157f9bba6b455cfb4632ed411e199fc8b8977642c2b12082e1bd9e6d173/kiwisolver-1.5.0-pp311-pypy311_pp73-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:daae526907e262de627d8f70058a0f64acc9e2641c164c99c8f594b34a799a16", size = 77603, upload-time = "2026-03-09T13:15:50.945Z" }, + { url = "https://files.pythonhosted.org/packages/0a/dd/8050c947d435c8d4bc94e3252f4d8bb8a76cfb424f043a8680be637a57f1/kiwisolver-1.5.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:59cd8683f575d96df5bb48f6add94afc055012c29e28124fcae2b63661b9efb1", size = 73558, upload-time = "2026-03-09T13:15:52.112Z" }, +] + +[[package]] +name = "lazy-loader" +version = "0.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "packaging" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/49/ac/21a1f8aa3777f5658576777ea76bfb124b702c520bbe90edf4ae9915eafa/lazy_loader-0.5.tar.gz", hash = "sha256:717f9179a0dbed357012ddad50a5ad3d5e4d9a0b8712680d4e687f5e6e6ed9b3", size = 15294, upload-time = "2026-03-06T15:45:09.054Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8a/a1/8d812e53a5da1687abb10445275d41a8b13adb781bbf7196ddbcf8d88505/lazy_loader-0.5-py3-none-any.whl", hash = "sha256:ab0ea149e9c554d4ffeeb21105ac60bed7f3b4fd69b1d2360a4add51b170b005", size = 8044, upload-time = "2026-03-06T15:45:07.668Z" }, +] + +[[package]] +name = "librosa" +version = "0.11.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "audioread" }, + { name = "decorator" }, + { name = "joblib" }, + { name = "lazy-loader" }, + { name = "msgpack" }, + { name = "numba" }, + { name = "numpy" }, + { name = "pooch" }, + { name = "scikit-learn" }, + { name = "scipy" }, + { name = "soundfile" }, + { name = "soxr" }, + { name = "standard-aifc", marker = "python_full_version >= '3.13'" }, + { name = "standard-sunau", marker = "python_full_version >= '3.13'" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/64/36/360b5aafa0238e29758729e9486c6ed92a6f37fa403b7875e06c115cdf4a/librosa-0.11.0.tar.gz", hash = "sha256:f5ed951ca189b375bbe2e33b2abd7e040ceeee302b9bbaeeffdfddb8d0ace908", size = 327001, upload-time = "2025-03-11T15:09:54.884Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b5/ba/c63c5786dfee4c3417094c4b00966e61e4a63efecee22cb7b4c0387dda83/librosa-0.11.0-py3-none-any.whl", hash = "sha256:0b6415c4fd68bff4c29288abe67c6d80b587e0e1e2cfb0aad23e4559504a7fa1", size = 260749, upload-time = "2025-03-11T15:09:52.982Z" }, +] + +[[package]] +name = "llvmlite" +version = "0.47.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/01/88/a8952b6d5c21e74cbf158515b779666f692846502623e9e3c39d8e8ba25f/llvmlite-0.47.0.tar.gz", hash = "sha256:62031ce968ec74e95092184d4b0e857e444f8fdff0b8f9213707699570c33ccc", size = 193614, upload-time = "2026-03-31T18:29:53.497Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/34/0b/b9d1911cfefa61399821dfb37f486d83e0f42630a8d12f7194270c417002/llvmlite-0.47.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:74090f0dcfd6f24ebbef3f21f11e38111c4d7e6919b54c4416e1e357c3446b07", size = 37232770, upload-time = "2026-03-31T18:28:26.765Z" }, + { url = "https://files.pythonhosted.org/packages/46/27/5799b020e4cdfb25a7c951c06a96397c135efcdc21b78d853bbd9c814c7d/llvmlite-0.47.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ca14f02e29134e837982497959a8e2193d6035235de1cb41a9cb2bd6da4eedbb", size = 56275177, upload-time = "2026-03-31T18:28:31.01Z" }, + { url = "https://files.pythonhosted.org/packages/7e/51/48a53fedf01cb1f3f43ef200be17ebf83c8d9a04018d3783c1a226c342c2/llvmlite-0.47.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:12a69d4bb05f402f30477e21eeabe81911e7c251cecb192bed82cd83c9db10d8", size = 55128631, upload-time = "2026-03-31T18:28:36.046Z" }, + { url = "https://files.pythonhosted.org/packages/a2/50/59227d06bdc96e23322713c381af4e77420949d8cd8a042c79e0043096cc/llvmlite-0.47.0-cp311-cp311-win_amd64.whl", hash = "sha256:c37d6eb7aaabfa83ab9c2ff5b5cdb95a5e6830403937b2c588b7490724e05327", size = 38138400, upload-time = "2026-03-31T18:28:40.076Z" }, + { url = "https://files.pythonhosted.org/packages/fa/48/4b7fe0e34c169fa2f12532916133e0b219d2823b540733651b34fdac509a/llvmlite-0.47.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:306a265f408c259067257a732c8e159284334018b4083a9e35f67d19792b164f", size = 37232769, upload-time = "2026-03-31T18:28:43.735Z" }, + { url = "https://files.pythonhosted.org/packages/e6/4b/e3f2cd17822cf772a4a51a0a8080b0032e6d37b2dbe8cfb724eac4e31c52/llvmlite-0.47.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5853bf26160857c0c2573415ff4efe01c4c651e59e2c55c2a088740acfee51cd", size = 56275178, upload-time = "2026-03-31T18:28:48.342Z" }, + { url = "https://files.pythonhosted.org/packages/b6/55/a3b4a543185305a9bdf3d9759d53646ed96e55e7dfd43f53e7a421b8fbae/llvmlite-0.47.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:003bcf7fa579e14db59c1a1e113f93ab8a06b56a4be31c7f08264d1d4072d077", size = 55128632, upload-time = "2026-03-31T18:28:52.901Z" }, + { url = "https://files.pythonhosted.org/packages/2f/f5/d281ae0f79378a5a91f308ea9fdb9f9cc068fddd09629edc0725a5a8fde1/llvmlite-0.47.0-cp312-cp312-win_amd64.whl", hash = "sha256:f3079f25bdc24cd9d27c4b2b5e68f5f60c4fdb7e8ad5ee2b9b006007558f9df7", size = 38138692, upload-time = "2026-03-31T18:28:57.147Z" }, + { url = "https://files.pythonhosted.org/packages/77/6f/4615353e016799f80fa52ccb270a843c413b22361fadda2589b2922fb9b0/llvmlite-0.47.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:a3c6a735d4e1041808434f9d440faa3d78d9b4af2ee64d05a66f351883b6ceec", size = 37232771, upload-time = "2026-03-31T18:29:01.324Z" }, + { url = "https://files.pythonhosted.org/packages/31/b8/69f5565f1a280d032525878a86511eebed0645818492feeb169dfb20ae8e/llvmlite-0.47.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2699a74321189e812d476a43d6d7f652f51811e7b5aad9d9bba842a1c7927acb", size = 56275178, upload-time = "2026-03-31T18:29:05.748Z" }, + { url = "https://files.pythonhosted.org/packages/d6/da/b32cafcb926fb0ce2aa25553bf32cb8764af31438f40e2481df08884c947/llvmlite-0.47.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6c6951e2b29930227963e53ee152441f0e14be92e9d4231852102d986c761e40", size = 55128632, upload-time = "2026-03-31T18:29:11.235Z" }, + { url = "https://files.pythonhosted.org/packages/46/9f/4898b44e4042c60fafcb1162dfb7014f6f15b1ec19bf29cfea6bf26df90d/llvmlite-0.47.0-cp313-cp313-win_amd64.whl", hash = "sha256:c2e9adf8698d813a9a5efb2d4370caf344dbc1e145019851fee6a6f319ba760e", size = 38138695, upload-time = "2026-03-31T18:29:15.43Z" }, + { url = "https://files.pythonhosted.org/packages/1c/d4/33c8af00f0bf6f552d74f3a054f648af2c5bc6bece97972f3bfadce4f5ec/llvmlite-0.47.0-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:de966c626c35c9dff5ae7bf12db25637738d0df83fc370cf793bc94d43d92d14", size = 37232773, upload-time = "2026-03-31T18:29:19.453Z" }, + { url = "https://files.pythonhosted.org/packages/64/1d/a760e993e0c0ba6db38d46b9f48f6c7dceb8ac838824997fb9e25f97bc04/llvmlite-0.47.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ddbccff2aeaff8670368340a158abefc032fe9b3ccf7d9c496639263d00151aa", size = 56275176, upload-time = "2026-03-31T18:29:24.149Z" }, + { url = "https://files.pythonhosted.org/packages/84/3b/e679bc3b29127182a7f4aa2d2e9e5bea42adb93fb840484147d59c236299/llvmlite-0.47.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d4a7b778a2e144fc64468fb9bf509ac1226c9813a00b4d7afea5d988c4e22fca", size = 55128631, upload-time = "2026-03-31T18:29:29.536Z" }, + { url = "https://files.pythonhosted.org/packages/be/f7/19e2a09c62809c9e63bbd14ce71fb92c6ff7b7b3045741bb00c781efc3c9/llvmlite-0.47.0-cp314-cp314-win_amd64.whl", hash = "sha256:694e3c2cdc472ed2bd8bd4555ca002eec4310961dd58ef791d508f57b5cc4c94", size = 39153826, upload-time = "2026-03-31T18:29:33.681Z" }, + { url = "https://files.pythonhosted.org/packages/40/a1/581a8c707b5e80efdbbe1dd94527404d33fe50bceb71f39d5a7e11bd57b7/llvmlite-0.47.0-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:92ec8a169a20b473c1c54d4695e371bde36489fc1efa3688e11e99beba0abf9c", size = 37232772, upload-time = "2026-03-31T18:29:37.952Z" }, + { url = "https://files.pythonhosted.org/packages/11/03/16090dd6f74ba2b8b922276047f15962fbeea0a75d5601607edb301ba945/llvmlite-0.47.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fa1cbd800edd3b20bc141521f7fd45a6185a5b84109aa6855134e81397ffe72b", size = 56275178, upload-time = "2026-03-31T18:29:42.58Z" }, + { url = "https://files.pythonhosted.org/packages/f5/cb/0abf1dd4c5286a95ffe0c1d8c67aec06b515894a0dd2ac97f5e27b82ab0b/llvmlite-0.47.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f6725179b89f03b17dabe236ff3422cb8291b4c1bf40af152826dfd34e350ae8", size = 55128632, upload-time = "2026-03-31T18:29:46.939Z" }, + { url = "https://files.pythonhosted.org/packages/4f/79/d3bbab197e86e0ff4f9c07122895b66a3e0d024247fcff7f12c473cb36d9/llvmlite-0.47.0-cp314-cp314t-win_amd64.whl", hash = "sha256:6842cf6f707ec4be3d985a385ad03f72b2d724439e118fcbe99b2929964f0453", size = 39153839, upload-time = "2026-03-31T18:29:51.004Z" }, +] + +[[package]] +name = "markdown" +version = "3.10.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/2b/f4/69fa6ed85ae003c2378ffa8f6d2e3234662abd02c10d216c0ba96081a238/markdown-3.10.2.tar.gz", hash = "sha256:994d51325d25ad8aa7ce4ebaec003febcce822c3f8c911e3b17c52f7f589f950", size = 368805, upload-time = "2026-02-09T14:57:26.942Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/de/1f/77fa3081e4f66ca3576c896ae5d31c3002ac6607f9747d2e3aa49227e464/markdown-3.10.2-py3-none-any.whl", hash = "sha256:e91464b71ae3ee7afd3017d9f358ef0baf158fd9a298db92f1d4761133824c36", size = 108180, upload-time = "2026-02-09T14:57:25.787Z" }, +] + +[[package]] +name = "markupsafe" +version = "3.0.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7e/99/7690b6d4034fffd95959cbe0c02de8deb3098cc577c67bb6a24fe5d7caa7/markupsafe-3.0.3.tar.gz", hash = "sha256:722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698", size = 80313, upload-time = "2025-09-27T18:37:40.426Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/08/db/fefacb2136439fc8dd20e797950e749aa1f4997ed584c62cfb8ef7c2be0e/markupsafe-3.0.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1cc7ea17a6824959616c525620e387f6dd30fec8cb44f649e31712db02123dad", size = 11631, upload-time = "2025-09-27T18:36:18.185Z" }, + { url = "https://files.pythonhosted.org/packages/e1/2e/5898933336b61975ce9dc04decbc0a7f2fee78c30353c5efba7f2d6ff27a/markupsafe-3.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4bd4cd07944443f5a265608cc6aab442e4f74dff8088b0dfc8238647b8f6ae9a", size = 12058, upload-time = "2025-09-27T18:36:19.444Z" }, + { url = "https://files.pythonhosted.org/packages/1d/09/adf2df3699d87d1d8184038df46a9c80d78c0148492323f4693df54e17bb/markupsafe-3.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b5420a1d9450023228968e7e6a9ce57f65d148ab56d2313fcd589eee96a7a50", size = 24287, upload-time = "2025-09-27T18:36:20.768Z" }, + { url = "https://files.pythonhosted.org/packages/30/ac/0273f6fcb5f42e314c6d8cd99effae6a5354604d461b8d392b5ec9530a54/markupsafe-3.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0bf2a864d67e76e5c9a34dc26ec616a66b9888e25e7b9460e1c76d3293bd9dbf", size = 22940, upload-time = "2025-09-27T18:36:22.249Z" }, + { url = "https://files.pythonhosted.org/packages/19/ae/31c1be199ef767124c042c6c3e904da327a2f7f0cd63a0337e1eca2967a8/markupsafe-3.0.3-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc51efed119bc9cfdf792cdeaa4d67e8f6fcccab66ed4bfdd6bde3e59bfcbb2f", size = 21887, upload-time = "2025-09-27T18:36:23.535Z" }, + { url = "https://files.pythonhosted.org/packages/b2/76/7edcab99d5349a4532a459e1fe64f0b0467a3365056ae550d3bcf3f79e1e/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:068f375c472b3e7acbe2d5318dea141359e6900156b5b2ba06a30b169086b91a", size = 23692, upload-time = "2025-09-27T18:36:24.823Z" }, + { url = "https://files.pythonhosted.org/packages/a4/28/6e74cdd26d7514849143d69f0bf2399f929c37dc2b31e6829fd2045b2765/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:7be7b61bb172e1ed687f1754f8e7484f1c8019780f6f6b0786e76bb01c2ae115", size = 21471, upload-time = "2025-09-27T18:36:25.95Z" }, + { url = "https://files.pythonhosted.org/packages/62/7e/a145f36a5c2945673e590850a6f8014318d5577ed7e5920a4b3448e0865d/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f9e130248f4462aaa8e2552d547f36ddadbeaa573879158d721bbd33dfe4743a", size = 22923, upload-time = "2025-09-27T18:36:27.109Z" }, + { url = "https://files.pythonhosted.org/packages/0f/62/d9c46a7f5c9adbeeeda52f5b8d802e1094e9717705a645efc71b0913a0a8/markupsafe-3.0.3-cp311-cp311-win32.whl", hash = "sha256:0db14f5dafddbb6d9208827849fad01f1a2609380add406671a26386cdf15a19", size = 14572, upload-time = "2025-09-27T18:36:28.045Z" }, + { url = "https://files.pythonhosted.org/packages/83/8a/4414c03d3f891739326e1783338e48fb49781cc915b2e0ee052aa490d586/markupsafe-3.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:de8a88e63464af587c950061a5e6a67d3632e36df62b986892331d4620a35c01", size = 15077, upload-time = "2025-09-27T18:36:29.025Z" }, + { url = "https://files.pythonhosted.org/packages/35/73/893072b42e6862f319b5207adc9ae06070f095b358655f077f69a35601f0/markupsafe-3.0.3-cp311-cp311-win_arm64.whl", hash = "sha256:3b562dd9e9ea93f13d53989d23a7e775fdfd1066c33494ff43f5418bc8c58a5c", size = 13876, upload-time = "2025-09-27T18:36:29.954Z" }, + { url = "https://files.pythonhosted.org/packages/5a/72/147da192e38635ada20e0a2e1a51cf8823d2119ce8883f7053879c2199b5/markupsafe-3.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d53197da72cc091b024dd97249dfc7794d6a56530370992a5e1a08983ad9230e", size = 11615, upload-time = "2025-09-27T18:36:30.854Z" }, + { url = "https://files.pythonhosted.org/packages/9a/81/7e4e08678a1f98521201c3079f77db69fb552acd56067661f8c2f534a718/markupsafe-3.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1872df69a4de6aead3491198eaf13810b565bdbeec3ae2dc8780f14458ec73ce", size = 12020, upload-time = "2025-09-27T18:36:31.971Z" }, + { url = "https://files.pythonhosted.org/packages/1e/2c/799f4742efc39633a1b54a92eec4082e4f815314869865d876824c257c1e/markupsafe-3.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3a7e8ae81ae39e62a41ec302f972ba6ae23a5c5396c8e60113e9066ef893da0d", size = 24332, upload-time = "2025-09-27T18:36:32.813Z" }, + { url = "https://files.pythonhosted.org/packages/3c/2e/8d0c2ab90a8c1d9a24f0399058ab8519a3279d1bd4289511d74e909f060e/markupsafe-3.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d", size = 22947, upload-time = "2025-09-27T18:36:33.86Z" }, + { url = "https://files.pythonhosted.org/packages/2c/54/887f3092a85238093a0b2154bd629c89444f395618842e8b0c41783898ea/markupsafe-3.0.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:94c6f0bb423f739146aec64595853541634bde58b2135f27f61c1ffd1cd4d16a", size = 21962, upload-time = "2025-09-27T18:36:35.099Z" }, + { url = "https://files.pythonhosted.org/packages/c9/2f/336b8c7b6f4a4d95e91119dc8521402461b74a485558d8f238a68312f11c/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:be8813b57049a7dc738189df53d69395eba14fb99345e0a5994914a3864c8a4b", size = 23760, upload-time = "2025-09-27T18:36:36.001Z" }, + { url = "https://files.pythonhosted.org/packages/32/43/67935f2b7e4982ffb50a4d169b724d74b62a3964bc1a9a527f5ac4f1ee2b/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:83891d0e9fb81a825d9a6d61e3f07550ca70a076484292a70fde82c4b807286f", size = 21529, upload-time = "2025-09-27T18:36:36.906Z" }, + { url = "https://files.pythonhosted.org/packages/89/e0/4486f11e51bbba8b0c041098859e869e304d1c261e59244baa3d295d47b7/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:77f0643abe7495da77fb436f50f8dab76dbc6e5fd25d39589a0f1fe6548bfa2b", size = 23015, upload-time = "2025-09-27T18:36:37.868Z" }, + { url = "https://files.pythonhosted.org/packages/2f/e1/78ee7a023dac597a5825441ebd17170785a9dab23de95d2c7508ade94e0e/markupsafe-3.0.3-cp312-cp312-win32.whl", hash = "sha256:d88b440e37a16e651bda4c7c2b930eb586fd15ca7406cb39e211fcff3bf3017d", size = 14540, upload-time = "2025-09-27T18:36:38.761Z" }, + { url = "https://files.pythonhosted.org/packages/aa/5b/bec5aa9bbbb2c946ca2733ef9c4ca91c91b6a24580193e891b5f7dbe8e1e/markupsafe-3.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:26a5784ded40c9e318cfc2bdb30fe164bdb8665ded9cd64d500a34fb42067b1c", size = 15105, upload-time = "2025-09-27T18:36:39.701Z" }, + { url = "https://files.pythonhosted.org/packages/e5/f1/216fc1bbfd74011693a4fd837e7026152e89c4bcf3e77b6692fba9923123/markupsafe-3.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:35add3b638a5d900e807944a078b51922212fb3dedb01633a8defc4b01a3c85f", size = 13906, upload-time = "2025-09-27T18:36:40.689Z" }, + { url = "https://files.pythonhosted.org/packages/38/2f/907b9c7bbba283e68f20259574b13d005c121a0fa4c175f9bed27c4597ff/markupsafe-3.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e1cf1972137e83c5d4c136c43ced9ac51d0e124706ee1c8aa8532c1287fa8795", size = 11622, upload-time = "2025-09-27T18:36:41.777Z" }, + { url = "https://files.pythonhosted.org/packages/9c/d9/5f7756922cdd676869eca1c4e3c0cd0df60ed30199ffd775e319089cb3ed/markupsafe-3.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:116bb52f642a37c115f517494ea5feb03889e04df47eeff5b130b1808ce7c219", size = 12029, upload-time = "2025-09-27T18:36:43.257Z" }, + { url = "https://files.pythonhosted.org/packages/00/07/575a68c754943058c78f30db02ee03a64b3c638586fba6a6dd56830b30a3/markupsafe-3.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:133a43e73a802c5562be9bbcd03d090aa5a1fe899db609c29e8c8d815c5f6de6", size = 24374, upload-time = "2025-09-27T18:36:44.508Z" }, + { url = "https://files.pythonhosted.org/packages/a9/21/9b05698b46f218fc0e118e1f8168395c65c8a2c750ae2bab54fc4bd4e0e8/markupsafe-3.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ccfcd093f13f0f0b7fdd0f198b90053bf7b2f02a3927a30e63f3ccc9df56b676", size = 22980, upload-time = "2025-09-27T18:36:45.385Z" }, + { url = "https://files.pythonhosted.org/packages/7f/71/544260864f893f18b6827315b988c146b559391e6e7e8f7252839b1b846a/markupsafe-3.0.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:509fa21c6deb7a7a273d629cf5ec029bc209d1a51178615ddf718f5918992ab9", size = 21990, upload-time = "2025-09-27T18:36:46.916Z" }, + { url = "https://files.pythonhosted.org/packages/c2/28/b50fc2f74d1ad761af2f5dcce7492648b983d00a65b8c0e0cb457c82ebbe/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a4afe79fb3de0b7097d81da19090f4df4f8d3a2b3adaa8764138aac2e44f3af1", size = 23784, upload-time = "2025-09-27T18:36:47.884Z" }, + { url = "https://files.pythonhosted.org/packages/ed/76/104b2aa106a208da8b17a2fb72e033a5a9d7073c68f7e508b94916ed47a9/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:795e7751525cae078558e679d646ae45574b47ed6e7771863fcc079a6171a0fc", size = 21588, upload-time = "2025-09-27T18:36:48.82Z" }, + { url = "https://files.pythonhosted.org/packages/b5/99/16a5eb2d140087ebd97180d95249b00a03aa87e29cc224056274f2e45fd6/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8485f406a96febb5140bfeca44a73e3ce5116b2501ac54fe953e488fb1d03b12", size = 23041, upload-time = "2025-09-27T18:36:49.797Z" }, + { url = "https://files.pythonhosted.org/packages/19/bc/e7140ed90c5d61d77cea142eed9f9c303f4c4806f60a1044c13e3f1471d0/markupsafe-3.0.3-cp313-cp313-win32.whl", hash = "sha256:bdd37121970bfd8be76c5fb069c7751683bdf373db1ed6c010162b2a130248ed", size = 14543, upload-time = "2025-09-27T18:36:51.584Z" }, + { url = "https://files.pythonhosted.org/packages/05/73/c4abe620b841b6b791f2edc248f556900667a5a1cf023a6646967ae98335/markupsafe-3.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:9a1abfdc021a164803f4d485104931fb8f8c1efd55bc6b748d2f5774e78b62c5", size = 15113, upload-time = "2025-09-27T18:36:52.537Z" }, + { url = "https://files.pythonhosted.org/packages/f0/3a/fa34a0f7cfef23cf9500d68cb7c32dd64ffd58a12b09225fb03dd37d5b80/markupsafe-3.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:7e68f88e5b8799aa49c85cd116c932a1ac15caaa3f5db09087854d218359e485", size = 13911, upload-time = "2025-09-27T18:36:53.513Z" }, + { url = "https://files.pythonhosted.org/packages/e4/d7/e05cd7efe43a88a17a37b3ae96e79a19e846f3f456fe79c57ca61356ef01/markupsafe-3.0.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:218551f6df4868a8d527e3062d0fb968682fe92054e89978594c28e642c43a73", size = 11658, upload-time = "2025-09-27T18:36:54.819Z" }, + { url = "https://files.pythonhosted.org/packages/99/9e/e412117548182ce2148bdeacdda3bb494260c0b0184360fe0d56389b523b/markupsafe-3.0.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3524b778fe5cfb3452a09d31e7b5adefeea8c5be1d43c4f810ba09f2ceb29d37", size = 12066, upload-time = "2025-09-27T18:36:55.714Z" }, + { url = "https://files.pythonhosted.org/packages/bc/e6/fa0ffcda717ef64a5108eaa7b4f5ed28d56122c9a6d70ab8b72f9f715c80/markupsafe-3.0.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4e885a3d1efa2eadc93c894a21770e4bc67899e3543680313b09f139e149ab19", size = 25639, upload-time = "2025-09-27T18:36:56.908Z" }, + { url = "https://files.pythonhosted.org/packages/96/ec/2102e881fe9d25fc16cb4b25d5f5cde50970967ffa5dddafdb771237062d/markupsafe-3.0.3-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8709b08f4a89aa7586de0aadc8da56180242ee0ada3999749b183aa23df95025", size = 23569, upload-time = "2025-09-27T18:36:57.913Z" }, + { url = "https://files.pythonhosted.org/packages/4b/30/6f2fce1f1f205fc9323255b216ca8a235b15860c34b6798f810f05828e32/markupsafe-3.0.3-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b8512a91625c9b3da6f127803b166b629725e68af71f8184ae7e7d54686a56d6", size = 23284, upload-time = "2025-09-27T18:36:58.833Z" }, + { url = "https://files.pythonhosted.org/packages/58/47/4a0ccea4ab9f5dcb6f79c0236d954acb382202721e704223a8aafa38b5c8/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9b79b7a16f7fedff2495d684f2b59b0457c3b493778c9eed31111be64d58279f", size = 24801, upload-time = "2025-09-27T18:36:59.739Z" }, + { url = "https://files.pythonhosted.org/packages/6a/70/3780e9b72180b6fecb83a4814d84c3bf4b4ae4bf0b19c27196104149734c/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:12c63dfb4a98206f045aa9563db46507995f7ef6d83b2f68eda65c307c6829eb", size = 22769, upload-time = "2025-09-27T18:37:00.719Z" }, + { url = "https://files.pythonhosted.org/packages/98/c5/c03c7f4125180fc215220c035beac6b9cb684bc7a067c84fc69414d315f5/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8f71bc33915be5186016f675cd83a1e08523649b0e33efdb898db577ef5bb009", size = 23642, upload-time = "2025-09-27T18:37:01.673Z" }, + { url = "https://files.pythonhosted.org/packages/80/d6/2d1b89f6ca4bff1036499b1e29a1d02d282259f3681540e16563f27ebc23/markupsafe-3.0.3-cp313-cp313t-win32.whl", hash = "sha256:69c0b73548bc525c8cb9a251cddf1931d1db4d2258e9599c28c07ef3580ef354", size = 14612, upload-time = "2025-09-27T18:37:02.639Z" }, + { url = "https://files.pythonhosted.org/packages/2b/98/e48a4bfba0a0ffcf9925fe2d69240bfaa19c6f7507b8cd09c70684a53c1e/markupsafe-3.0.3-cp313-cp313t-win_amd64.whl", hash = "sha256:1b4b79e8ebf6b55351f0d91fe80f893b4743f104bff22e90697db1590e47a218", size = 15200, upload-time = "2025-09-27T18:37:03.582Z" }, + { url = "https://files.pythonhosted.org/packages/0e/72/e3cc540f351f316e9ed0f092757459afbc595824ca724cbc5a5d4263713f/markupsafe-3.0.3-cp313-cp313t-win_arm64.whl", hash = "sha256:ad2cf8aa28b8c020ab2fc8287b0f823d0a7d8630784c31e9ee5edea20f406287", size = 13973, upload-time = "2025-09-27T18:37:04.929Z" }, + { url = "https://files.pythonhosted.org/packages/33/8a/8e42d4838cd89b7dde187011e97fe6c3af66d8c044997d2183fbd6d31352/markupsafe-3.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:eaa9599de571d72e2daf60164784109f19978b327a3910d3e9de8c97b5b70cfe", size = 11619, upload-time = "2025-09-27T18:37:06.342Z" }, + { url = "https://files.pythonhosted.org/packages/b5/64/7660f8a4a8e53c924d0fa05dc3a55c9cee10bbd82b11c5afb27d44b096ce/markupsafe-3.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c47a551199eb8eb2121d4f0f15ae0f923d31350ab9280078d1e5f12b249e0026", size = 12029, upload-time = "2025-09-27T18:37:07.213Z" }, + { url = "https://files.pythonhosted.org/packages/da/ef/e648bfd021127bef5fa12e1720ffed0c6cbb8310c8d9bea7266337ff06de/markupsafe-3.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f34c41761022dd093b4b6896d4810782ffbabe30f2d443ff5f083e0cbbb8c737", size = 24408, upload-time = "2025-09-27T18:37:09.572Z" }, + { url = "https://files.pythonhosted.org/packages/41/3c/a36c2450754618e62008bf7435ccb0f88053e07592e6028a34776213d877/markupsafe-3.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:457a69a9577064c05a97c41f4e65148652db078a3a509039e64d3467b9e7ef97", size = 23005, upload-time = "2025-09-27T18:37:10.58Z" }, + { url = "https://files.pythonhosted.org/packages/bc/20/b7fdf89a8456b099837cd1dc21974632a02a999ec9bf7ca3e490aacd98e7/markupsafe-3.0.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e8afc3f2ccfa24215f8cb28dcf43f0113ac3c37c2f0f0806d8c70e4228c5cf4d", size = 22048, upload-time = "2025-09-27T18:37:11.547Z" }, + { url = "https://files.pythonhosted.org/packages/9a/a7/591f592afdc734f47db08a75793a55d7fbcc6902a723ae4cfbab61010cc5/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ec15a59cf5af7be74194f7ab02d0f59a62bdcf1a537677ce67a2537c9b87fcda", size = 23821, upload-time = "2025-09-27T18:37:12.48Z" }, + { url = "https://files.pythonhosted.org/packages/7d/33/45b24e4f44195b26521bc6f1a82197118f74df348556594bd2262bda1038/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:0eb9ff8191e8498cca014656ae6b8d61f39da5f95b488805da4bb029cccbfbaf", size = 21606, upload-time = "2025-09-27T18:37:13.485Z" }, + { url = "https://files.pythonhosted.org/packages/ff/0e/53dfaca23a69fbfbbf17a4b64072090e70717344c52eaaaa9c5ddff1e5f0/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2713baf880df847f2bece4230d4d094280f4e67b1e813eec43b4c0e144a34ffe", size = 23043, upload-time = "2025-09-27T18:37:14.408Z" }, + { url = "https://files.pythonhosted.org/packages/46/11/f333a06fc16236d5238bfe74daccbca41459dcd8d1fa952e8fbd5dccfb70/markupsafe-3.0.3-cp314-cp314-win32.whl", hash = "sha256:729586769a26dbceff69f7a7dbbf59ab6572b99d94576a5592625d5b411576b9", size = 14747, upload-time = "2025-09-27T18:37:15.36Z" }, + { url = "https://files.pythonhosted.org/packages/28/52/182836104b33b444e400b14f797212f720cbc9ed6ba34c800639d154e821/markupsafe-3.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:bdc919ead48f234740ad807933cdf545180bfbe9342c2bb451556db2ed958581", size = 15341, upload-time = "2025-09-27T18:37:16.496Z" }, + { url = "https://files.pythonhosted.org/packages/6f/18/acf23e91bd94fd7b3031558b1f013adfa21a8e407a3fdb32745538730382/markupsafe-3.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:5a7d5dc5140555cf21a6fefbdbf8723f06fcd2f63ef108f2854de715e4422cb4", size = 14073, upload-time = "2025-09-27T18:37:17.476Z" }, + { url = "https://files.pythonhosted.org/packages/3c/f0/57689aa4076e1b43b15fdfa646b04653969d50cf30c32a102762be2485da/markupsafe-3.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:1353ef0c1b138e1907ae78e2f6c63ff67501122006b0f9abad68fda5f4ffc6ab", size = 11661, upload-time = "2025-09-27T18:37:18.453Z" }, + { url = "https://files.pythonhosted.org/packages/89/c3/2e67a7ca217c6912985ec766c6393b636fb0c2344443ff9d91404dc4c79f/markupsafe-3.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1085e7fbddd3be5f89cc898938f42c0b3c711fdcb37d75221de2666af647c175", size = 12069, upload-time = "2025-09-27T18:37:19.332Z" }, + { url = "https://files.pythonhosted.org/packages/f0/00/be561dce4e6ca66b15276e184ce4b8aec61fe83662cce2f7d72bd3249d28/markupsafe-3.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b52b4fb9df4eb9ae465f8d0c228a00624de2334f216f178a995ccdcf82c4634", size = 25670, upload-time = "2025-09-27T18:37:20.245Z" }, + { url = "https://files.pythonhosted.org/packages/50/09/c419f6f5a92e5fadde27efd190eca90f05e1261b10dbd8cbcb39cd8ea1dc/markupsafe-3.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fed51ac40f757d41b7c48425901843666a6677e3e8eb0abcff09e4ba6e664f50", size = 23598, upload-time = "2025-09-27T18:37:21.177Z" }, + { url = "https://files.pythonhosted.org/packages/22/44/a0681611106e0b2921b3033fc19bc53323e0b50bc70cffdd19f7d679bb66/markupsafe-3.0.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f190daf01f13c72eac4efd5c430a8de82489d9cff23c364c3ea822545032993e", size = 23261, upload-time = "2025-09-27T18:37:22.167Z" }, + { url = "https://files.pythonhosted.org/packages/5f/57/1b0b3f100259dc9fffe780cfb60d4be71375510e435efec3d116b6436d43/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e56b7d45a839a697b5eb268c82a71bd8c7f6c94d6fd50c3d577fa39a9f1409f5", size = 24835, upload-time = "2025-09-27T18:37:23.296Z" }, + { url = "https://files.pythonhosted.org/packages/26/6a/4bf6d0c97c4920f1597cc14dd720705eca0bf7c787aebc6bb4d1bead5388/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:f3e98bb3798ead92273dc0e5fd0f31ade220f59a266ffd8a4f6065e0a3ce0523", size = 22733, upload-time = "2025-09-27T18:37:24.237Z" }, + { url = "https://files.pythonhosted.org/packages/14/c7/ca723101509b518797fedc2fdf79ba57f886b4aca8a7d31857ba3ee8281f/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5678211cb9333a6468fb8d8be0305520aa073f50d17f089b5b4b477ea6e67fdc", size = 23672, upload-time = "2025-09-27T18:37:25.271Z" }, + { url = "https://files.pythonhosted.org/packages/fb/df/5bd7a48c256faecd1d36edc13133e51397e41b73bb77e1a69deab746ebac/markupsafe-3.0.3-cp314-cp314t-win32.whl", hash = "sha256:915c04ba3851909ce68ccc2b8e2cd691618c4dc4c4232fb7982bca3f41fd8c3d", size = 14819, upload-time = "2025-09-27T18:37:26.285Z" }, + { url = "https://files.pythonhosted.org/packages/1a/8a/0402ba61a2f16038b48b39bccca271134be00c5c9f0f623208399333c448/markupsafe-3.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4faffd047e07c38848ce017e8725090413cd80cbc23d86e55c587bf979e579c9", size = 15426, upload-time = "2025-09-27T18:37:27.316Z" }, + { url = "https://files.pythonhosted.org/packages/70/bc/6f1c2f612465f5fa89b95bead1f44dcb607670fd42891d8fdcd5d039f4f4/markupsafe-3.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:32001d6a8fc98c8cb5c947787c5d08b0a50663d139f1305bac5885d98d9b40fa", size = 14146, upload-time = "2025-09-27T18:37:28.327Z" }, +] + +[[package]] +name = "matplotlib" +version = "3.10.9" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "contourpy" }, + { name = "cycler" }, + { name = "fonttools" }, + { name = "kiwisolver" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "pillow" }, + { name = "pyparsing" }, + { name = "python-dateutil" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/63/1b/4be5be87d43d327a0cf4de1a56e86f7f84c89312452406cf122efe2839e6/matplotlib-3.10.9.tar.gz", hash = "sha256:fd66508e8c6877d98e586654b608a0456db8d7e8a546eb1e2600efd957302358", size = 34811233, upload-time = "2026-04-24T00:14:13.539Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4c/8c/290f021104741fea63769c31494f5324c0cd249bf536a65a4350767b1f22/matplotlib-3.10.9-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:68cfdcede415f7c8f5577b03303dd94526cdb6d11036cecdc205e08733b2d2bb", size = 8306860, upload-time = "2026-04-24T00:12:01.207Z" }, + { url = "https://files.pythonhosted.org/packages/51/18/325cd32ece1120d1da51cc4e4294c6580190699490183fc2fe8cb6d61ec5/matplotlib-3.10.9-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dfca0129678bd56379db26c52b5d77ed7de314c047492fbdc763aa7501710cfb", size = 8199254, upload-time = "2026-04-24T00:12:04.239Z" }, + { url = "https://files.pythonhosted.org/packages/79/db/e28c1b83e3680740aa78925f5fb2ae4d16207207419ad75ea9fe604f8676/matplotlib-3.10.9-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8e436d155fa8a3399dc62683f8f5d0e2e50d25d0144a73edd73f82eec8f4abfb", size = 8777092, upload-time = "2026-04-24T00:12:06.793Z" }, + { url = "https://files.pythonhosted.org/packages/55/fa/3ce7adfe9ba101748f465211660d9c6374c876b671bdb8c2bb6d347e8b94/matplotlib-3.10.9-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:56fc0bd271b00025c6edfdc7c2dcd247372c8e1544971d62e1dc7c17367e8bf9", size = 9595691, upload-time = "2026-04-24T00:12:09.706Z" }, + { url = "https://files.pythonhosted.org/packages/36/c4/6960a76686ed668f2c60f84e9799ba4c0d56abdb36b1577b60c1d061d1ec/matplotlib-3.10.9-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:a5a6104ed666402ba5106d7f36e0e0cdca4e8d7fa4d39708ca88019e2835a2eb", size = 9659771, upload-time = "2026-04-24T00:12:12.766Z" }, + { url = "https://files.pythonhosted.org/packages/7e/0d/271aace3342157c64700c9ff4c59c7b392f3dbab393692e8db6fbe7ab96c/matplotlib-3.10.9-cp311-cp311-win_amd64.whl", hash = "sha256:d730e984eddf56974c3e72b6129c7ca462ac38dc624338f4b0b23eb23ecba00f", size = 8205112, upload-time = "2026-04-24T00:12:15.773Z" }, + { url = "https://files.pythonhosted.org/packages/e2/ee/cb57ad4754f3e7b9174ce6ce66d9205fb827067e48a9f58ac09d7e7d6b77/matplotlib-3.10.9-cp311-cp311-win_arm64.whl", hash = "sha256:51bf0ddbdc598e060d46c16b5590708f81a1624cefbaaf62f6a81bf9285b8c80", size = 8132310, upload-time = "2026-04-24T00:12:18.645Z" }, + { url = "https://files.pythonhosted.org/packages/35/c6/5581e26c72233ebb2a2a6fed2d24fb7c66b4700120b813f51b0555acf0b6/matplotlib-3.10.9-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f0c3c28d9fbcc1fe7a03be236d73430cf6409c41fb2383a7ac52fe932b072cb1", size = 8319908, upload-time = "2026-04-24T00:12:21.323Z" }, + { url = "https://files.pythonhosted.org/packages/b7/18/4880dd762e40cd360c1bf06e890c5a97b997e91cb324602b1a19950ad5ce/matplotlib-3.10.9-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:41cb28c2bd769aa3e98322c6ab09854cbcc52ab69d2759d681bba3e327b2b320", size = 8216016, upload-time = "2026-04-24T00:12:23.4Z" }, + { url = "https://files.pythonhosted.org/packages/32/91/d024616abdba99e83120e07a20658976f6a343646710760c4a51df126029/matplotlib-3.10.9-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ae20801130378b82d647ff5047c07316295b68dc054ca6b3c13519d0ea624285", size = 8789336, upload-time = "2026-04-24T00:12:26.096Z" }, + { url = "https://files.pythonhosted.org/packages/5c/04/030a2f61ef2158f5e4c259487a92ac877732499fb33d871585d89e03c42d/matplotlib-3.10.9-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6c63ebcd8b4b169eb2f5c200552ae6b8be8999a005b6b507ed76fb8d7d674fe2", size = 9604602, upload-time = "2026-04-24T00:12:29.052Z" }, + { url = "https://files.pythonhosted.org/packages/fc/c2/541e4d09d87bb6b5830fc28b4c887a9a8cf4e1c6cee698a8c05552ae2003/matplotlib-3.10.9-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:d75d11c949914165976c621b2324f9ef162af7ebf4b057ddf95dd1dba7e5edcf", size = 9670966, upload-time = "2026-04-24T00:12:32.131Z" }, + { url = "https://files.pythonhosted.org/packages/04/a1/4571fc46e7702de8d0c2dc54ad1b2f8e29328dea3ee90831181f7353d93c/matplotlib-3.10.9-cp312-cp312-win_amd64.whl", hash = "sha256:d091f9d758b34aaaaa6331d13574bf01891d903b3dec59bfff458ef7551de5d6", size = 8217462, upload-time = "2026-04-24T00:12:35.226Z" }, + { url = "https://files.pythonhosted.org/packages/4b/d0/2269edb12aa30c13c8bcc9382892e39943ce1d28aab4ec296e0381798e81/matplotlib-3.10.9-cp312-cp312-win_arm64.whl", hash = "sha256:10cc5ce06d10231c36f40e875f3c7e8050362a4ee8f0ee5d29a6b3277d57bb42", size = 8136688, upload-time = "2026-04-24T00:12:37.442Z" }, + { url = "https://files.pythonhosted.org/packages/aa/d3/8d4f6afbecb49fc04e060a57c0fce39ea51cc163a6bd87303ccd698e4fa6/matplotlib-3.10.9-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:b580440f1ff81a0e34122051a3dfabb7e4b7f9e380629929bde0eff9af72165f", size = 8320331, upload-time = "2026-04-24T00:12:39.688Z" }, + { url = "https://files.pythonhosted.org/packages/63/d9/9e14bc7564bf92d5ffa801ae5fac819ce74b925dfb55e3ebde61a3bbad3e/matplotlib-3.10.9-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:b1b745c489cd1a77a0dc1120a05dc87af9798faebc913601feb8c73d89bf2d1e", size = 8216461, upload-time = "2026-04-24T00:12:42.494Z" }, + { url = "https://files.pythonhosted.org/packages/8a/17/4402d0d14ccf1dfc70932600b68097fbbf9c898a4871d2cbbe79c7801a32/matplotlib-3.10.9-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8f3bcac1ca5ed000a6f4337d47ba67dfddf37ed6a46c15fd7f014997f7bf865f", size = 8790091, upload-time = "2026-04-24T00:12:44.789Z" }, + { url = "https://files.pythonhosted.org/packages/3e/0b/322aeec06dd9b91411f92028b37d447342770a24392aa4813e317064dad5/matplotlib-3.10.9-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7a8d66a55def891c33147ba3ba9bfcabf0b526a43764c818acbb4525e5ed0838", size = 9605027, upload-time = "2026-04-24T00:12:47.583Z" }, + { url = "https://files.pythonhosted.org/packages/74/88/5f13482f55e7b00bcfc09838b093c2456e1379978d2a146844aae05350ad/matplotlib-3.10.9-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:d843374407c4017a6403b59c6c81606773d136f3259d5b6da3131bc814542cc2", size = 9671269, upload-time = "2026-04-24T00:12:50.878Z" }, + { url = "https://files.pythonhosted.org/packages/c5/e0/0840fd2f93da988ec660b8ad1984abe9f25d2aed22a5e394ff1c68c88307/matplotlib-3.10.9-cp313-cp313-win_amd64.whl", hash = "sha256:f4399f64b3e94cd500195490972ae1ee81170df1636fa15364d157d5bdd7b921", size = 8217588, upload-time = "2026-04-24T00:12:53.784Z" }, + { url = "https://files.pythonhosted.org/packages/47/b9/d706d06dd605c49b9f83a2aed8c13e3e5db70697d7a80b7e3d7915de6b17/matplotlib-3.10.9-cp313-cp313-win_arm64.whl", hash = "sha256:ba7b3b8ef09eab7df0e86e9ae086faa433efbfbdb46afcb3aa16aabf779469a8", size = 8136913, upload-time = "2026-04-24T00:12:56.501Z" }, + { url = "https://files.pythonhosted.org/packages/9b/45/6e32d96978264c8ca8c4b1010adb955a1a49cfaf314e212bbc8908f04a61/matplotlib-3.10.9-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:09218df8a93712bd6ea133e83a153c755448cf7868316c531cffcc43f69d1cc9", size = 8368019, upload-time = "2026-04-24T00:12:58.896Z" }, + { url = "https://files.pythonhosted.org/packages/86/0a/c8e3d3bba245f0f7fc424937f8ff7ef77291a36af3edb97ccd78aa93d84f/matplotlib-3.10.9-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:82368699727bfb7b0182e1aa13082e3c08e092fa1a25d3e1fd92405bff96f6d4", size = 8264645, upload-time = "2026-04-24T00:13:01.406Z" }, + { url = "https://files.pythonhosted.org/packages/3d/aa/5bf5a14fe4fed73a4209a155606f8096ff797aad89c6c35179026571133e/matplotlib-3.10.9-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3225f4e1edcb8c86c884ddf79ebe20ecd0a67d30188f279897554ccd8fded4dc", size = 8802194, upload-time = "2026-04-24T00:13:03.702Z" }, + { url = "https://files.pythonhosted.org/packages/dd/5e/b4be852d6bba6fd15893fadf91ff26ae49cb91aac789e95dde9d342e664f/matplotlib-3.10.9-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:de2445a0c6690d21b7eb6ce071cebad6d40a2e9bdf10d039074a96ba19797b99", size = 9622684, upload-time = "2026-04-24T00:13:06.647Z" }, + { url = "https://files.pythonhosted.org/packages/4c/3d/ed428c971139112ef730f62770654d609467346d09d4b62617e1afd68a5a/matplotlib-3.10.9-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:b2b9516251cb89ff618d757daec0e2ed1bf21248013844a853d87ef85ab3081d", size = 9680790, upload-time = "2026-04-24T00:13:10.009Z" }, + { url = "https://files.pythonhosted.org/packages/e7/09/052e884aaf2b985c63cb79f715f1d5b6a3eaa7de78f6a52b9dbc077d5b53/matplotlib-3.10.9-cp313-cp313t-win_amd64.whl", hash = "sha256:e9fae004b941b23ff2edcf1567a857ed77bafc8086ffa258190462328434faf8", size = 8287571, upload-time = "2026-04-24T00:13:13.087Z" }, + { url = "https://files.pythonhosted.org/packages/f4/38/ae27288e788c35a4250491422f3db7750366fc8c97d6f36fbdecfc1f5518/matplotlib-3.10.9-cp313-cp313t-win_arm64.whl", hash = "sha256:6b63d9c7c769b88ab81e10dc86e4e0607cf56817b9f9e6cf24b2a5f1693b8e38", size = 8188292, upload-time = "2026-04-24T00:13:15.546Z" }, + { url = "https://files.pythonhosted.org/packages/d6/e6/3bd8afd04949f02eabc1c17115ea5255e19cacd4d06fc5abdde4eeb0052c/matplotlib-3.10.9-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:172db52c9e683f5d12eaf57f0f54834190e12581fe1cc2a19595a8f5acb4e77d", size = 8321276, upload-time = "2026-04-24T00:13:18.318Z" }, + { url = "https://files.pythonhosted.org/packages/41/86/86231232fff41c9f8e4a1a7d7a597d349a02527109c3af7d618366122139/matplotlib-3.10.9-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:97e35e8d39ccc85859095e01a53847432ba9a53ddf7986f7a54a11b73d0e143f", size = 8218218, upload-time = "2026-04-24T00:13:20.974Z" }, + { url = "https://files.pythonhosted.org/packages/85/8f/becc9722cafc64f5d2eb0b7c1bf5f585271c618a45dbd8fabeb021f898b6/matplotlib-3.10.9-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:aba1615dabe83188e19d4f75a253c6a08423e04c1425e64039f800050a69de6b", size = 9608145, upload-time = "2026-04-24T00:13:23.228Z" }, + { url = "https://files.pythonhosted.org/packages/32/5d/f7e914f7d9325abff4057cee62c0fa70263683189f774473cbfb534cd13b/matplotlib-3.10.9-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:34cf8167e023ad956c15f36302911d5406bd99a9862c1a8499ea6f7c0e015dc2", size = 9885085, upload-time = "2026-04-24T00:13:25.849Z" }, + { url = "https://files.pythonhosted.org/packages/a5/fd/fa69f2221534e80cc5772ac2b7d222011a2acafc2ec7216d5dd174c864ae/matplotlib-3.10.9-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:59476c6d29d612b8e9bb6ce8c5b631be6ba8f9e3a2421f22a02b192c7dd28716", size = 9672358, upload-time = "2026-04-24T00:13:28.906Z" }, + { url = "https://files.pythonhosted.org/packages/ab/1a/5a4f747a8b271cbb024946d2dd3c913ab5032ba430626f8c3528ada96b4b/matplotlib-3.10.9-cp314-cp314-win_amd64.whl", hash = "sha256:336b9acc64d309063126edcdaca00db9373af3c476bb94388fe9c5a53ad13e6f", size = 8349970, upload-time = "2026-04-24T00:13:31.904Z" }, + { url = "https://files.pythonhosted.org/packages/64/dc/95d60ecaefe30680a154b52ea96ab4b0dab547f1fd6aa12f5fb655e89cae/matplotlib-3.10.9-cp314-cp314-win_arm64.whl", hash = "sha256:2dc9477819ffd78ad12a20df1d9d6a6bd4fec6aaa9072681465fddca052f1456", size = 8272785, upload-time = "2026-04-24T00:13:34.511Z" }, + { url = "https://files.pythonhosted.org/packages/70/a0/005d68bc8b8418300ce6591f18586910a8526806e2ab663933d9f20a41e9/matplotlib-3.10.9-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:da4e09638420548f31c354032a6250e473c68e5a4e96899b4844cf39ddea23fe", size = 8367999, upload-time = "2026-04-24T00:13:36.962Z" }, + { url = "https://files.pythonhosted.org/packages/22/05/1236cc9290be70b2498af20ca348add76e3fffe7f67b477db5133a84f3ea/matplotlib-3.10.9-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:345f6f68ecc8da0ca56fad2ea08fde1a115eda530079eca185d50a7bc3e146c6", size = 8264543, upload-time = "2026-04-24T00:13:39.851Z" }, + { url = "https://files.pythonhosted.org/packages/cd/c2/071f5a5ff6c5bd63aaaf2f45c811d9bf2ced94bde188d9e1a519e21d0cba/matplotlib-3.10.9-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4edcfbd8565339aa62f1cd4012f7180926fdbe71850f7b0d3c379c175cd6b66c", size = 9622800, upload-time = "2026-04-24T00:13:42.296Z" }, + { url = "https://files.pythonhosted.org/packages/95/57/da7d1f10a85624b9e7db68e069dd94e58dc41dbf9463c5921632ecbe3661/matplotlib-3.10.9-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6be157fe17fc37cb95ac1d7374cf717ce9259616edec911a78d9d26dae8522d4", size = 9888561, upload-time = "2026-04-24T00:13:45.026Z" }, + { url = "https://files.pythonhosted.org/packages/67/b2/ef8d6bb59b0edb6c16c968b70f548aa13b54348972def5aa6ac85df67145/matplotlib-3.10.9-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:4e42042d54db34fda4e95a7bd3e5789c2a995d2dad3eb8850232ee534092fbbf", size = 9680884, upload-time = "2026-04-24T00:13:48.066Z" }, + { url = "https://files.pythonhosted.org/packages/61/1c/d21bfeb9931881ebe96bcfcff27c7ae4b160ae0ec291a714c42641a56d75/matplotlib-3.10.9-cp314-cp314t-win_amd64.whl", hash = "sha256:c27df8b3848f32a83d1767566595e43cfaa4460380974da06f4279a7ec143c39", size = 8432333, upload-time = "2026-04-24T00:13:51.008Z" }, + { url = "https://files.pythonhosted.org/packages/78/23/92493c3e6e1b635ccfff146f7b99e674808787915420373ac399283764c2/matplotlib-3.10.9-cp314-cp314t-win_arm64.whl", hash = "sha256:a49f1eadc84ca85fd72fa4e89e70e61bf86452df6f971af04b12c60761a0772c", size = 8324785, upload-time = "2026-04-24T00:13:53.633Z" }, + { url = "https://files.pythonhosted.org/packages/63/e2/9f66ca6a651a52abfe0d4964ce01439ed34f3f1e119de10ff3a07f403043/matplotlib-3.10.9-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:42fb814efabe95c06c1994d8ab5a8385f43a249e23badd3ba931d4308e5bca20", size = 8304420, upload-time = "2026-04-24T00:14:04.57Z" }, + { url = "https://files.pythonhosted.org/packages/e8/e8/467c03568218792906aa87b5e7bb379b605e056ed0c74fe00c051786d925/matplotlib-3.10.9-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:f76e640a5268850bfda54b5131b1b1941cc685e42c5fa98ed9f2d64038308cba", size = 8197981, upload-time = "2026-04-24T00:14:07.233Z" }, + { url = "https://files.pythonhosted.org/packages/6f/87/afead29192170917537934c6aff4b008c805fff7b1ccea0c79120d96beda/matplotlib-3.10.9-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3fc0364dfbe1d07f6d15c5ebd0c5bf89e126916e5a8667dd4a7a6e84c36653d4", size = 8774002, upload-time = "2026-04-24T00:14:09.816Z" }, +] + +[[package]] +name = "matplotlib-inline" +version = "0.2.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c7/74/97e72a36efd4ae2bccb3463284300f8953f199b5ffbc04cbbb0ec78f74b1/matplotlib_inline-0.2.1.tar.gz", hash = "sha256:e1ee949c340d771fc39e241ea75683deb94762c8fa5f2927ec57c83c4dffa9fe", size = 8110, upload-time = "2025-10-23T09:00:22.126Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/af/33/ee4519fa02ed11a94aef9559552f3b17bb863f2ecfe1a35dc7f548cde231/matplotlib_inline-0.2.1-py3-none-any.whl", hash = "sha256:d56ce5156ba6085e00a9d54fead6ed29a9c47e215cd1bba2e976ef39f5710a76", size = 9516, upload-time = "2025-10-23T09:00:20.675Z" }, +] + +[[package]] +name = "mpmath" +version = "1.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e0/47/dd32fa426cc72114383ac549964eecb20ecfd886d1e5ccf5340b55b02f57/mpmath-1.3.0.tar.gz", hash = "sha256:7a28eb2a9774d00c7bc92411c19a89209d5da7c4c9a9e227be8330a23a25b91f", size = 508106, upload-time = "2023-03-07T16:47:11.061Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/43/e3/7d92a15f894aa0c9c4b49b8ee9ac9850d6e63b03c9c32c0367a13ae62209/mpmath-1.3.0-py3-none-any.whl", hash = "sha256:a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c", size = 536198, upload-time = "2023-03-07T16:47:09.197Z" }, +] + +[[package]] +name = "msgpack" +version = "1.1.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4d/f2/bfb55a6236ed8725a96b0aa3acbd0ec17588e6a2c3b62a93eb513ed8783f/msgpack-1.1.2.tar.gz", hash = "sha256:3b60763c1373dd60f398488069bcdc703cd08a711477b5d480eecc9f9626f47e", size = 173581, upload-time = "2025-10-08T09:15:56.596Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2c/97/560d11202bcd537abca693fd85d81cebe2107ba17301de42b01ac1677b69/msgpack-1.1.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:2e86a607e558d22985d856948c12a3fa7b42efad264dca8a3ebbcfa2735d786c", size = 82271, upload-time = "2025-10-08T09:14:49.967Z" }, + { url = "https://files.pythonhosted.org/packages/83/04/28a41024ccbd67467380b6fb440ae916c1e4f25e2cd4c63abe6835ac566e/msgpack-1.1.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:283ae72fc89da59aa004ba147e8fc2f766647b1251500182fac0350d8af299c0", size = 84914, upload-time = "2025-10-08T09:14:50.958Z" }, + { url = "https://files.pythonhosted.org/packages/71/46/b817349db6886d79e57a966346cf0902a426375aadc1e8e7a86a75e22f19/msgpack-1.1.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:61c8aa3bd513d87c72ed0b37b53dd5c5a0f58f2ff9f26e1555d3bd7948fb7296", size = 416962, upload-time = "2025-10-08T09:14:51.997Z" }, + { url = "https://files.pythonhosted.org/packages/da/e0/6cc2e852837cd6086fe7d8406af4294e66827a60a4cf60b86575a4a65ca8/msgpack-1.1.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:454e29e186285d2ebe65be34629fa0e8605202c60fbc7c4c650ccd41870896ef", size = 426183, upload-time = "2025-10-08T09:14:53.477Z" }, + { url = "https://files.pythonhosted.org/packages/25/98/6a19f030b3d2ea906696cedd1eb251708e50a5891d0978b012cb6107234c/msgpack-1.1.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7bc8813f88417599564fafa59fd6f95be417179f76b40325b500b3c98409757c", size = 411454, upload-time = "2025-10-08T09:14:54.648Z" }, + { url = "https://files.pythonhosted.org/packages/b7/cd/9098fcb6adb32187a70b7ecaabf6339da50553351558f37600e53a4a2a23/msgpack-1.1.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:bafca952dc13907bdfdedfc6a5f579bf4f292bdd506fadb38389afa3ac5b208e", size = 422341, upload-time = "2025-10-08T09:14:56.328Z" }, + { url = "https://files.pythonhosted.org/packages/e6/ae/270cecbcf36c1dc85ec086b33a51a4d7d08fc4f404bdbc15b582255d05ff/msgpack-1.1.2-cp311-cp311-win32.whl", hash = "sha256:602b6740e95ffc55bfb078172d279de3773d7b7db1f703b2f1323566b878b90e", size = 64747, upload-time = "2025-10-08T09:14:57.882Z" }, + { url = "https://files.pythonhosted.org/packages/2a/79/309d0e637f6f37e83c711f547308b91af02b72d2326ddd860b966080ef29/msgpack-1.1.2-cp311-cp311-win_amd64.whl", hash = "sha256:d198d275222dc54244bf3327eb8cbe00307d220241d9cec4d306d49a44e85f68", size = 71633, upload-time = "2025-10-08T09:14:59.177Z" }, + { url = "https://files.pythonhosted.org/packages/73/4d/7c4e2b3d9b1106cd0aa6cb56cc57c6267f59fa8bfab7d91df5adc802c847/msgpack-1.1.2-cp311-cp311-win_arm64.whl", hash = "sha256:86f8136dfa5c116365a8a651a7d7484b65b13339731dd6faebb9a0242151c406", size = 64755, upload-time = "2025-10-08T09:15:00.48Z" }, + { url = "https://files.pythonhosted.org/packages/ad/bd/8b0d01c756203fbab65d265859749860682ccd2a59594609aeec3a144efa/msgpack-1.1.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:70a0dff9d1f8da25179ffcf880e10cf1aad55fdb63cd59c9a49a1b82290062aa", size = 81939, upload-time = "2025-10-08T09:15:01.472Z" }, + { url = "https://files.pythonhosted.org/packages/34/68/ba4f155f793a74c1483d4bdef136e1023f7bcba557f0db4ef3db3c665cf1/msgpack-1.1.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:446abdd8b94b55c800ac34b102dffd2f6aa0ce643c55dfc017ad89347db3dbdb", size = 85064, upload-time = "2025-10-08T09:15:03.764Z" }, + { url = "https://files.pythonhosted.org/packages/f2/60/a064b0345fc36c4c3d2c743c82d9100c40388d77f0b48b2f04d6041dbec1/msgpack-1.1.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c63eea553c69ab05b6747901b97d620bb2a690633c77f23feb0c6a947a8a7b8f", size = 417131, upload-time = "2025-10-08T09:15:05.136Z" }, + { url = "https://files.pythonhosted.org/packages/65/92/a5100f7185a800a5d29f8d14041f61475b9de465ffcc0f3b9fba606e4505/msgpack-1.1.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:372839311ccf6bdaf39b00b61288e0557916c3729529b301c52c2d88842add42", size = 427556, upload-time = "2025-10-08T09:15:06.837Z" }, + { url = "https://files.pythonhosted.org/packages/f5/87/ffe21d1bf7d9991354ad93949286f643b2bb6ddbeab66373922b44c3b8cc/msgpack-1.1.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2929af52106ca73fcb28576218476ffbb531a036c2adbcf54a3664de124303e9", size = 404920, upload-time = "2025-10-08T09:15:08.179Z" }, + { url = "https://files.pythonhosted.org/packages/ff/41/8543ed2b8604f7c0d89ce066f42007faac1eaa7d79a81555f206a5cdb889/msgpack-1.1.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:be52a8fc79e45b0364210eef5234a7cf8d330836d0a64dfbb878efa903d84620", size = 415013, upload-time = "2025-10-08T09:15:09.83Z" }, + { url = "https://files.pythonhosted.org/packages/41/0d/2ddfaa8b7e1cee6c490d46cb0a39742b19e2481600a7a0e96537e9c22f43/msgpack-1.1.2-cp312-cp312-win32.whl", hash = "sha256:1fff3d825d7859ac888b0fbda39a42d59193543920eda9d9bea44d958a878029", size = 65096, upload-time = "2025-10-08T09:15:11.11Z" }, + { url = "https://files.pythonhosted.org/packages/8c/ec/d431eb7941fb55a31dd6ca3404d41fbb52d99172df2e7707754488390910/msgpack-1.1.2-cp312-cp312-win_amd64.whl", hash = "sha256:1de460f0403172cff81169a30b9a92b260cb809c4cb7e2fc79ae8d0510c78b6b", size = 72708, upload-time = "2025-10-08T09:15:12.554Z" }, + { url = "https://files.pythonhosted.org/packages/c5/31/5b1a1f70eb0e87d1678e9624908f86317787b536060641d6798e3cf70ace/msgpack-1.1.2-cp312-cp312-win_arm64.whl", hash = "sha256:be5980f3ee0e6bd44f3a9e9dea01054f175b50c3e6cdb692bc9424c0bbb8bf69", size = 64119, upload-time = "2025-10-08T09:15:13.589Z" }, + { url = "https://files.pythonhosted.org/packages/6b/31/b46518ecc604d7edf3a4f94cb3bf021fc62aa301f0cb849936968164ef23/msgpack-1.1.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4efd7b5979ccb539c221a4c4e16aac1a533efc97f3b759bb5a5ac9f6d10383bf", size = 81212, upload-time = "2025-10-08T09:15:14.552Z" }, + { url = "https://files.pythonhosted.org/packages/92/dc/c385f38f2c2433333345a82926c6bfa5ecfff3ef787201614317b58dd8be/msgpack-1.1.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:42eefe2c3e2af97ed470eec850facbe1b5ad1d6eacdbadc42ec98e7dcf68b4b7", size = 84315, upload-time = "2025-10-08T09:15:15.543Z" }, + { url = "https://files.pythonhosted.org/packages/d3/68/93180dce57f684a61a88a45ed13047558ded2be46f03acb8dec6d7c513af/msgpack-1.1.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1fdf7d83102bf09e7ce3357de96c59b627395352a4024f6e2458501f158bf999", size = 412721, upload-time = "2025-10-08T09:15:16.567Z" }, + { url = "https://files.pythonhosted.org/packages/5d/ba/459f18c16f2b3fc1a1ca871f72f07d70c07bf768ad0a507a698b8052ac58/msgpack-1.1.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fac4be746328f90caa3cd4bc67e6fe36ca2bf61d5c6eb6d895b6527e3f05071e", size = 424657, upload-time = "2025-10-08T09:15:17.825Z" }, + { url = "https://files.pythonhosted.org/packages/38/f8/4398c46863b093252fe67368b44edc6c13b17f4e6b0e4929dbf0bdb13f23/msgpack-1.1.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:fffee09044073e69f2bad787071aeec727183e7580443dfeb8556cbf1978d162", size = 402668, upload-time = "2025-10-08T09:15:19.003Z" }, + { url = "https://files.pythonhosted.org/packages/28/ce/698c1eff75626e4124b4d78e21cca0b4cc90043afb80a507626ea354ab52/msgpack-1.1.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:5928604de9b032bc17f5099496417f113c45bc6bc21b5c6920caf34b3c428794", size = 419040, upload-time = "2025-10-08T09:15:20.183Z" }, + { url = "https://files.pythonhosted.org/packages/67/32/f3cd1667028424fa7001d82e10ee35386eea1408b93d399b09fb0aa7875f/msgpack-1.1.2-cp313-cp313-win32.whl", hash = "sha256:a7787d353595c7c7e145e2331abf8b7ff1e6673a6b974ded96e6d4ec09f00c8c", size = 65037, upload-time = "2025-10-08T09:15:21.416Z" }, + { url = "https://files.pythonhosted.org/packages/74/07/1ed8277f8653c40ebc65985180b007879f6a836c525b3885dcc6448ae6cb/msgpack-1.1.2-cp313-cp313-win_amd64.whl", hash = "sha256:a465f0dceb8e13a487e54c07d04ae3ba131c7c5b95e2612596eafde1dccf64a9", size = 72631, upload-time = "2025-10-08T09:15:22.431Z" }, + { url = "https://files.pythonhosted.org/packages/e5/db/0314e4e2db56ebcf450f277904ffd84a7988b9e5da8d0d61ab2d057df2b6/msgpack-1.1.2-cp313-cp313-win_arm64.whl", hash = "sha256:e69b39f8c0aa5ec24b57737ebee40be647035158f14ed4b40e6f150077e21a84", size = 64118, upload-time = "2025-10-08T09:15:23.402Z" }, + { url = "https://files.pythonhosted.org/packages/22/71/201105712d0a2ff07b7873ed3c220292fb2ea5120603c00c4b634bcdafb3/msgpack-1.1.2-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:e23ce8d5f7aa6ea6d2a2b326b4ba46c985dbb204523759984430db7114f8aa00", size = 81127, upload-time = "2025-10-08T09:15:24.408Z" }, + { url = "https://files.pythonhosted.org/packages/1b/9f/38ff9e57a2eade7bf9dfee5eae17f39fc0e998658050279cbb14d97d36d9/msgpack-1.1.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:6c15b7d74c939ebe620dd8e559384be806204d73b4f9356320632d783d1f7939", size = 84981, upload-time = "2025-10-08T09:15:25.812Z" }, + { url = "https://files.pythonhosted.org/packages/8e/a9/3536e385167b88c2cc8f4424c49e28d49a6fc35206d4a8060f136e71f94c/msgpack-1.1.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:99e2cb7b9031568a2a5c73aa077180f93dd2e95b4f8d3b8e14a73ae94a9e667e", size = 411885, upload-time = "2025-10-08T09:15:27.22Z" }, + { url = "https://files.pythonhosted.org/packages/2f/40/dc34d1a8d5f1e51fc64640b62b191684da52ca469da9cd74e84936ffa4a6/msgpack-1.1.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:180759d89a057eab503cf62eeec0aa61c4ea1200dee709f3a8e9397dbb3b6931", size = 419658, upload-time = "2025-10-08T09:15:28.4Z" }, + { url = "https://files.pythonhosted.org/packages/3b/ef/2b92e286366500a09a67e03496ee8b8ba00562797a52f3c117aa2b29514b/msgpack-1.1.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:04fb995247a6e83830b62f0b07bf36540c213f6eac8e851166d8d86d83cbd014", size = 403290, upload-time = "2025-10-08T09:15:29.764Z" }, + { url = "https://files.pythonhosted.org/packages/78/90/e0ea7990abea5764e4655b8177aa7c63cdfa89945b6e7641055800f6c16b/msgpack-1.1.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:8e22ab046fa7ede9e36eeb4cfad44d46450f37bb05d5ec482b02868f451c95e2", size = 415234, upload-time = "2025-10-08T09:15:31.022Z" }, + { url = "https://files.pythonhosted.org/packages/72/4e/9390aed5db983a2310818cd7d3ec0aecad45e1f7007e0cda79c79507bb0d/msgpack-1.1.2-cp314-cp314-win32.whl", hash = "sha256:80a0ff7d4abf5fecb995fcf235d4064b9a9a8a40a3ab80999e6ac1e30b702717", size = 66391, upload-time = "2025-10-08T09:15:32.265Z" }, + { url = "https://files.pythonhosted.org/packages/6e/f1/abd09c2ae91228c5f3998dbd7f41353def9eac64253de3c8105efa2082f7/msgpack-1.1.2-cp314-cp314-win_amd64.whl", hash = "sha256:9ade919fac6a3e7260b7f64cea89df6bec59104987cbea34d34a2fa15d74310b", size = 73787, upload-time = "2025-10-08T09:15:33.219Z" }, + { url = "https://files.pythonhosted.org/packages/6a/b0/9d9f667ab48b16ad4115c1935d94023b82b3198064cb84a123e97f7466c1/msgpack-1.1.2-cp314-cp314-win_arm64.whl", hash = "sha256:59415c6076b1e30e563eb732e23b994a61c159cec44deaf584e5cc1dd662f2af", size = 66453, upload-time = "2025-10-08T09:15:34.225Z" }, + { url = "https://files.pythonhosted.org/packages/16/67/93f80545eb1792b61a217fa7f06d5e5cb9e0055bed867f43e2b8e012e137/msgpack-1.1.2-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:897c478140877e5307760b0ea66e0932738879e7aa68144d9b78ea4c8302a84a", size = 85264, upload-time = "2025-10-08T09:15:35.61Z" }, + { url = "https://files.pythonhosted.org/packages/87/1c/33c8a24959cf193966ef11a6f6a2995a65eb066bd681fd085afd519a57ce/msgpack-1.1.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:a668204fa43e6d02f89dbe79a30b0d67238d9ec4c5bd8a940fc3a004a47b721b", size = 89076, upload-time = "2025-10-08T09:15:36.619Z" }, + { url = "https://files.pythonhosted.org/packages/fc/6b/62e85ff7193663fbea5c0254ef32f0c77134b4059f8da89b958beb7696f3/msgpack-1.1.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5559d03930d3aa0f3aacb4c42c776af1a2ace2611871c84a75afe436695e6245", size = 435242, upload-time = "2025-10-08T09:15:37.647Z" }, + { url = "https://files.pythonhosted.org/packages/c1/47/5c74ecb4cc277cf09f64e913947871682ffa82b3b93c8dad68083112f412/msgpack-1.1.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:70c5a7a9fea7f036b716191c29047374c10721c389c21e9ffafad04df8c52c90", size = 432509, upload-time = "2025-10-08T09:15:38.794Z" }, + { url = "https://files.pythonhosted.org/packages/24/a4/e98ccdb56dc4e98c929a3f150de1799831c0a800583cde9fa022fa90602d/msgpack-1.1.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:f2cb069d8b981abc72b41aea1c580ce92d57c673ec61af4c500153a626cb9e20", size = 415957, upload-time = "2025-10-08T09:15:40.238Z" }, + { url = "https://files.pythonhosted.org/packages/da/28/6951f7fb67bc0a4e184a6b38ab71a92d9ba58080b27a77d3e2fb0be5998f/msgpack-1.1.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:d62ce1f483f355f61adb5433ebfd8868c5f078d1a52d042b0a998682b4fa8c27", size = 422910, upload-time = "2025-10-08T09:15:41.505Z" }, + { url = "https://files.pythonhosted.org/packages/f0/03/42106dcded51f0a0b5284d3ce30a671e7bd3f7318d122b2ead66ad289fed/msgpack-1.1.2-cp314-cp314t-win32.whl", hash = "sha256:1d1418482b1ee984625d88aa9585db570180c286d942da463533b238b98b812b", size = 75197, upload-time = "2025-10-08T09:15:42.954Z" }, + { url = "https://files.pythonhosted.org/packages/15/86/d0071e94987f8db59d4eeb386ddc64d0bb9b10820a8d82bcd3e53eeb2da6/msgpack-1.1.2-cp314-cp314t-win_amd64.whl", hash = "sha256:5a46bf7e831d09470ad92dff02b8b1ac92175ca36b087f904a0519857c6be3ff", size = 85772, upload-time = "2025-10-08T09:15:43.954Z" }, + { url = "https://files.pythonhosted.org/packages/81/f2/08ace4142eb281c12701fc3b93a10795e4d4dc7f753911d836675050f886/msgpack-1.1.2-cp314-cp314t-win_arm64.whl", hash = "sha256:d99ef64f349d5ec3293688e91486c5fdb925ed03807f64d98d205d2713c60b46", size = 70868, upload-time = "2025-10-08T09:15:44.959Z" }, +] + +[[package]] +name = "mutagen" +version = "1.47.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/81/e6/64bc71b74eef4b68e61eb921dcf72dabd9e4ec4af1e11891bbd312ccbb77/mutagen-1.47.0.tar.gz", hash = "sha256:719fadef0a978c31b4cf3c956261b3c58b6948b32023078a2117b1de09f0fc99", size = 1274186, upload-time = "2023-09-03T16:33:33.411Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b0/7a/620f945b96be1f6ee357d211d5bf74ab1b7fe72a9f1525aafbfe3aee6875/mutagen-1.47.0-py3-none-any.whl", hash = "sha256:edd96f50c5907a9539d8e5bba7245f62c9f520aef333d13392a79a4f70aca719", size = 194391, upload-time = "2023-09-03T16:33:29.955Z" }, +] + +[[package]] +name = "networkx" +version = "3.6.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6a/51/63fe664f3908c97be9d2e4f1158eb633317598cfa6e1fc14af5383f17512/networkx-3.6.1.tar.gz", hash = "sha256:26b7c357accc0c8cde558ad486283728b65b6a95d85ee1cd66bafab4c8168509", size = 2517025, upload-time = "2025-12-08T17:02:39.908Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/c9/b2622292ea83fbb4ec318f5b9ab867d0a28ab43c5717bb85b0a5f6b3b0a4/networkx-3.6.1-py3-none-any.whl", hash = "sha256:d47fbf302e7d9cbbb9e2555a0d267983d2aa476bac30e90dfbe5669bd57f3762", size = 2068504, upload-time = "2025-12-08T17:02:38.159Z" }, +] + +[[package]] +name = "numba" +version = "0.65.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "llvmlite" }, + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f6/c5/db2ac3685833d626c0dcae6bd2330cd68433e1fd248d15f70998160d3ad7/numba-0.65.1.tar.gz", hash = "sha256:19357146c32fe9ed25059ab915e8465fb13951cf6b0aace3826b76886373ab23", size = 2765600, upload-time = "2026-04-24T02:02:56.551Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/96/b3/650500c2eab4534d98e9166f4298e0f3c69c742afdf24e6eabccd1f16ad8/numba-0.65.1-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:7020d74b19cdb8cff16506542fdd510756e28c5e7f3bd0b7f574f0f42272fcd9", size = 2680563, upload-time = "2026-04-24T02:02:18.414Z" }, + { url = "https://files.pythonhosted.org/packages/44/0b/0615dbedb98f5b32a35a53290fbdc6e22306968109278d7e58df82d7a9f6/numba-0.65.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f80ed83774b5173abd6581cd8d2165d1d38e13d2e5c8155c0c0b421784745420", size = 3745018, upload-time = "2026-04-24T02:02:20.252Z" }, + { url = "https://files.pythonhosted.org/packages/49/aa/4361698f35bf63bff67dfe6c90493731177f48ede954f77b0588731537bc/numba-0.65.1-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7ed425a43b0a5f9772f2f4e2dd0bbd12eabecae1af0b24efcfd4e053f012aac6", size = 3450962, upload-time = "2026-04-24T02:02:22.449Z" }, + { url = "https://files.pythonhosted.org/packages/bd/9a/af61ec03b3116c161fd7a06b9e8a265729a8718458333e8ffbb06d9a3978/numba-0.65.1-cp311-cp311-win_amd64.whl", hash = "sha256:df40a5028a975b9ea66f6a2a3f7abbdbd541a863070e34ed367aff21141248e4", size = 2747417, upload-time = "2026-04-24T02:02:24.43Z" }, + { url = "https://files.pythonhosted.org/packages/57/bc/76f8f8c5cf9adee47fdb7bbb03be8900f76f902d451d7477cf12b845e1de/numba-0.65.1-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:ac3f1e77c352dd0ea9712732c2d8f9ca507717435eec5b5013bf138ac33c4a08", size = 2681371, upload-time = "2026-04-24T02:02:26.105Z" }, + { url = "https://files.pythonhosted.org/packages/69/47/a415af0283e4db0398104c6d1c11c9861a98dc67a7aa442a7769ed5d6196/numba-0.65.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:52bc6f3ceb8fcaff9b2ae26b4c6b1e9fee39db8d355534c0fe4f39a901246b84", size = 3802467, upload-time = "2026-04-24T02:02:27.712Z" }, + { url = "https://files.pythonhosted.org/packages/46/36/246f73ec99cfeab2f2cb2ce7d4218766cc36a2da418901223f4f4da9c813/numba-0.65.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:90ca10b3463bae0bd70589726fe3c77d01d6b5fc86bee54bcdf9fb6b47c28977", size = 3502628, upload-time = "2026-04-24T02:02:29.763Z" }, + { url = "https://files.pythonhosted.org/packages/db/9e/3c679b2ee078425b9e99a91e44f8d132a6830d8ccce5227bc5e9181aeed8/numba-0.65.1-cp312-cp312-win_amd64.whl", hash = "sha256:5971c632be2a2351500431f46213821dba8d02b18a9f7d02fd36bd2743e41a6a", size = 2750611, upload-time = "2026-04-24T02:02:31.477Z" }, + { url = "https://files.pythonhosted.org/packages/79/37/14a4579049c1eb673afd0de0cb4842982acd55b9ce2643e763db858bcea0/numba-0.65.1-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:1735c15c1134a5108b4d6a5c77fc0947924ea066a738dc09a52008c13df9cad3", size = 2681344, upload-time = "2026-04-24T02:02:33.65Z" }, + { url = "https://files.pythonhosted.org/packages/a0/22/b8d873f6466b20aa563fc9b33acd48dec89a07803ddaa2f1c8ca1cd33126/numba-0.65.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c09f49117ef255e1f1c6dad0c7a1ed39868243862a73be5706793241a3755f1b", size = 3810619, upload-time = "2026-04-24T02:02:36.041Z" }, + { url = "https://files.pythonhosted.org/packages/62/08/e16a8b5d9a018962ebb5c66be662317cde32b9f5dab08441f90bed5522fb/numba-0.65.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:594a8680b3fadac99e97e489b1fd89007177e5336713745c3b769528c635a464", size = 3509783, upload-time = "2026-04-24T02:02:38.245Z" }, + { url = "https://files.pythonhosted.org/packages/fd/a5/03c970d57f4c1741354837353ce39fb5206952ae1dba8922d29c86f64805/numba-0.65.1-cp313-cp313-win_amd64.whl", hash = "sha256:85be74c0d036842699a30058f82fb88fc5ffdc59f7615cab5792ea92914c9b62", size = 2750534, upload-time = "2026-04-24T02:02:39.903Z" }, + { url = "https://files.pythonhosted.org/packages/4f/2e/8aed9b726d9ba5f11ad287645fd479e88278db3060a25cb1225d730eb2b7/numba-0.65.1-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:33f5eb68eb1c843511615d14663ce60258525d6a4c65ab040e2c2b0c4cf17450", size = 2681554, upload-time = "2026-04-24T02:02:41.812Z" }, + { url = "https://files.pythonhosted.org/packages/87/96/f3eb235fafa82a34e2ab5dd7dc9ffff998ebf5f0bbc23fa56a96aeb44da6/numba-0.65.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:71e73029bf53a62cc6afcf96be4bd942290d8b4c55f0a454fb536158115790f7", size = 3779602, upload-time = "2026-04-24T02:02:43.726Z" }, + { url = "https://files.pythonhosted.org/packages/09/90/b0f09b48752d23640b8284f22aa597737e8adaddc7fbfacc4708b7f73a4c/numba-0.65.1-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3a07635e0be926b9bdbffb09137c230fb13f6ec0e564914ba937cee12ce3eb35", size = 3479532, upload-time = "2026-04-24T02:02:45.427Z" }, + { url = "https://files.pythonhosted.org/packages/56/46/3f7fc04fb853559e74b210e0b62c19974ec844cefec611f9e535f4da3761/numba-0.65.1-cp314-cp314-win_amd64.whl", hash = "sha256:2a20fcdabdefbdacf88d85caf70c3b18c4bcb7ebb8f82e6a19486383dd26ab63", size = 2752637, upload-time = "2026-04-24T02:02:47.664Z" }, + { url = "https://files.pythonhosted.org/packages/81/7b/c1a341a9067367778f4152a5f01061cf281fb09582c92c510ec4918cabf6/numba-0.65.1-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:548dd4b3a4508d5062768d1514b2cd7b015f9a25ec7af651c50dee243965e652", size = 2684600, upload-time = "2026-04-24T02:02:49.653Z" }, + { url = "https://files.pythonhosted.org/packages/03/36/98ddbcf3e4f04a6dd07e1c67249955920579ba4af6bb6868e3088f4ed282/numba-0.65.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:78abc28feff2c2ff8307fff3975b6438352759c9acb797ecd6b1fb6e7e39e31d", size = 3817198, upload-time = "2026-04-24T02:02:51.266Z" }, + { url = "https://files.pythonhosted.org/packages/a3/83/0dad21057ece5a835599f5d24099b091703995e23dbbf894f259e91c010b/numba-0.65.1-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee7676cb389555805f9b9a1840cbcd1ea6c8bd5376ab6918e3a29c5ea1dbda20", size = 3533862, upload-time = "2026-04-24T02:02:52.987Z" }, + { url = "https://files.pythonhosted.org/packages/32/36/8be7118ffd4c8440881046eac3d0982cc5ab42909508cf5d67024d62a2e4/numba-0.65.1-cp314-cp314t-win_amd64.whl", hash = "sha256:20609346e3bd75204950dcbbfe383a8d7dbf4902f442aedbf00f97fef4aa8f38", size = 2758237, upload-time = "2026-04-24T02:02:54.612Z" }, +] + +[[package]] +name = "numpy" +version = "2.4.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d7/9f/b8cef5bffa569759033adda9481211426f12f53299629b410340795c2514/numpy-2.4.4.tar.gz", hash = "sha256:2d390634c5182175533585cc89f3608a4682ccb173cc9bb940b2881c8d6f8fa0", size = 20731587, upload-time = "2026-03-29T13:22:01.298Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ef/c6/4218570d8c8ecc9704b5157a3348e486e84ef4be0ed3e38218ab473c83d2/numpy-2.4.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f983334aea213c99992053ede6168500e5f086ce74fbc4acc3f2b00f5762e9db", size = 16976799, upload-time = "2026-03-29T13:18:15.438Z" }, + { url = "https://files.pythonhosted.org/packages/dd/92/b4d922c4a5f5dab9ed44e6153908a5c665b71acf183a83b93b690996e39b/numpy-2.4.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:72944b19f2324114e9dc86a159787333b77874143efcf89a5167ef83cfee8af0", size = 14971552, upload-time = "2026-03-29T13:18:18.606Z" }, + { url = "https://files.pythonhosted.org/packages/8a/dc/df98c095978fa6ee7b9a9387d1d58cbb3d232d0e69ad169a4ce784bde4fd/numpy-2.4.4-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:86b6f55f5a352b48d7fbfd2dbc3d5b780b2d79f4d3c121f33eb6efb22e9a2015", size = 5476566, upload-time = "2026-03-29T13:18:21.532Z" }, + { url = "https://files.pythonhosted.org/packages/28/34/b3fdcec6e725409223dd27356bdf5a3c2cc2282e428218ecc9cb7acc9763/numpy-2.4.4-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:ba1f4fc670ed79f876f70082eff4f9583c15fb9a4b89d6188412de4d18ae2f40", size = 6806482, upload-time = "2026-03-29T13:18:23.634Z" }, + { url = "https://files.pythonhosted.org/packages/68/62/63417c13aa35d57bee1337c67446761dc25ea6543130cf868eace6e8157b/numpy-2.4.4-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8a87ec22c87be071b6bdbd27920b129b94f2fc964358ce38f3822635a3e2e03d", size = 15973376, upload-time = "2026-03-29T13:18:26.677Z" }, + { url = "https://files.pythonhosted.org/packages/cf/c5/9fcb7e0e69cef59cf10c746b84f7d58b08bc66a6b7d459783c5a4f6101a6/numpy-2.4.4-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:df3775294accfdd75f32c74ae39fcba920c9a378a2fc18a12b6820aa8c1fb502", size = 16925137, upload-time = "2026-03-29T13:18:30.14Z" }, + { url = "https://files.pythonhosted.org/packages/7e/43/80020edacb3f84b9efdd1591120a4296462c23fd8db0dde1666f6ef66f13/numpy-2.4.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0d4e437e295f18ec29bc79daf55e8a47a9113df44d66f702f02a293d93a2d6dd", size = 17329414, upload-time = "2026-03-29T13:18:33.733Z" }, + { url = "https://files.pythonhosted.org/packages/fd/06/af0658593b18a5f73532d377188b964f239eb0894e664a6c12f484472f97/numpy-2.4.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:6aa3236c78803afbcb255045fbef97a9e25a1f6c9888357d205ddc42f4d6eba5", size = 18658397, upload-time = "2026-03-29T13:18:37.511Z" }, + { url = "https://files.pythonhosted.org/packages/e6/ce/13a09ed65f5d0ce5c7dd0669250374c6e379910f97af2c08c57b0608eee4/numpy-2.4.4-cp311-cp311-win32.whl", hash = "sha256:30caa73029a225b2d40d9fae193e008e24b2026b7ee1a867b7ee8d96ca1a448e", size = 6239499, upload-time = "2026-03-29T13:18:40.372Z" }, + { url = "https://files.pythonhosted.org/packages/bd/63/05d193dbb4b5eec1eca73822d80da98b511f8328ad4ae3ca4caf0f4db91d/numpy-2.4.4-cp311-cp311-win_amd64.whl", hash = "sha256:6bbe4eb67390b0a0265a2c25458f6b90a409d5d069f1041e6aff1e27e3d9a79e", size = 12614257, upload-time = "2026-03-29T13:18:42.95Z" }, + { url = "https://files.pythonhosted.org/packages/87/c5/8168052f080c26fa984c413305012be54741c9d0d74abd7fbeeccae3889f/numpy-2.4.4-cp311-cp311-win_arm64.whl", hash = "sha256:fcfe2045fd2e8f3cb0ce9d4ba6dba6333b8fa05bb8a4939c908cd43322d14c7e", size = 10486775, upload-time = "2026-03-29T13:18:45.835Z" }, + { url = "https://files.pythonhosted.org/packages/28/05/32396bec30fb2263770ee910142f49c1476d08e8ad41abf8403806b520ce/numpy-2.4.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:15716cfef24d3a9762e3acdf87e27f58dc823d1348f765bbea6bef8c639bfa1b", size = 16689272, upload-time = "2026-03-29T13:18:49.223Z" }, + { url = "https://files.pythonhosted.org/packages/c5/f3/a983d28637bfcd763a9c7aafdb6d5c0ebf3d487d1e1459ffdb57e2f01117/numpy-2.4.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:23cbfd4c17357c81021f21540da84ee282b9c8fba38a03b7b9d09ba6b951421e", size = 14699573, upload-time = "2026-03-29T13:18:52.629Z" }, + { url = "https://files.pythonhosted.org/packages/9b/fd/e5ecca1e78c05106d98028114f5c00d3eddb41207686b2b7de3e477b0e22/numpy-2.4.4-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:8b3b60bb7cba2c8c81837661c488637eee696f59a877788a396d33150c35d842", size = 5204782, upload-time = "2026-03-29T13:18:55.579Z" }, + { url = "https://files.pythonhosted.org/packages/de/2f/702a4594413c1a8632092beae8aba00f1d67947389369b3777aed783fdca/numpy-2.4.4-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:e4a010c27ff6f210ff4c6ef34394cd61470d01014439b192ec22552ee867f2a8", size = 6552038, upload-time = "2026-03-29T13:18:57.769Z" }, + { url = "https://files.pythonhosted.org/packages/7f/37/eed308a8f56cba4d1fdf467a4fc67ef4ff4bf1c888f5fc980481890104b1/numpy-2.4.4-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f9e75681b59ddaa5e659898085ae0eaea229d054f2ac0c7e563a62205a700121", size = 15670666, upload-time = "2026-03-29T13:19:00.341Z" }, + { url = "https://files.pythonhosted.org/packages/0a/0d/0e3ecece05b7a7e87ab9fb587855548da437a061326fff64a223b6dcb78a/numpy-2.4.4-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:81f4a14bee47aec54f883e0cad2d73986640c1590eb9bfaaba7ad17394481e6e", size = 16645480, upload-time = "2026-03-29T13:19:03.63Z" }, + { url = "https://files.pythonhosted.org/packages/34/49/f2312c154b82a286758ee2f1743336d50651f8b5195db18cdb63675ff649/numpy-2.4.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:62d6b0f03b694173f9fcb1fb317f7222fd0b0b103e784c6549f5e53a27718c44", size = 17020036, upload-time = "2026-03-29T13:19:07.428Z" }, + { url = "https://files.pythonhosted.org/packages/7b/e9/736d17bd77f1b0ec4f9901aaec129c00d59f5d84d5e79bba540ef12c2330/numpy-2.4.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fbc356aae7adf9e6336d336b9c8111d390a05df88f1805573ebb0807bd06fd1d", size = 18368643, upload-time = "2026-03-29T13:19:10.775Z" }, + { url = "https://files.pythonhosted.org/packages/63/f6/d417977c5f519b17c8a5c3bc9e8304b0908b0e21136fe43bf628a1343914/numpy-2.4.4-cp312-cp312-win32.whl", hash = "sha256:0d35aea54ad1d420c812bfa0385c71cd7cc5bcf7c65fed95fc2cd02fe8c79827", size = 5961117, upload-time = "2026-03-29T13:19:13.464Z" }, + { url = "https://files.pythonhosted.org/packages/2d/5b/e1deebf88ff431b01b7406ca3583ab2bbb90972bbe1c568732e49c844f7e/numpy-2.4.4-cp312-cp312-win_amd64.whl", hash = "sha256:b5f0362dc928a6ecd9db58868fca5e48485205e3855957bdedea308f8672ea4a", size = 12320584, upload-time = "2026-03-29T13:19:16.155Z" }, + { url = "https://files.pythonhosted.org/packages/58/89/e4e856ac82a68c3ed64486a544977d0e7bdd18b8da75b78a577ca31c4395/numpy-2.4.4-cp312-cp312-win_arm64.whl", hash = "sha256:846300f379b5b12cc769334464656bc882e0735d27d9726568bc932fdc49d5ec", size = 10221450, upload-time = "2026-03-29T13:19:18.994Z" }, + { url = "https://files.pythonhosted.org/packages/14/1d/d0a583ce4fefcc3308806a749a536c201ed6b5ad6e1322e227ee4848979d/numpy-2.4.4-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:08f2e31ed5e6f04b118e49821397f12767934cfdd12a1ce86a058f91e004ee50", size = 16684933, upload-time = "2026-03-29T13:19:22.47Z" }, + { url = "https://files.pythonhosted.org/packages/c1/62/2b7a48fbb745d344742c0277f01286dead15f3f68e4f359fbfcf7b48f70f/numpy-2.4.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e823b8b6edc81e747526f70f71a9c0a07ac4e7ad13020aa736bb7c9d67196115", size = 14694532, upload-time = "2026-03-29T13:19:25.581Z" }, + { url = "https://files.pythonhosted.org/packages/e5/87/499737bfba066b4a3bebff24a8f1c5b2dee410b209bc6668c9be692580f0/numpy-2.4.4-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:4a19d9dba1a76618dd86b164d608566f393f8ec6ac7c44f0cc879011c45e65af", size = 5199661, upload-time = "2026-03-29T13:19:28.31Z" }, + { url = "https://files.pythonhosted.org/packages/cd/da/464d551604320d1491bc345efed99b4b7034143a85787aab78d5691d5a0e/numpy-2.4.4-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:d2a8490669bfe99a233298348acc2d824d496dee0e66e31b66a6022c2ad74a5c", size = 6547539, upload-time = "2026-03-29T13:19:30.97Z" }, + { url = "https://files.pythonhosted.org/packages/7d/90/8d23e3b0dafd024bf31bdec225b3bb5c2dbfa6912f8a53b8659f21216cbf/numpy-2.4.4-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:45dbed2ab436a9e826e302fcdcbe9133f9b0006e5af7168afb8963a6520da103", size = 15668806, upload-time = "2026-03-29T13:19:33.887Z" }, + { url = "https://files.pythonhosted.org/packages/d1/73/a9d864e42a01896bb5974475438f16086be9ba1f0d19d0bb7a07427c4a8b/numpy-2.4.4-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c901b15172510173f5cb310eae652908340f8dede90fff9e3bf6c0d8dfd92f83", size = 16632682, upload-time = "2026-03-29T13:19:37.336Z" }, + { url = "https://files.pythonhosted.org/packages/34/fb/14570d65c3bde4e202a031210475ae9cde9b7686a2e7dc97ee67d2833b35/numpy-2.4.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:99d838547ace2c4aace6c4f76e879ddfe02bb58a80c1549928477862b7a6d6ed", size = 17019810, upload-time = "2026-03-29T13:19:40.963Z" }, + { url = "https://files.pythonhosted.org/packages/8a/77/2ba9d87081fd41f6d640c83f26fb7351e536b7ce6dd9061b6af5904e8e46/numpy-2.4.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:0aec54fd785890ecca25a6003fd9a5aed47ad607bbac5cd64f836ad8666f4959", size = 18357394, upload-time = "2026-03-29T13:19:44.859Z" }, + { url = "https://files.pythonhosted.org/packages/a2/23/52666c9a41708b0853fa3b1a12c90da38c507a3074883823126d4e9d5b30/numpy-2.4.4-cp313-cp313-win32.whl", hash = "sha256:07077278157d02f65c43b1b26a3886bce886f95d20aabd11f87932750dfb14ed", size = 5959556, upload-time = "2026-03-29T13:19:47.661Z" }, + { url = "https://files.pythonhosted.org/packages/57/fb/48649b4971cde70d817cf97a2a2fdc0b4d8308569f1dd2f2611959d2e0cf/numpy-2.4.4-cp313-cp313-win_amd64.whl", hash = "sha256:5c70f1cc1c4efbe316a572e2d8b9b9cc44e89b95f79ca3331553fbb63716e2bf", size = 12317311, upload-time = "2026-03-29T13:19:50.67Z" }, + { url = "https://files.pythonhosted.org/packages/ba/d8/11490cddd564eb4de97b4579ef6bfe6a736cc07e94c1598590ae25415e01/numpy-2.4.4-cp313-cp313-win_arm64.whl", hash = "sha256:ef4059d6e5152fa1a39f888e344c73fdc926e1b2dd58c771d67b0acfbf2aa67d", size = 10222060, upload-time = "2026-03-29T13:19:54.229Z" }, + { url = "https://files.pythonhosted.org/packages/99/5d/dab4339177a905aad3e2221c915b35202f1ec30d750dd2e5e9d9a72b804b/numpy-2.4.4-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:4bbc7f303d125971f60ec0aaad5e12c62d0d2c925f0ab1273debd0e4ba37aba5", size = 14822302, upload-time = "2026-03-29T13:19:57.585Z" }, + { url = "https://files.pythonhosted.org/packages/eb/e4/0564a65e7d3d97562ed6f9b0fd0fb0a6f559ee444092f105938b50043876/numpy-2.4.4-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:4d6d57903571f86180eb98f8f0c839fa9ebbfb031356d87f1361be91e433f5b7", size = 5327407, upload-time = "2026-03-29T13:20:00.601Z" }, + { url = "https://files.pythonhosted.org/packages/29/8d/35a3a6ce5ad371afa58b4700f1c820f8f279948cca32524e0a695b0ded83/numpy-2.4.4-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:4636de7fd195197b7535f231b5de9e4b36d2c440b6e566d2e4e4746e6af0ca93", size = 6647631, upload-time = "2026-03-29T13:20:02.855Z" }, + { url = "https://files.pythonhosted.org/packages/f4/da/477731acbd5a58a946c736edfdabb2ac5b34c3d08d1ba1a7b437fa0884df/numpy-2.4.4-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ad2e2ef14e0b04e544ea2fa0a36463f847f113d314aa02e5b402fdf910ef309e", size = 15727691, upload-time = "2026-03-29T13:20:06.004Z" }, + { url = "https://files.pythonhosted.org/packages/e6/db/338535d9b152beabeb511579598418ba0212ce77cf9718edd70262cc4370/numpy-2.4.4-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5a285b3b96f951841799528cd1f4f01cd70e7e0204b4abebac9463eecfcf2a40", size = 16681241, upload-time = "2026-03-29T13:20:09.417Z" }, + { url = "https://files.pythonhosted.org/packages/e2/a9/ad248e8f58beb7a0219b413c9c7d8151c5d285f7f946c3e26695bdbbe2df/numpy-2.4.4-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:f8474c4241bc18b750be2abea9d7a9ec84f46ef861dbacf86a4f6e043401f79e", size = 17085767, upload-time = "2026-03-29T13:20:13.126Z" }, + { url = "https://files.pythonhosted.org/packages/b5/1a/3b88ccd3694681356f70da841630e4725a7264d6a885c8d442a697e1146b/numpy-2.4.4-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:4e874c976154687c1f71715b034739b45c7711bec81db01914770373d125e392", size = 18403169, upload-time = "2026-03-29T13:20:17.096Z" }, + { url = "https://files.pythonhosted.org/packages/c2/c9/fcfd5d0639222c6eac7f304829b04892ef51c96a75d479214d77e3ce6e33/numpy-2.4.4-cp313-cp313t-win32.whl", hash = "sha256:9c585a1790d5436a5374bac930dad6ed244c046ed91b2b2a3634eb2971d21008", size = 6083477, upload-time = "2026-03-29T13:20:20.195Z" }, + { url = "https://files.pythonhosted.org/packages/d5/e3/3938a61d1c538aaec8ed6fd6323f57b0c2d2d2219512434c5c878db76553/numpy-2.4.4-cp313-cp313t-win_amd64.whl", hash = "sha256:93e15038125dc1e5345d9b5b68aa7f996ec33b98118d18c6ca0d0b7d6198b7e8", size = 12457487, upload-time = "2026-03-29T13:20:22.946Z" }, + { url = "https://files.pythonhosted.org/packages/97/6a/7e345032cc60501721ef94e0e30b60f6b0bd601f9174ebd36389a2b86d40/numpy-2.4.4-cp313-cp313t-win_arm64.whl", hash = "sha256:0dfd3f9d3adbe2920b68b5cd3d51444e13a10792ec7154cd0a2f6e74d4ab3233", size = 10292002, upload-time = "2026-03-29T13:20:25.909Z" }, + { url = "https://files.pythonhosted.org/packages/6e/06/c54062f85f673dd5c04cbe2f14c3acb8c8b95e3384869bb8cc9bff8cb9df/numpy-2.4.4-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:f169b9a863d34f5d11b8698ead99febeaa17a13ca044961aa8e2662a6c7766a0", size = 16684353, upload-time = "2026-03-29T13:20:29.504Z" }, + { url = "https://files.pythonhosted.org/packages/4c/39/8a320264a84404c74cc7e79715de85d6130fa07a0898f67fb5cd5bd79908/numpy-2.4.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:2483e4584a1cb3092da4470b38866634bafb223cbcd551ee047633fd2584599a", size = 14704914, upload-time = "2026-03-29T13:20:33.547Z" }, + { url = "https://files.pythonhosted.org/packages/91/fb/287076b2614e1d1044235f50f03748f31fa287e3dbe6abeb35cdfa351eca/numpy-2.4.4-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:2d19e6e2095506d1736b7d80595e0f252d76b89f5e715c35e06e937679ea7d7a", size = 5210005, upload-time = "2026-03-29T13:20:36.45Z" }, + { url = "https://files.pythonhosted.org/packages/63/eb/fcc338595309910de6ecabfcef2419a9ce24399680bfb149421fa2df1280/numpy-2.4.4-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:6a246d5914aa1c820c9443ddcee9c02bec3e203b0c080349533fae17727dfd1b", size = 6544974, upload-time = "2026-03-29T13:20:39.014Z" }, + { url = "https://files.pythonhosted.org/packages/44/5d/e7e9044032a716cdfaa3fba27a8e874bf1c5f1912a1ddd4ed071bf8a14a6/numpy-2.4.4-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:989824e9faf85f96ec9c7761cd8d29c531ad857bfa1daa930cba85baaecf1a9a", size = 15684591, upload-time = "2026-03-29T13:20:42.146Z" }, + { url = "https://files.pythonhosted.org/packages/98/7c/21252050676612625449b4807d6b695b9ce8a7c9e1c197ee6216c8a65c7c/numpy-2.4.4-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:27a8d92cd10f1382a67d7cf4db7ce18341b66438bdd9f691d7b0e48d104c2a9d", size = 16637700, upload-time = "2026-03-29T13:20:46.204Z" }, + { url = "https://files.pythonhosted.org/packages/b1/29/56d2bbef9465db24ef25393383d761a1af4f446a1df9b8cded4fe3a5a5d7/numpy-2.4.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:e44319a2953c738205bf3354537979eaa3998ed673395b964c1176083dd46252", size = 17035781, upload-time = "2026-03-29T13:20:50.242Z" }, + { url = "https://files.pythonhosted.org/packages/e3/2b/a35a6d7589d21f44cea7d0a98de5ddcbb3d421b2622a5c96b1edf18707c3/numpy-2.4.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:e892aff75639bbef0d2a2cfd55535510df26ff92f63c92cd84ef8d4ba5a5557f", size = 18362959, upload-time = "2026-03-29T13:20:54.019Z" }, + { url = "https://files.pythonhosted.org/packages/64/c9/d52ec581f2390e0f5f85cbfd80fb83d965fc15e9f0e1aec2195faa142cde/numpy-2.4.4-cp314-cp314-win32.whl", hash = "sha256:1378871da56ca8943c2ba674530924bb8ca40cd228358a3b5f302ad60cf875fc", size = 6008768, upload-time = "2026-03-29T13:20:56.912Z" }, + { url = "https://files.pythonhosted.org/packages/fa/22/4cc31a62a6c7b74a8730e31a4274c5dc80e005751e277a2ce38e675e4923/numpy-2.4.4-cp314-cp314-win_amd64.whl", hash = "sha256:715d1c092715954784bc79e1174fc2a90093dc4dc84ea15eb14dad8abdcdeb74", size = 12449181, upload-time = "2026-03-29T13:20:59.548Z" }, + { url = "https://files.pythonhosted.org/packages/70/2e/14cda6f4d8e396c612d1bf97f22958e92148801d7e4f110cabebdc0eef4b/numpy-2.4.4-cp314-cp314-win_arm64.whl", hash = "sha256:2c194dd721e54ecad9ad387c1d35e63dce5c4450c6dc7dd5611283dda239aabb", size = 10496035, upload-time = "2026-03-29T13:21:02.524Z" }, + { url = "https://files.pythonhosted.org/packages/b1/e8/8fed8c8d848d7ecea092dc3469643f9d10bc3a134a815a3b033da1d2039b/numpy-2.4.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:2aa0613a5177c264ff5921051a5719d20095ea586ca88cc802c5c218d1c67d3e", size = 14824958, upload-time = "2026-03-29T13:21:05.671Z" }, + { url = "https://files.pythonhosted.org/packages/05/1a/d8007a5138c179c2bf33ef44503e83d70434d2642877ee8fbb230e7c0548/numpy-2.4.4-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:42c16925aa5a02362f986765f9ebabf20de75cdefdca827d14315c568dcab113", size = 5330020, upload-time = "2026-03-29T13:21:08.635Z" }, + { url = "https://files.pythonhosted.org/packages/99/64/ffb99ac6ae93faf117bcbd5c7ba48a7f45364a33e8e458545d3633615dda/numpy-2.4.4-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:874f200b2a981c647340f841730fc3a2b54c9d940566a3c4149099591e2c4c3d", size = 6650758, upload-time = "2026-03-29T13:21:10.949Z" }, + { url = "https://files.pythonhosted.org/packages/6e/6e/795cc078b78a384052e73b2f6281ff7a700e9bf53bcce2ee579d4f6dd879/numpy-2.4.4-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c9b39d38a9bd2ae1becd7eac1303d031c5c110ad31f2b319c6e7d98b135c934d", size = 15729948, upload-time = "2026-03-29T13:21:14.047Z" }, + { url = "https://files.pythonhosted.org/packages/5f/86/2acbda8cc2af5f3d7bfc791192863b9e3e19674da7b5e533fded124d1299/numpy-2.4.4-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b268594bccac7d7cf5844c7732e3f20c50921d94e36d7ec9b79e9857694b1b2f", size = 16679325, upload-time = "2026-03-29T13:21:17.561Z" }, + { url = "https://files.pythonhosted.org/packages/bc/59/cafd83018f4aa55e0ac6fa92aa066c0a1877b77a615ceff1711c260ffae8/numpy-2.4.4-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:ac6b31e35612a26483e20750126d30d0941f949426974cace8e6b5c58a3657b0", size = 17084883, upload-time = "2026-03-29T13:21:21.106Z" }, + { url = "https://files.pythonhosted.org/packages/f0/85/a42548db84e65ece46ab2caea3d3f78b416a47af387fcbb47ec28e660dc2/numpy-2.4.4-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:8e3ed142f2728df44263aaf5fb1f5b0b99f4070c553a0d7f033be65338329150", size = 18403474, upload-time = "2026-03-29T13:21:24.828Z" }, + { url = "https://files.pythonhosted.org/packages/ed/ad/483d9e262f4b831000062e5d8a45e342166ec8aaa1195264982bca267e62/numpy-2.4.4-cp314-cp314t-win32.whl", hash = "sha256:dddbbd259598d7240b18c9d87c56a9d2fb3b02fe266f49a7c101532e78c1d871", size = 6155500, upload-time = "2026-03-29T13:21:28.205Z" }, + { url = "https://files.pythonhosted.org/packages/c7/03/2fc4e14c7bd4ff2964b74ba90ecb8552540b6315f201df70f137faa5c589/numpy-2.4.4-cp314-cp314t-win_amd64.whl", hash = "sha256:a7164afb23be6e37ad90b2f10426149fd75aee07ca55653d2aa41e66c4ef697e", size = 12637755, upload-time = "2026-03-29T13:21:31.107Z" }, + { url = "https://files.pythonhosted.org/packages/58/78/548fb8e07b1a341746bfbecb32f2c268470f45fa028aacdbd10d9bc73aab/numpy-2.4.4-cp314-cp314t-win_arm64.whl", hash = "sha256:ba203255017337d39f89bdd58417f03c4426f12beed0440cfd933cb15f8669c7", size = 10566643, upload-time = "2026-03-29T13:21:34.339Z" }, + { url = "https://files.pythonhosted.org/packages/6b/33/8fae8f964a4f63ed528264ddf25d2b683d0b663e3cba26961eb838a7c1bd/numpy-2.4.4-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:58c8b5929fcb8287cbd6f0a3fae19c6e03a5c48402ae792962ac465224a629a4", size = 16854491, upload-time = "2026-03-29T13:21:38.03Z" }, + { url = "https://files.pythonhosted.org/packages/bc/d0/1aabee441380b981cf8cdda3ae7a46aa827d1b5a8cce84d14598bc94d6d9/numpy-2.4.4-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:eea7ac5d2dce4189771cedb559c738a71512768210dc4e4753b107a2048b3d0e", size = 14895830, upload-time = "2026-03-29T13:21:41.509Z" }, + { url = "https://files.pythonhosted.org/packages/a5/b8/aafb0d1065416894fccf4df6b49ef22b8db045187949545bced89c034b8e/numpy-2.4.4-pp311-pypy311_pp73-macosx_14_0_arm64.whl", hash = "sha256:51fc224f7ca4d92656d5a5eb315f12eb5fe2c97a66249aa7b5f562528a3be38c", size = 5400927, upload-time = "2026-03-29T13:21:44.747Z" }, + { url = "https://files.pythonhosted.org/packages/d6/77/063baa20b08b431038c7f9ff5435540c7b7265c78cf56012a483019ca72d/numpy-2.4.4-pp311-pypy311_pp73-macosx_14_0_x86_64.whl", hash = "sha256:28a650663f7314afc3e6ec620f44f333c386aad9f6fc472030865dc0ebb26ee3", size = 6715557, upload-time = "2026-03-29T13:21:47.406Z" }, + { url = "https://files.pythonhosted.org/packages/c7/a8/379542d45a14f149444c5c4c4e7714707239ce9cc1de8c2803958889da14/numpy-2.4.4-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:19710a9ca9992d7174e9c52f643d4272dcd1558c5f7af7f6f8190f633bd651a7", size = 15804253, upload-time = "2026-03-29T13:21:50.753Z" }, + { url = "https://files.pythonhosted.org/packages/a2/c8/f0a45426d6d21e7ea3310a15cf90c43a14d9232c31a837702dba437f3373/numpy-2.4.4-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9b2aec6af35c113b05695ebb5749a787acd63cafc83086a05771d1e1cd1e555f", size = 16753552, upload-time = "2026-03-29T13:21:54.344Z" }, + { url = "https://files.pythonhosted.org/packages/04/74/f4c001f4714c3ad9ce037e18cf2b9c64871a84951eaa0baf683a9ca9301c/numpy-2.4.4-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:f2cf083b324a467e1ab358c105f6cad5ea950f50524668a80c486ff1db24e119", size = 12509075, upload-time = "2026-03-29T13:21:57.644Z" }, +] + +[[package]] +name = "nvidia-cublas-cu12" +version = "12.8.4.1" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/dc/61/e24b560ab2e2eaeb3c839129175fb330dfcfc29e5203196e5541a4c44682/nvidia_cublas_cu12-12.8.4.1-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:8ac4e771d5a348c551b2a426eda6193c19aa630236b418086020df5ba9667142", size = 594346921, upload-time = "2025-03-07T01:44:31.254Z" }, +] + +[[package]] +name = "nvidia-cuda-cupti-cu12" +version = "12.8.90" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f8/02/2adcaa145158bf1a8295d83591d22e4103dbfd821bcaf6f3f53151ca4ffa/nvidia_cuda_cupti_cu12-12.8.90-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ea0cb07ebda26bb9b29ba82cda34849e73c166c18162d3913575b0c9db9a6182", size = 10248621, upload-time = "2025-03-07T01:40:21.213Z" }, +] + +[[package]] +name = "nvidia-cuda-nvrtc-cu12" +version = "12.8.93" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/05/6b/32f747947df2da6994e999492ab306a903659555dddc0fbdeb9d71f75e52/nvidia_cuda_nvrtc_cu12-12.8.93-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", hash = "sha256:a7756528852ef889772a84c6cd89d41dfa74667e24cca16bb31f8f061e3e9994", size = 88040029, upload-time = "2025-03-07T01:42:13.562Z" }, +] + +[[package]] +name = "nvidia-cuda-runtime-cu12" +version = "12.8.90" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0d/9b/a997b638fcd068ad6e4d53b8551a7d30fe8b404d6f1804abf1df69838932/nvidia_cuda_runtime_cu12-12.8.90-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:adade8dcbd0edf427b7204d480d6066d33902cab2a4707dcfc48a2d0fd44ab90", size = 954765, upload-time = "2025-03-07T01:40:01.615Z" }, +] + +[[package]] +name = "nvidia-cudnn-cu12" +version = "9.10.2.21" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "nvidia-cublas-cu12", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/ba/51/e123d997aa098c61d029f76663dedbfb9bc8dcf8c60cbd6adbe42f76d049/nvidia_cudnn_cu12-9.10.2.21-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:949452be657fa16687d0930933f032835951ef0892b37d2d53824d1a84dc97a8", size = 706758467, upload-time = "2025-06-06T21:54:08.597Z" }, +] + +[[package]] +name = "nvidia-cufft-cu12" +version = "11.3.3.83" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "nvidia-nvjitlink-cu12", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/1f/13/ee4e00f30e676b66ae65b4f08cb5bcbb8392c03f54f2d5413ea99a5d1c80/nvidia_cufft_cu12-11.3.3.83-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4d2dd21ec0b88cf61b62e6b43564355e5222e4a3fb394cac0db101f2dd0d4f74", size = 193118695, upload-time = "2025-03-07T01:45:27.821Z" }, +] + +[[package]] +name = "nvidia-cufile-cu12" +version = "1.13.1.3" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bb/fe/1bcba1dfbfb8d01be8d93f07bfc502c93fa23afa6fd5ab3fc7c1df71038a/nvidia_cufile_cu12-1.13.1.3-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1d069003be650e131b21c932ec3d8969c1715379251f8d23a1860554b1cb24fc", size = 1197834, upload-time = "2025-03-07T01:45:50.723Z" }, +] + +[[package]] +name = "nvidia-curand-cu12" +version = "10.3.9.90" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fb/aa/6584b56dc84ebe9cf93226a5cde4d99080c8e90ab40f0c27bda7a0f29aa1/nvidia_curand_cu12-10.3.9.90-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:b32331d4f4df5d6eefa0554c565b626c7216f87a06a4f56fab27c3b68a830ec9", size = 63619976, upload-time = "2025-03-07T01:46:23.323Z" }, +] + +[[package]] +name = "nvidia-cusolver-cu12" +version = "11.7.3.90" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "nvidia-cublas-cu12", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, + { name = "nvidia-cusparse-cu12", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, + { name = "nvidia-nvjitlink-cu12", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/85/48/9a13d2975803e8cf2777d5ed57b87a0b6ca2cc795f9a4f59796a910bfb80/nvidia_cusolver_cu12-11.7.3.90-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:4376c11ad263152bd50ea295c05370360776f8c3427b30991df774f9fb26c450", size = 267506905, upload-time = "2025-03-07T01:47:16.273Z" }, +] + +[[package]] +name = "nvidia-cusparse-cu12" +version = "12.5.8.93" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "nvidia-nvjitlink-cu12", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/c2/f5/e1854cb2f2bcd4280c44736c93550cc300ff4b8c95ebe370d0aa7d2b473d/nvidia_cusparse_cu12-12.5.8.93-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1ec05d76bbbd8b61b06a80e1eaf8cf4959c3d4ce8e711b65ebd0443bb0ebb13b", size = 288216466, upload-time = "2025-03-07T01:48:13.779Z" }, +] + +[[package]] +name = "nvidia-cusparselt-cu12" +version = "0.7.1" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/56/79/12978b96bd44274fe38b5dde5cfb660b1d114f70a65ef962bcbbed99b549/nvidia_cusparselt_cu12-0.7.1-py3-none-manylinux2014_x86_64.whl", hash = "sha256:f1bb701d6b930d5a7cea44c19ceb973311500847f81b634d802b7b539dc55623", size = 287193691, upload-time = "2025-02-26T00:15:44.104Z" }, +] + +[[package]] +name = "nvidia-nccl-cu12" +version = "2.27.3" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5c/5b/4e4fff7bad39adf89f735f2bc87248c81db71205b62bcc0d5ca5b606b3c3/nvidia_nccl_cu12-2.27.3-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:adf27ccf4238253e0b826bce3ff5fa532d65fc42322c8bfdfaf28024c0fbe039", size = 322364134, upload-time = "2025-06-03T21:58:04.013Z" }, +] + +[[package]] +name = "nvidia-nvjitlink-cu12" +version = "12.8.93" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f6/74/86a07f1d0f42998ca31312f998bd3b9a7eff7f52378f4f270c8679c77fb9/nvidia_nvjitlink_cu12-12.8.93-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", hash = "sha256:81ff63371a7ebd6e6451970684f916be2eab07321b73c9d244dc2b4da7f73b88", size = 39254836, upload-time = "2025-03-07T01:49:55.661Z" }, +] + +[[package]] +name = "nvidia-nvtx-cu12" +version = "12.8.90" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a2/eb/86626c1bbc2edb86323022371c39aa48df6fd8b0a1647bc274577f72e90b/nvidia_nvtx_cu12-12.8.90-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5b17e2001cc0d751a5bc2c6ec6d26ad95913324a4adb86788c944f8ce9ba441f", size = 89954, upload-time = "2025-03-07T01:42:44.131Z" }, +] + +[[package]] +name = "packaging" +version = "26.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d7/f1/e7a6dd94a8d4a5626c03e4e99c87f241ba9e350cd9e6d75123f992427270/packaging-26.2.tar.gz", hash = "sha256:ff452ff5a3e828ce110190feff1178bb1f2ea2281fa2075aadb987c2fb221661", size = 228134, upload-time = "2026-04-24T20:15:23.917Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/df/b2/87e62e8c3e2f4b32e5fe99e0b86d576da1312593b39f47d8ceef365e95ed/packaging-26.2-py3-none-any.whl", hash = "sha256:5fc45236b9446107ff2415ce77c807cee2862cb6fac22b8a73826d0693b0980e", size = 100195, upload-time = "2026-04-24T20:15:22.081Z" }, +] + +[[package]] +name = "pandas" +version = "3.0.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, + { name = "python-dateutil" }, + { name = "tzdata", marker = "sys_platform == 'emscripten' or sys_platform == 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/da/99/b342345300f13440fe9fe385c3c481e2d9a595ee3bab4d3219247ac94e9a/pandas-3.0.2.tar.gz", hash = "sha256:f4753e73e34c8d83221ba58f232433fca2748be8b18dbca02d242ed153945043", size = 4645855, upload-time = "2026-03-31T06:48:30.816Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/97/35/6411db530c618e0e0005187e35aa02ce60ae4c4c4d206964a2f978217c27/pandas-3.0.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a727a73cbdba2f7458dc82449e2315899d5140b449015d822f515749a46cbbe0", size = 10326926, upload-time = "2026-03-31T06:46:08.29Z" }, + { url = "https://files.pythonhosted.org/packages/c4/d3/b7da1d5d7dbdc5ef52ed7debd2b484313b832982266905315dad5a0bf0b1/pandas-3.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dbbd4aa20ca51e63b53bbde6a0fa4254b1aaabb74d2f542df7a7959feb1d760c", size = 9926987, upload-time = "2026-03-31T06:46:11.724Z" }, + { url = "https://files.pythonhosted.org/packages/52/77/9b1c2d6070b5dbe239a7bc889e21bfa58720793fb902d1e070695d87c6d0/pandas-3.0.2-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:339dda302bd8369dedeae979cb750e484d549b563c3f54f3922cb8ff4978c5eb", size = 10757067, upload-time = "2026-03-31T06:46:14.903Z" }, + { url = "https://files.pythonhosted.org/packages/20/17/ec40d981705654853726e7ac9aea9ddbb4a5d9cf54d8472222f4f3de06c2/pandas-3.0.2-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:61c2fd96d72b983a9891b2598f286befd4ad262161a609c92dc1652544b46b76", size = 11258787, upload-time = "2026-03-31T06:46:17.683Z" }, + { url = "https://files.pythonhosted.org/packages/90/e3/3f1126d43d3702ca8773871a81c9f15122a1f412342cc56284ffda5b1f70/pandas-3.0.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c934008c733b8bbea273ea308b73b3156f0181e5b72960790b09c18a2794fe1e", size = 11771616, upload-time = "2026-03-31T06:46:20.532Z" }, + { url = "https://files.pythonhosted.org/packages/2e/cf/0f4e268e1f5062e44a6bda9f925806721cd4c95c2b808a4c82ebe914f96b/pandas-3.0.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:60a80bb4feacbef5e1447a3f82c33209c8b7e07f28d805cfd1fb951e5cb443aa", size = 12337623, upload-time = "2026-03-31T06:46:23.754Z" }, + { url = "https://files.pythonhosted.org/packages/44/a0/97a6339859d4acb2536efb24feb6708e82f7d33b2ed7e036f2983fcced82/pandas-3.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:ed72cb3f45190874eb579c64fa92d9df74e98fd63e2be7f62bce5ace0ade61df", size = 9897372, upload-time = "2026-03-31T06:46:26.703Z" }, + { url = "https://files.pythonhosted.org/packages/8f/eb/781516b808a99ddf288143cec46b342b3016c3414d137da1fdc3290d8860/pandas-3.0.2-cp311-cp311-win_arm64.whl", hash = "sha256:f12b1a9e332c01e09510586f8ca9b108fd631fd656af82e452d7315ef6df5f9f", size = 9154922, upload-time = "2026-03-31T06:46:30.284Z" }, + { url = "https://files.pythonhosted.org/packages/f3/b0/c20bd4d6d3f736e6bd6b55794e9cd0a617b858eaad27c8f410ea05d953b7/pandas-3.0.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:232a70ebb568c0c4d2db4584f338c1577d81e3af63292208d615907b698a0f18", size = 10347921, upload-time = "2026-03-31T06:46:33.36Z" }, + { url = "https://files.pythonhosted.org/packages/35/d0/4831af68ce30cc2d03c697bea8450e3225a835ef497d0d70f31b8cdde965/pandas-3.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:970762605cff1ca0d3f71ed4f3a769ea8f85fc8e6348f6e110b8fea7e6eb5a14", size = 9888127, upload-time = "2026-03-31T06:46:36.253Z" }, + { url = "https://files.pythonhosted.org/packages/61/a9/16ea9346e1fc4a96e2896242d9bc674764fb9049b0044c0132502f7a771e/pandas-3.0.2-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:aff4e6f4d722e0652707d7bcb190c445fe58428500c6d16005b02401764b1b3d", size = 10399577, upload-time = "2026-03-31T06:46:39.224Z" }, + { url = "https://files.pythonhosted.org/packages/c4/a8/3a61a721472959ab0ce865ef05d10b0d6bfe27ce8801c99f33d4fa996e65/pandas-3.0.2-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ef8b27695c3d3dc78403c9a7d5e59a62d5464a7e1123b4e0042763f7104dc74f", size = 10880030, upload-time = "2026-03-31T06:46:42.412Z" }, + { url = "https://files.pythonhosted.org/packages/da/65/7225c0ea4d6ce9cb2160a7fb7f39804871049f016e74782e5dade4d14109/pandas-3.0.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f8d68083e49e16b84734eb1a4dcae4259a75c90fb6e2251ab9a00b61120c06ab", size = 11409468, upload-time = "2026-03-31T06:46:45.2Z" }, + { url = "https://files.pythonhosted.org/packages/fa/5b/46e7c76032639f2132359b5cf4c785dd8cf9aea5ea64699eac752f02b9db/pandas-3.0.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:32cc41f310ebd4a296d93515fcac312216adfedb1894e879303987b8f1e2b97d", size = 11936381, upload-time = "2026-03-31T06:46:48.293Z" }, + { url = "https://files.pythonhosted.org/packages/7b/8b/721a9cff6fa6a91b162eb51019c6243b82b3226c71bb6c8ef4a9bd65cbc6/pandas-3.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:a4785e1d6547d8427c5208b748ae2efb64659a21bd82bf440d4262d02bfa02a4", size = 9744993, upload-time = "2026-03-31T06:46:51.488Z" }, + { url = "https://files.pythonhosted.org/packages/d5/18/7f0bd34ae27b28159aa80f2a6799f47fda34f7fb938a76e20c7b7fe3b200/pandas-3.0.2-cp312-cp312-win_arm64.whl", hash = "sha256:08504503f7101300107ecdc8df73658e4347586db5cfdadabc1592e9d7e7a0fd", size = 9056118, upload-time = "2026-03-31T06:46:54.548Z" }, + { url = "https://files.pythonhosted.org/packages/bf/ca/3e639a1ea6fcd0617ca4e8ca45f62a74de33a56ae6cd552735470b22c8d3/pandas-3.0.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:b5918ba197c951dec132b0c5929a00c0bf05d5942f590d3c10a807f6e15a57d3", size = 10321105, upload-time = "2026-03-31T06:46:57.327Z" }, + { url = "https://files.pythonhosted.org/packages/0b/77/dbc82ff2fb0e63c6564356682bf201edff0ba16c98630d21a1fb312a8182/pandas-3.0.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d606a041c89c0a474a4702d532ab7e73a14fe35c8d427b972a625c8e46373668", size = 9864088, upload-time = "2026-03-31T06:46:59.935Z" }, + { url = "https://files.pythonhosted.org/packages/5c/2b/341f1b04bbca2e17e13cd3f08c215b70ef2c60c5356ef1e8c6857449edc7/pandas-3.0.2-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:710246ba0616e86891b58ab95f2495143bb2bc83ab6b06747c74216f583a6ac9", size = 10369066, upload-time = "2026-03-31T06:47:02.792Z" }, + { url = "https://files.pythonhosted.org/packages/12/c5/cbb1ffefb20a93d3f0e1fdcda699fb84976210d411b008f97f48bf6ce27e/pandas-3.0.2-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5d3cfe227c725b1f3dff4278b43d8c784656a42a9325b63af6b1492a8232209e", size = 10876780, upload-time = "2026-03-31T06:47:06.205Z" }, + { url = "https://files.pythonhosted.org/packages/98/fe/2249ae5e0a69bd0ddf17353d0a5d26611d70970111f5b3600cdc8be883e7/pandas-3.0.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c3b723df9087a9a9a840e263ebd9f88b64a12075d1bf2ea401a5a42f254f084d", size = 11375181, upload-time = "2026-03-31T06:47:09.383Z" }, + { url = "https://files.pythonhosted.org/packages/de/64/77a38b09e70b6464883b8d7584ab543e748e42c1b5d337a2ee088e0df741/pandas-3.0.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a3096110bf9eac0070b7208465f2740e2d8a670d5cb6530b5bb884eca495fd39", size = 11928899, upload-time = "2026-03-31T06:47:12.686Z" }, + { url = "https://files.pythonhosted.org/packages/5e/52/42855bf626868413f761addd574acc6195880ae247a5346477a4361c3acb/pandas-3.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:07a10f5c36512eead51bc578eb3354ad17578b22c013d89a796ab5eee90cd991", size = 9746574, upload-time = "2026-03-31T06:47:15.64Z" }, + { url = "https://files.pythonhosted.org/packages/88/39/21304ae06a25e8bf9fc820d69b29b2c495b2ae580d1e143146c309941760/pandas-3.0.2-cp313-cp313-win_arm64.whl", hash = "sha256:5fdbfa05931071aba28b408e59226186b01eb5e92bea2ab78b65863ca3228d84", size = 9047156, upload-time = "2026-03-31T06:47:18.595Z" }, + { url = "https://files.pythonhosted.org/packages/72/20/7defa8b27d4f330a903bb68eea33be07d839c5ea6bdda54174efcec0e1d2/pandas-3.0.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:dbc20dea3b9e27d0e66d74c42b2d0c1bed9c2ffe92adea33633e3bedeb5ac235", size = 10756238, upload-time = "2026-03-31T06:47:22.012Z" }, + { url = "https://files.pythonhosted.org/packages/e9/95/49433c14862c636afc0e9b2db83ff16b3ad92959364e52b2955e44c8e94c/pandas-3.0.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:b75c347eff42497452116ce05ef461822d97ce5b9ff8df6edacb8076092c855d", size = 10408520, upload-time = "2026-03-31T06:47:25.197Z" }, + { url = "https://files.pythonhosted.org/packages/3b/f8/462ad2b5881d6b8ec8e5f7ed2ea1893faa02290d13870a1600fe72ad8efc/pandas-3.0.2-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d1478075142e83a5571782ad007fb201ed074bdeac7ebcc8890c71442e96adf7", size = 10324154, upload-time = "2026-03-31T06:47:28.097Z" }, + { url = "https://files.pythonhosted.org/packages/0a/65/d1e69b649cbcddda23ad6e4c40ef935340f6f652a006e5cbc3555ac8adb3/pandas-3.0.2-cp313-cp313t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5880314e69e763d4c8b27937090de570f1fb8d027059a7ada3f7f8e98bdcb677", size = 10714449, upload-time = "2026-03-31T06:47:30.85Z" }, + { url = "https://files.pythonhosted.org/packages/47/a4/85b59bc65b8190ea3689882db6cdf32a5003c0ccd5a586c30fdcc3ffc4fc/pandas-3.0.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:b5329e26898896f06035241a626d7c335daa479b9bbc82be7c2742d048e41172", size = 11338475, upload-time = "2026-03-31T06:47:34.026Z" }, + { url = "https://files.pythonhosted.org/packages/1e/c4/bc6966c6e38e5d9478b935272d124d80a589511ed1612a5d21d36f664c68/pandas-3.0.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:81526c4afd31971f8b62671442a4b2b51e0aa9acc3819c9f0f12a28b6fcf85f1", size = 11786568, upload-time = "2026-03-31T06:47:36.941Z" }, + { url = "https://files.pythonhosted.org/packages/e8/74/09298ca9740beed1d3504e073d67e128aa07e5ca5ca2824b0c674c0b8676/pandas-3.0.2-cp313-cp313t-win_amd64.whl", hash = "sha256:7cadd7e9a44ec13b621aec60f9150e744cfc7a3dd32924a7e2f45edff31823b0", size = 10488652, upload-time = "2026-03-31T06:47:40.612Z" }, + { url = "https://files.pythonhosted.org/packages/bb/40/c6ea527147c73b24fc15c891c3fcffe9c019793119c5742b8784a062c7db/pandas-3.0.2-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:db0dbfd2a6cdf3770aa60464d50333d8f3d9165b2f2671bcc299b72de5a6677b", size = 10326084, upload-time = "2026-03-31T06:47:43.834Z" }, + { url = "https://files.pythonhosted.org/packages/95/25/bdb9326c3b5455f8d4d3549fce7abcf967259de146fe2cf7a82368141948/pandas-3.0.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:0555c5882688a39317179ab4a0ed41d3ebc8812ab14c69364bbee8fb7a3f6288", size = 9914146, upload-time = "2026-03-31T06:47:46.67Z" }, + { url = "https://files.pythonhosted.org/packages/8d/77/3a227ff3337aa376c60d288e1d61c5d097131d0ac71f954d90a8f369e422/pandas-3.0.2-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:01f31a546acd5574ef77fe199bc90b55527c225c20ccda6601cf6b0fd5ed597c", size = 10444081, upload-time = "2026-03-31T06:47:49.681Z" }, + { url = "https://files.pythonhosted.org/packages/15/88/3cdd54fa279341afa10acf8d2b503556b1375245dccc9315659f795dd2e9/pandas-3.0.2-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:deeca1b5a931fdf0c2212c8a659ade6d3b1edc21f0914ce71ef24456ca7a6535", size = 10897535, upload-time = "2026-03-31T06:47:53.033Z" }, + { url = "https://files.pythonhosted.org/packages/06/9d/98cc7a7624f7932e40f434299260e2917b090a579d75937cb8a57b9d2de3/pandas-3.0.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:0f48afd9bb13300ffb5a3316973324c787054ba6665cda0da3fbd67f451995db", size = 11446992, upload-time = "2026-03-31T06:47:56.193Z" }, + { url = "https://files.pythonhosted.org/packages/9a/cd/19ff605cc3760e80602e6826ddef2824d8e7050ed80f2e11c4b079741dc3/pandas-3.0.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:6c4d8458b97a35717b62469a4ea0e85abd5ed8687277f5ccfc67f8a5126f8c53", size = 11968257, upload-time = "2026-03-31T06:47:59.137Z" }, + { url = "https://files.pythonhosted.org/packages/db/60/aba6a38de456e7341285102bede27514795c1eaa353bc0e7638b6b785356/pandas-3.0.2-cp314-cp314-win_amd64.whl", hash = "sha256:b35d14bb5d8285d9494fe93815a9e9307c0876e10f1e8e89ac5b88f728ec8dcf", size = 9865893, upload-time = "2026-03-31T06:48:02.038Z" }, + { url = "https://files.pythonhosted.org/packages/08/71/e5ec979dd2e8a093dacb8864598c0ff59a0cee0bbcdc0bfec16a51684d4f/pandas-3.0.2-cp314-cp314-win_arm64.whl", hash = "sha256:63d141b56ef686f7f0d714cfb8de4e320475b86bf4b620aa0b7da89af8cbdbbb", size = 9188644, upload-time = "2026-03-31T06:48:05.045Z" }, + { url = "https://files.pythonhosted.org/packages/f1/6c/7b45d85db19cae1eb524f2418ceaa9d85965dcf7b764ed151386b7c540f0/pandas-3.0.2-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:140f0cffb1fa2524e874dde5b477d9defe10780d8e9e220d259b2c0874c89d9d", size = 10776246, upload-time = "2026-03-31T06:48:07.789Z" }, + { url = "https://files.pythonhosted.org/packages/a8/3e/7b00648b086c106e81766f25322b48aa8dfa95b55e621dbdf2fdd413a117/pandas-3.0.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ae37e833ff4fed0ba352f6bdd8b73ba3ab3256a85e54edfd1ab51ae40cca0af8", size = 10424801, upload-time = "2026-03-31T06:48:10.897Z" }, + { url = "https://files.pythonhosted.org/packages/da/6e/558dd09a71b53b4008e7fc8a98ec6d447e9bfb63cdaeea10e5eb9b2dabe8/pandas-3.0.2-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4d888a5c678a419a5bb41a2a93818e8ed9fd3172246555c0b37b7cc27027effd", size = 10345643, upload-time = "2026-03-31T06:48:13.7Z" }, + { url = "https://files.pythonhosted.org/packages/be/e3/921c93b4d9a280409451dc8d07b062b503bbec0531d2627e73a756e99a82/pandas-3.0.2-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b444dc64c079e84df91baa8bf613d58405645461cabca929d9178f2cd392398d", size = 10743641, upload-time = "2026-03-31T06:48:16.659Z" }, + { url = "https://files.pythonhosted.org/packages/56/ca/fd17286f24fa3b4d067965d8d5d7e14fe557dd4f979a0b068ac0deaf8228/pandas-3.0.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:4544c7a54920de8eeacaa1466a6b7268ecfbc9bc64ab4dbb89c6bbe94d5e0660", size = 11361993, upload-time = "2026-03-31T06:48:19.475Z" }, + { url = "https://files.pythonhosted.org/packages/e4/a5/2f6ed612056819de445a433ca1f2821ac3dab7f150d569a59e9cc105de1d/pandas-3.0.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:734be7551687c00fbd760dc0522ed974f82ad230d4a10f54bf51b80d44a08702", size = 11815274, upload-time = "2026-03-31T06:48:22.695Z" }, + { url = "https://files.pythonhosted.org/packages/00/2f/b622683e99ec3ce00b0854bac9e80868592c5b051733f2cf3a868e5fea26/pandas-3.0.2-cp314-cp314t-win_amd64.whl", hash = "sha256:57a07209bebcbcf768d2d13c9b78b852f9a15978dac41b9e6421a81ad4cdd276", size = 10888530, upload-time = "2026-03-31T06:48:25.806Z" }, + { url = "https://files.pythonhosted.org/packages/cb/2b/f8434233fab2bd66a02ec014febe4e5adced20e2693e0e90a07d118ed30e/pandas-3.0.2-cp314-cp314t-win_arm64.whl", hash = "sha256:5371b72c2d4d415d08765f32d689217a43227484e81b2305b52076e328f6f482", size = 9455341, upload-time = "2026-03-31T06:48:28.418Z" }, +] + +[[package]] +name = "parso" +version = "0.8.7" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/30/4b/90c937815137d43ce71ba043cd3566221e9df6b9c805f24b5d138c9d40a7/parso-0.8.7.tar.gz", hash = "sha256:eaaac4c9fdd5e9e8852dc778d2d7405897ec510f2a298071453e5e3a07914bb1", size = 401824, upload-time = "2026-05-01T23:13:02.138Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/99/5d/8268b644392ee874ee82a635cd0df1773de230bde356c38de28e298392cc/parso-0.8.7-py2.py3-none-any.whl", hash = "sha256:a8926eb2a1b915486941fdbd31e86a4baf88fe8c210f25f2f35ecec5b574ca1c", size = 107025, upload-time = "2026-05-01T23:12:58.867Z" }, +] + +[[package]] +name = "pexpect" +version = "4.9.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ptyprocess", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/42/92/cc564bf6381ff43ce1f4d06852fc19a2f11d180f23dc32d9588bee2f149d/pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f", size = 166450, upload-time = "2023-11-25T09:07:26.339Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/c3/059298687310d527a58bb01f3b1965787ee3b40dce76752eda8b44e9a2c5/pexpect-4.9.0-py2.py3-none-any.whl", hash = "sha256:7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523", size = 63772, upload-time = "2023-11-25T06:56:14.81Z" }, +] + +[[package]] +name = "pillow" +version = "12.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/8c/21/c2bcdd5906101a30244eaffc1b6e6ce71a31bd0742a01eb89e660ebfac2d/pillow-12.2.0.tar.gz", hash = "sha256:a830b1a40919539d07806aa58e1b114df53ddd43213d9c8b75847eee6c0182b5", size = 46987819, upload-time = "2026-04-01T14:46:17.687Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/68/e1/748f5663efe6edcfc4e74b2b93edfb9b8b99b67f21a854c3ae416500a2d9/pillow-12.2.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:8be29e59487a79f173507c30ddf57e733a357f67881430449bb32614075a40ab", size = 5354347, upload-time = "2026-04-01T14:42:44.255Z" }, + { url = "https://files.pythonhosted.org/packages/47/a1/d5ff69e747374c33a3b53b9f98cca7889fce1fd03d79cdc4e1bccc6c5a87/pillow-12.2.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:71cde9a1e1551df7d34a25462fc60325e8a11a82cc2e2f54578e5e9a1e153d65", size = 4695873, upload-time = "2026-04-01T14:42:46.452Z" }, + { url = "https://files.pythonhosted.org/packages/df/21/e3fbdf54408a973c7f7f89a23b2cb97a7ef30c61ab4142af31eee6aebc88/pillow-12.2.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f490f9368b6fc026f021db16d7ec2fbf7d89e2edb42e8ec09d2c60505f5729c7", size = 6280168, upload-time = "2026-04-01T14:42:49.228Z" }, + { url = "https://files.pythonhosted.org/packages/d3/f1/00b7278c7dd52b17ad4329153748f87b6756ec195ff786c2bdf12518337d/pillow-12.2.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8bd7903a5f2a4545f6fd5935c90058b89d30045568985a71c79f5fd6edf9b91e", size = 8088188, upload-time = "2026-04-01T14:42:51.735Z" }, + { url = "https://files.pythonhosted.org/packages/ad/cf/220a5994ef1b10e70e85748b75649d77d506499352be135a4989c957b701/pillow-12.2.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3997232e10d2920a68d25191392e3a4487d8183039e1c74c2297f00ed1c50705", size = 6394401, upload-time = "2026-04-01T14:42:54.343Z" }, + { url = "https://files.pythonhosted.org/packages/e9/bd/e51a61b1054f09437acfbc2ff9106c30d1eb76bc1453d428399946781253/pillow-12.2.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e74473c875d78b8e9d5da2a70f7099549f9eb37ded4e2f6a463e60125bccd176", size = 7079655, upload-time = "2026-04-01T14:42:56.954Z" }, + { url = "https://files.pythonhosted.org/packages/6b/3d/45132c57d5fb4b5744567c3817026480ac7fc3ce5d4c47902bc0e7f6f853/pillow-12.2.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:56a3f9c60a13133a98ecff6197af34d7824de9b7b38c3654861a725c970c197b", size = 6503105, upload-time = "2026-04-01T14:42:59.847Z" }, + { url = "https://files.pythonhosted.org/packages/7d/2e/9df2fc1e82097b1df3dce58dc43286aa01068e918c07574711fcc53e6fb4/pillow-12.2.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:90e6f81de50ad6b534cab6e5aef77ff6e37722b2f5d908686f4a5c9eba17a909", size = 7203402, upload-time = "2026-04-01T14:43:02.664Z" }, + { url = "https://files.pythonhosted.org/packages/bd/2e/2941e42858ebb67e50ae741473de81c2984e6eff7b397017623c676e2e8d/pillow-12.2.0-cp311-cp311-win32.whl", hash = "sha256:8c984051042858021a54926eb597d6ee3012393ce9c181814115df4c60b9a808", size = 6378149, upload-time = "2026-04-01T14:43:05.274Z" }, + { url = "https://files.pythonhosted.org/packages/69/42/836b6f3cd7f3e5fa10a1f1a5420447c17966044c8fbf589cc0452d5502db/pillow-12.2.0-cp311-cp311-win_amd64.whl", hash = "sha256:6e6b2a0c538fc200b38ff9eb6628228b77908c319a005815f2dde585a0664b60", size = 7082626, upload-time = "2026-04-01T14:43:08.557Z" }, + { url = "https://files.pythonhosted.org/packages/c2/88/549194b5d6f1f494b485e493edc6693c0a16f4ada488e5bd974ed1f42fad/pillow-12.2.0-cp311-cp311-win_arm64.whl", hash = "sha256:9a8a34cc89c67a65ea7437ce257cea81a9dad65b29805f3ecee8c8fe8ff25ffe", size = 2463531, upload-time = "2026-04-01T14:43:10.743Z" }, + { url = "https://files.pythonhosted.org/packages/58/be/7482c8a5ebebbc6470b3eb791812fff7d5e0216c2be3827b30b8bb6603ed/pillow-12.2.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2d192a155bbcec180f8564f693e6fd9bccff5a7af9b32e2e4bf8c9c69dbad6b5", size = 5308279, upload-time = "2026-04-01T14:43:13.246Z" }, + { url = "https://files.pythonhosted.org/packages/d8/95/0a351b9289c2b5cbde0bacd4a83ebc44023e835490a727b2a3bd60ddc0f4/pillow-12.2.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f3f40b3c5a968281fd507d519e444c35f0ff171237f4fdde090dd60699458421", size = 4695490, upload-time = "2026-04-01T14:43:15.584Z" }, + { url = "https://files.pythonhosted.org/packages/de/af/4e8e6869cbed569d43c416fad3dc4ecb944cb5d9492defaed89ddd6fe871/pillow-12.2.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:03e7e372d5240cc23e9f07deca4d775c0817bffc641b01e9c3af208dbd300987", size = 6284462, upload-time = "2026-04-01T14:43:18.268Z" }, + { url = "https://files.pythonhosted.org/packages/e9/9e/c05e19657fd57841e476be1ab46c4d501bffbadbafdc31a6d665f8b737b6/pillow-12.2.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b86024e52a1b269467a802258c25521e6d742349d760728092e1bc2d135b4d76", size = 8094744, upload-time = "2026-04-01T14:43:20.716Z" }, + { url = "https://files.pythonhosted.org/packages/2b/54/1789c455ed10176066b6e7e6da1b01e50e36f94ba584dc68d9eebfe9156d/pillow-12.2.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7371b48c4fa448d20d2714c9a1f775a81155050d383333e0a6c15b1123dda005", size = 6398371, upload-time = "2026-04-01T14:43:23.443Z" }, + { url = "https://files.pythonhosted.org/packages/43/e3/fdc657359e919462369869f1c9f0e973f353f9a9ee295a39b1fea8ee1a77/pillow-12.2.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:62f5409336adb0663b7caa0da5c7d9e7bdbaae9ce761d34669420c2a801b2780", size = 7087215, upload-time = "2026-04-01T14:43:26.758Z" }, + { url = "https://files.pythonhosted.org/packages/8b/f8/2f6825e441d5b1959d2ca5adec984210f1ec086435b0ed5f52c19b3b8a6e/pillow-12.2.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:01afa7cf67f74f09523699b4e88c73fb55c13346d212a59a2db1f86b0a63e8c5", size = 6509783, upload-time = "2026-04-01T14:43:29.56Z" }, + { url = "https://files.pythonhosted.org/packages/67/f9/029a27095ad20f854f9dba026b3ea6428548316e057e6fc3545409e86651/pillow-12.2.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fc3d34d4a8fbec3e88a79b92e5465e0f9b842b628675850d860b8bd300b159f5", size = 7212112, upload-time = "2026-04-01T14:43:32.091Z" }, + { url = "https://files.pythonhosted.org/packages/be/42/025cfe05d1be22dbfdb4f264fe9de1ccda83f66e4fc3aac94748e784af04/pillow-12.2.0-cp312-cp312-win32.whl", hash = "sha256:58f62cc0f00fd29e64b29f4fd923ffdb3859c9f9e6105bfc37ba1d08994e8940", size = 6378489, upload-time = "2026-04-01T14:43:34.601Z" }, + { url = "https://files.pythonhosted.org/packages/5d/7b/25a221d2c761c6a8ae21bfa3874988ff2583e19cf8a27bf2fee358df7942/pillow-12.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:7f84204dee22a783350679a0333981df803dac21a0190d706a50475e361c93f5", size = 7084129, upload-time = "2026-04-01T14:43:37.213Z" }, + { url = "https://files.pythonhosted.org/packages/10/e1/542a474affab20fd4a0f1836cb234e8493519da6b76899e30bcc5d990b8b/pillow-12.2.0-cp312-cp312-win_arm64.whl", hash = "sha256:af73337013e0b3b46f175e79492d96845b16126ddf79c438d7ea7ff27783a414", size = 2463612, upload-time = "2026-04-01T14:43:39.421Z" }, + { url = "https://files.pythonhosted.org/packages/4a/01/53d10cf0dbad820a8db274d259a37ba50b88b24768ddccec07355382d5ad/pillow-12.2.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:8297651f5b5679c19968abefd6bb84d95fe30ef712eb1b2d9b2d31ca61267f4c", size = 4100837, upload-time = "2026-04-01T14:43:41.506Z" }, + { url = "https://files.pythonhosted.org/packages/0f/98/f3a6657ecb698c937f6c76ee564882945f29b79bad496abcba0e84659ec5/pillow-12.2.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:50d8520da2a6ce0af445fa6d648c4273c3eeefbc32d7ce049f22e8b5c3daecc2", size = 4176528, upload-time = "2026-04-01T14:43:43.773Z" }, + { url = "https://files.pythonhosted.org/packages/69/bc/8986948f05e3ea490b8442ea1c1d4d990b24a7e43d8a51b2c7d8b1dced36/pillow-12.2.0-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:766cef22385fa1091258ad7e6216792b156dc16d8d3fa607e7545b2b72061f1c", size = 3640401, upload-time = "2026-04-01T14:43:45.87Z" }, + { url = "https://files.pythonhosted.org/packages/34/46/6c717baadcd62bc8ed51d238d521ab651eaa74838291bda1f86fe1f864c9/pillow-12.2.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5d2fd0fa6b5d9d1de415060363433f28da8b1526c1c129020435e186794b3795", size = 5308094, upload-time = "2026-04-01T14:43:48.438Z" }, + { url = "https://files.pythonhosted.org/packages/71/43/905a14a8b17fdb1ccb58d282454490662d2cb89a6bfec26af6d3520da5ec/pillow-12.2.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:56b25336f502b6ed02e889f4ece894a72612fe885889a6e8c4c80239ff6e5f5f", size = 4695402, upload-time = "2026-04-01T14:43:51.292Z" }, + { url = "https://files.pythonhosted.org/packages/73/dd/42107efcb777b16fa0393317eac58f5b5cf30e8392e266e76e51cff28c3d/pillow-12.2.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f1c943e96e85df3d3478f7b691f229887e143f81fedab9b20205349ab04d73ed", size = 6280005, upload-time = "2026-04-01T14:43:54.242Z" }, + { url = "https://files.pythonhosted.org/packages/a8/68/b93e09e5e8549019e61acf49f65b1a8530765a7f812c77a7461bca7e4494/pillow-12.2.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:03f6fab9219220f041c74aeaa2939ff0062bd5c364ba9ce037197f4c6d498cd9", size = 8090669, upload-time = "2026-04-01T14:43:57.335Z" }, + { url = "https://files.pythonhosted.org/packages/4b/6e/3ccb54ce8ec4ddd1accd2d89004308b7b0b21c4ac3d20fa70af4760a4330/pillow-12.2.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5cdfebd752ec52bf5bb4e35d9c64b40826bc5b40a13df7c3cda20a2c03a0f5ed", size = 6395194, upload-time = "2026-04-01T14:43:59.864Z" }, + { url = "https://files.pythonhosted.org/packages/67/ee/21d4e8536afd1a328f01b359b4d3997b291ffd35a237c877b331c1c3b71c/pillow-12.2.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:eedf4b74eda2b5a4b2b2fb4c006d6295df3bf29e459e198c90ea48e130dc75c3", size = 7082423, upload-time = "2026-04-01T14:44:02.74Z" }, + { url = "https://files.pythonhosted.org/packages/78/5f/e9f86ab0146464e8c133fe85df987ed9e77e08b29d8d35f9f9f4d6f917ba/pillow-12.2.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:00a2865911330191c0b818c59103b58a5e697cae67042366970a6b6f1b20b7f9", size = 6505667, upload-time = "2026-04-01T14:44:05.381Z" }, + { url = "https://files.pythonhosted.org/packages/ed/1e/409007f56a2fdce61584fd3acbc2bbc259857d555196cedcadc68c015c82/pillow-12.2.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1e1757442ed87f4912397c6d35a0db6a7b52592156014706f17658ff58bbf795", size = 7208580, upload-time = "2026-04-01T14:44:08.39Z" }, + { url = "https://files.pythonhosted.org/packages/23/c4/7349421080b12fb35414607b8871e9534546c128a11965fd4a7002ccfbee/pillow-12.2.0-cp313-cp313-win32.whl", hash = "sha256:144748b3af2d1b358d41286056d0003f47cb339b8c43a9ea42f5fea4d8c66b6e", size = 6375896, upload-time = "2026-04-01T14:44:11.197Z" }, + { url = "https://files.pythonhosted.org/packages/3f/82/8a3739a5e470b3c6cbb1d21d315800d8e16bff503d1f16b03a4ec3212786/pillow-12.2.0-cp313-cp313-win_amd64.whl", hash = "sha256:390ede346628ccc626e5730107cde16c42d3836b89662a115a921f28440e6a3b", size = 7081266, upload-time = "2026-04-01T14:44:13.947Z" }, + { url = "https://files.pythonhosted.org/packages/c3/25/f968f618a062574294592f668218f8af564830ccebdd1fa6200f598e65c5/pillow-12.2.0-cp313-cp313-win_arm64.whl", hash = "sha256:8023abc91fba39036dbce14a7d6535632f99c0b857807cbbbf21ecc9f4717f06", size = 2463508, upload-time = "2026-04-01T14:44:16.312Z" }, + { url = "https://files.pythonhosted.org/packages/4d/a4/b342930964e3cb4dce5038ae34b0eab4653334995336cd486c5a8c25a00c/pillow-12.2.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:042db20a421b9bafecc4b84a8b6e444686bd9d836c7fd24542db3e7df7baad9b", size = 5309927, upload-time = "2026-04-01T14:44:18.89Z" }, + { url = "https://files.pythonhosted.org/packages/9f/de/23198e0a65a9cf06123f5435a5d95cea62a635697f8f03d134d3f3a96151/pillow-12.2.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:dd025009355c926a84a612fecf58bb315a3f6814b17ead51a8e48d3823d9087f", size = 4698624, upload-time = "2026-04-01T14:44:21.115Z" }, + { url = "https://files.pythonhosted.org/packages/01/a6/1265e977f17d93ea37aa28aa81bad4fa597933879fac2520d24e021c8da3/pillow-12.2.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:88ddbc66737e277852913bd1e07c150cc7bb124539f94c4e2df5344494e0a612", size = 6321252, upload-time = "2026-04-01T14:44:23.663Z" }, + { url = "https://files.pythonhosted.org/packages/3c/83/5982eb4a285967baa70340320be9f88e57665a387e3a53a7f0db8231a0cd/pillow-12.2.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d362d1878f00c142b7e1a16e6e5e780f02be8195123f164edf7eddd911eefe7c", size = 8126550, upload-time = "2026-04-01T14:44:26.772Z" }, + { url = "https://files.pythonhosted.org/packages/4e/48/6ffc514adce69f6050d0753b1a18fd920fce8cac87620d5a31231b04bfc5/pillow-12.2.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2c727a6d53cb0018aadd8018c2b938376af27914a68a492f59dfcaca650d5eea", size = 6433114, upload-time = "2026-04-01T14:44:29.615Z" }, + { url = "https://files.pythonhosted.org/packages/36/a3/f9a77144231fb8d40ee27107b4463e205fa4677e2ca2548e14da5cf18dce/pillow-12.2.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:efd8c21c98c5cc60653bcb311bef2ce0401642b7ce9d09e03a7da87c878289d4", size = 7115667, upload-time = "2026-04-01T14:44:32.773Z" }, + { url = "https://files.pythonhosted.org/packages/c1/fc/ac4ee3041e7d5a565e1c4fd72a113f03b6394cc72ab7089d27608f8aaccb/pillow-12.2.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9f08483a632889536b8139663db60f6724bfcb443c96f1b18855860d7d5c0fd4", size = 6538966, upload-time = "2026-04-01T14:44:35.252Z" }, + { url = "https://files.pythonhosted.org/packages/c0/a8/27fb307055087f3668f6d0a8ccb636e7431d56ed0750e07a60547b1e083e/pillow-12.2.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:dac8d77255a37e81a2efcbd1fc05f1c15ee82200e6c240d7e127e25e365c39ea", size = 7238241, upload-time = "2026-04-01T14:44:37.875Z" }, + { url = "https://files.pythonhosted.org/packages/ad/4b/926ab182c07fccae9fcb120043464e1ff1564775ec8864f21a0ebce6ac25/pillow-12.2.0-cp313-cp313t-win32.whl", hash = "sha256:ee3120ae9dff32f121610bb08e4313be87e03efeadfc6c0d18f89127e24d0c24", size = 6379592, upload-time = "2026-04-01T14:44:40.336Z" }, + { url = "https://files.pythonhosted.org/packages/c2/c4/f9e476451a098181b30050cc4c9a3556b64c02cf6497ea421ac047e89e4b/pillow-12.2.0-cp313-cp313t-win_amd64.whl", hash = "sha256:325ca0528c6788d2a6c3d40e3568639398137346c3d6e66bb61db96b96511c98", size = 7085542, upload-time = "2026-04-01T14:44:43.251Z" }, + { url = "https://files.pythonhosted.org/packages/00/a4/285f12aeacbe2d6dc36c407dfbbe9e96d4a80b0fb710a337f6d2ad978c75/pillow-12.2.0-cp313-cp313t-win_arm64.whl", hash = "sha256:2e5a76d03a6c6dcef67edabda7a52494afa4035021a79c8558e14af25313d453", size = 2465765, upload-time = "2026-04-01T14:44:45.996Z" }, + { url = "https://files.pythonhosted.org/packages/bf/98/4595daa2365416a86cb0d495248a393dfc84e96d62ad080c8546256cb9c0/pillow-12.2.0-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:3adc9215e8be0448ed6e814966ecf3d9952f0ea40eb14e89a102b87f450660d8", size = 4100848, upload-time = "2026-04-01T14:44:48.48Z" }, + { url = "https://files.pythonhosted.org/packages/0b/79/40184d464cf89f6663e18dfcf7ca21aae2491fff1a16127681bf1fa9b8cf/pillow-12.2.0-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:6a9adfc6d24b10f89588096364cc726174118c62130c817c2837c60cf08a392b", size = 4176515, upload-time = "2026-04-01T14:44:51.353Z" }, + { url = "https://files.pythonhosted.org/packages/b0/63/703f86fd4c422a9cf722833670f4f71418fb116b2853ff7da722ea43f184/pillow-12.2.0-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:6a6e67ea2e6feda684ed370f9a1c52e7a243631c025ba42149a2cc5934dec295", size = 3640159, upload-time = "2026-04-01T14:44:53.588Z" }, + { url = "https://files.pythonhosted.org/packages/71/e0/fb22f797187d0be2270f83500aab851536101b254bfa1eae10795709d283/pillow-12.2.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:2bb4a8d594eacdfc59d9e5ad972aa8afdd48d584ffd5f13a937a664c3e7db0ed", size = 5312185, upload-time = "2026-04-01T14:44:56.039Z" }, + { url = "https://files.pythonhosted.org/packages/ba/8c/1a9e46228571de18f8e28f16fabdfc20212a5d019f3e3303452b3f0a580d/pillow-12.2.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:80b2da48193b2f33ed0c32c38140f9d3186583ce7d516526d462645fd98660ae", size = 4695386, upload-time = "2026-04-01T14:44:58.663Z" }, + { url = "https://files.pythonhosted.org/packages/70/62/98f6b7f0c88b9addd0e87c217ded307b36be024d4ff8869a812b241d1345/pillow-12.2.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:22db17c68434de69d8ecfc2fe821569195c0c373b25cccb9cbdacf2c6e53c601", size = 6280384, upload-time = "2026-04-01T14:45:01.5Z" }, + { url = "https://files.pythonhosted.org/packages/5e/03/688747d2e91cfbe0e64f316cd2e8005698f76ada3130d0194664174fa5de/pillow-12.2.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7b14cc0106cd9aecda615dd6903840a058b4700fcb817687d0ee4fc8b6e389be", size = 8091599, upload-time = "2026-04-01T14:45:04.5Z" }, + { url = "https://files.pythonhosted.org/packages/f6/35/577e22b936fcdd66537329b33af0b4ccfefaeabd8aec04b266528cddb33c/pillow-12.2.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8cbeb542b2ebc6fcdacabf8aca8c1a97c9b3ad3927d46b8723f9d4f033288a0f", size = 6396021, upload-time = "2026-04-01T14:45:07.117Z" }, + { url = "https://files.pythonhosted.org/packages/11/8d/d2532ad2a603ca2b93ad9f5135732124e57811d0168155852f37fbce2458/pillow-12.2.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4bfd07bc812fbd20395212969e41931001fd59eb55a60658b0e5710872e95286", size = 7083360, upload-time = "2026-04-01T14:45:09.763Z" }, + { url = "https://files.pythonhosted.org/packages/5e/26/d325f9f56c7e039034897e7380e9cc202b1e368bfd04d4cbe6a441f02885/pillow-12.2.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:9aba9a17b623ef750a4d11b742cbafffeb48a869821252b30ee21b5e91392c50", size = 6507628, upload-time = "2026-04-01T14:45:12.378Z" }, + { url = "https://files.pythonhosted.org/packages/5f/f7/769d5632ffb0988f1c5e7660b3e731e30f7f8ec4318e94d0a5d674eb65a4/pillow-12.2.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:deede7c263feb25dba4e82ea23058a235dcc2fe1f6021025dc71f2b618e26104", size = 7209321, upload-time = "2026-04-01T14:45:15.122Z" }, + { url = "https://files.pythonhosted.org/packages/6a/7a/c253e3c645cd47f1aceea6a8bacdba9991bf45bb7dfe927f7c893e89c93c/pillow-12.2.0-cp314-cp314-win32.whl", hash = "sha256:632ff19b2778e43162304d50da0181ce24ac5bb8180122cbe1bf4673428328c7", size = 6479723, upload-time = "2026-04-01T14:45:17.797Z" }, + { url = "https://files.pythonhosted.org/packages/cd/8b/601e6566b957ca50e28725cb6c355c59c2c8609751efbecd980db44e0349/pillow-12.2.0-cp314-cp314-win_amd64.whl", hash = "sha256:4e6c62e9d237e9b65fac06857d511e90d8461a32adcc1b9065ea0c0fa3a28150", size = 7217400, upload-time = "2026-04-01T14:45:20.529Z" }, + { url = "https://files.pythonhosted.org/packages/d6/94/220e46c73065c3e2951bb91c11a1fb636c8c9ad427ac3ce7d7f3359b9b2f/pillow-12.2.0-cp314-cp314-win_arm64.whl", hash = "sha256:b1c1fbd8a5a1af3412a0810d060a78b5136ec0836c8a4ef9aa11807f2a22f4e1", size = 2554835, upload-time = "2026-04-01T14:45:23.162Z" }, + { url = "https://files.pythonhosted.org/packages/b6/ab/1b426a3974cb0e7da5c29ccff4807871d48110933a57207b5a676cccc155/pillow-12.2.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:57850958fe9c751670e49b2cecf6294acc99e562531f4bd317fa5ddee2068463", size = 5314225, upload-time = "2026-04-01T14:45:25.637Z" }, + { url = "https://files.pythonhosted.org/packages/19/1e/dce46f371be2438eecfee2a1960ee2a243bbe5e961890146d2dee1ff0f12/pillow-12.2.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:d5d38f1411c0ed9f97bcb49b7bd59b6b7c314e0e27420e34d99d844b9ce3b6f3", size = 4698541, upload-time = "2026-04-01T14:45:28.355Z" }, + { url = "https://files.pythonhosted.org/packages/55/c3/7fbecf70adb3a0c33b77a300dc52e424dc22ad8cdc06557a2e49523b703d/pillow-12.2.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5c0a9f29ca8e79f09de89293f82fc9b0270bb4af1d58bc98f540cc4aedf03166", size = 6322251, upload-time = "2026-04-01T14:45:30.924Z" }, + { url = "https://files.pythonhosted.org/packages/1c/3c/7fbc17cfb7e4fe0ef1642e0abc17fc6c94c9f7a16be41498e12e2ba60408/pillow-12.2.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1610dd6c61621ae1cf811bef44d77e149ce3f7b95afe66a4512f8c59f25d9ebe", size = 8127807, upload-time = "2026-04-01T14:45:33.908Z" }, + { url = "https://files.pythonhosted.org/packages/ff/c3/a8ae14d6defd2e448493ff512fae903b1e9bd40b72efb6ec55ce0048c8ce/pillow-12.2.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0a34329707af4f73cf1782a36cd2289c0368880654a2c11f027bcee9052d35dd", size = 6433935, upload-time = "2026-04-01T14:45:36.623Z" }, + { url = "https://files.pythonhosted.org/packages/6e/32/2880fb3a074847ac159d8f902cb43278a61e85f681661e7419e6596803ed/pillow-12.2.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8e9c4f5b3c546fa3458a29ab22646c1c6c787ea8f5ef51300e5a60300736905e", size = 7116720, upload-time = "2026-04-01T14:45:39.258Z" }, + { url = "https://files.pythonhosted.org/packages/46/87/495cc9c30e0129501643f24d320076f4cc54f718341df18cc70ec94c44e1/pillow-12.2.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:fb043ee2f06b41473269765c2feae53fc2e2fbf96e5e22ca94fb5ad677856f06", size = 6540498, upload-time = "2026-04-01T14:45:41.879Z" }, + { url = "https://files.pythonhosted.org/packages/18/53/773f5edca692009d883a72211b60fdaf8871cbef075eaa9d577f0a2f989e/pillow-12.2.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f278f034eb75b4e8a13a54a876cc4a5ab39173d2cdd93a638e1b467fc545ac43", size = 7239413, upload-time = "2026-04-01T14:45:44.705Z" }, + { url = "https://files.pythonhosted.org/packages/c9/e4/4b64a97d71b2a83158134abbb2f5bd3f8a2ea691361282f010998f339ec7/pillow-12.2.0-cp314-cp314t-win32.whl", hash = "sha256:6bb77b2dcb06b20f9f4b4a8454caa581cd4dd0643a08bacf821216a16d9c8354", size = 6482084, upload-time = "2026-04-01T14:45:47.568Z" }, + { url = "https://files.pythonhosted.org/packages/ba/13/306d275efd3a3453f72114b7431c877d10b1154014c1ebbedd067770d629/pillow-12.2.0-cp314-cp314t-win_amd64.whl", hash = "sha256:6562ace0d3fb5f20ed7290f1f929cae41b25ae29528f2af1722966a0a02e2aa1", size = 7225152, upload-time = "2026-04-01T14:45:50.032Z" }, + { url = "https://files.pythonhosted.org/packages/ff/6e/cf826fae916b8658848d7b9f38d88da6396895c676e8086fc0988073aaf8/pillow-12.2.0-cp314-cp314t-win_arm64.whl", hash = "sha256:aa88ccfe4e32d362816319ed727a004423aab09c5cea43c01a4b435643fa34eb", size = 2556579, upload-time = "2026-04-01T14:45:52.529Z" }, + { url = "https://files.pythonhosted.org/packages/4e/b7/2437044fb910f499610356d1352e3423753c98e34f915252aafecc64889f/pillow-12.2.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:0538bd5e05efec03ae613fd89c4ce0368ecd2ba239cc25b9f9be7ed426b0af1f", size = 5273969, upload-time = "2026-04-01T14:45:55.538Z" }, + { url = "https://files.pythonhosted.org/packages/f6/f4/8316e31de11b780f4ac08ef3654a75555e624a98db1056ecb2122d008d5a/pillow-12.2.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:394167b21da716608eac917c60aa9b969421b5dcbbe02ae7f013e7b85811c69d", size = 4659674, upload-time = "2026-04-01T14:45:58.093Z" }, + { url = "https://files.pythonhosted.org/packages/d4/37/664fca7201f8bb2aa1d20e2c3d5564a62e6ae5111741966c8319ca802361/pillow-12.2.0-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5d04bfa02cc2d23b497d1e90a0f927070043f6cbf303e738300532379a4b4e0f", size = 5288479, upload-time = "2026-04-01T14:46:01.141Z" }, + { url = "https://files.pythonhosted.org/packages/49/62/5b0ed78fce87346be7a5cfcfaaad91f6a1f98c26f86bdbafa2066c647ef6/pillow-12.2.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0c838a5125cee37e68edec915651521191cef1e6aa336b855f495766e77a366e", size = 7032230, upload-time = "2026-04-01T14:46:03.874Z" }, + { url = "https://files.pythonhosted.org/packages/c3/28/ec0fc38107fc32536908034e990c47914c57cd7c5a3ece4d8d8f7ffd7e27/pillow-12.2.0-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4a6c9fa44005fa37a91ebfc95d081e8079757d2e904b27103f4f5fa6f0bf78c0", size = 5355404, upload-time = "2026-04-01T14:46:06.33Z" }, + { url = "https://files.pythonhosted.org/packages/5e/8b/51b0eddcfa2180d60e41f06bd6d0a62202b20b59c68f5a132e615b75aecf/pillow-12.2.0-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:25373b66e0dd5905ed63fa3cae13c82fbddf3079f2c8bf15c6fb6a35586324c1", size = 6002215, upload-time = "2026-04-01T14:46:08.83Z" }, + { url = "https://files.pythonhosted.org/packages/bc/60/5382c03e1970de634027cee8e1b7d39776b778b81812aaf45b694dfe9e28/pillow-12.2.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:bfa9c230d2fe991bed5318a5f119bd6780cda2915cca595393649fc118ab895e", size = 7080946, upload-time = "2026-04-01T14:46:11.734Z" }, +] + +[[package]] +name = "platformdirs" +version = "4.9.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/9f/4a/0883b8e3802965322523f0b200ecf33d31f10991d0401162f4b23c698b42/platformdirs-4.9.6.tar.gz", hash = "sha256:3bfa75b0ad0db84096ae777218481852c0ebc6c727b3168c1b9e0118e458cf0a", size = 29400, upload-time = "2026-04-09T00:04:10.812Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/75/a6/a0a304dc33b49145b21f4808d763822111e67d1c3a32b524a1baf947b6e1/platformdirs-4.9.6-py3-none-any.whl", hash = "sha256:e61adb1d5e5cb3441b4b7710bea7e4c12250ca49439228cc1021c00dcfac0917", size = 21348, upload-time = "2026-04-09T00:04:09.463Z" }, +] + +[[package]] +name = "pooch" +version = "1.9.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "packaging" }, + { name = "platformdirs" }, + { name = "requests" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/83/43/85ef45e8b36c6a48546af7b266592dc32d7f67837a6514d111bced6d7d75/pooch-1.9.0.tar.gz", hash = "sha256:de46729579b9857ffd3e741987a2f6d5e0e03219892c167c6578c0091fb511ed", size = 61788, upload-time = "2026-01-30T19:15:09.649Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2a/2d/d4bf65e47cea8ff2c794a600c4fd1273a7902f268757c531e0ee9f18aa58/pooch-1.9.0-py3-none-any.whl", hash = "sha256:f265597baa9f760d25ceb29d0beb8186c243d6607b0f60b83ecf14078dbc703b", size = 67175, upload-time = "2026-01-30T19:15:08.36Z" }, +] + +[[package]] +name = "primepy" +version = "1.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/35/77/0cfa1b4697cfb5336f3a96e8bc73327f64610be3a64c97275f1801afb395/primePy-1.3.tar.gz", hash = "sha256:25fd7e25344b0789a5984c75d89f054fcf1f180bef20c998e4befbac92de4669", size = 3914, upload-time = "2018-05-29T17:18:18.683Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/74/c1/bb7e334135859c3a92ec399bc89293ea73f28e815e35b43929c8db6af030/primePy-1.3-py3-none-any.whl", hash = "sha256:5ed443718765be9bf7e2ff4c56cdff71b42140a15b39d054f9d99f0009e2317a", size = 4040, upload-time = "2018-05-29T17:18:17.53Z" }, +] + +[[package]] +name = "prompt-toolkit" +version = "3.0.52" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "wcwidth" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a1/96/06e01a7b38dce6fe1db213e061a4602dd6032a8a97ef6c1a862537732421/prompt_toolkit-3.0.52.tar.gz", hash = "sha256:28cde192929c8e7321de85de1ddbe736f1375148b02f2e17edd840042b1be855", size = 434198, upload-time = "2025-08-27T15:24:02.057Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/84/03/0d3ce49e2505ae70cf43bc5bb3033955d2fc9f932163e84dc0779cc47f48/prompt_toolkit-3.0.52-py3-none-any.whl", hash = "sha256:9aac639a3bbd33284347de5ad8d68ecc044b91a762dc39b7c21095fcd6a19955", size = 391431, upload-time = "2025-08-27T15:23:59.498Z" }, +] + +[[package]] +name = "protobuf" +version = "7.34.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6b/6b/a0e95cad1ad7cc3f2c6821fcab91671bd5b78bd42afb357bb4765f29bc41/protobuf-7.34.1.tar.gz", hash = "sha256:9ce42245e704cc5027be797c1db1eb93184d44d1cdd71811fb2d9b25ad541280", size = 454708, upload-time = "2026-03-20T17:34:47.036Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ec/11/3325d41e6ee15bf1125654301211247b042563bcc898784351252549a8ad/protobuf-7.34.1-cp310-abi3-macosx_10_9_universal2.whl", hash = "sha256:d8b2cc79c4d8f62b293ad9b11ec3aebce9af481fa73e64556969f7345ebf9fc7", size = 429247, upload-time = "2026-03-20T17:34:37.024Z" }, + { url = "https://files.pythonhosted.org/packages/eb/9d/aa69df2724ff63efa6f72307b483ce0827f4347cc6d6df24b59e26659fef/protobuf-7.34.1-cp310-abi3-manylinux2014_aarch64.whl", hash = "sha256:5185e0e948d07abe94bb76ec9b8416b604cfe5da6f871d67aad30cbf24c3110b", size = 325753, upload-time = "2026-03-20T17:34:38.751Z" }, + { url = "https://files.pythonhosted.org/packages/92/e8/d174c91fd48e50101943f042b09af9029064810b734e4160bbe282fa1caa/protobuf-7.34.1-cp310-abi3-manylinux2014_s390x.whl", hash = "sha256:403b093a6e28a960372b44e5eb081775c9b056e816a8029c61231743d63f881a", size = 340198, upload-time = "2026-03-20T17:34:39.871Z" }, + { url = "https://files.pythonhosted.org/packages/53/1b/3b431694a4dc6d37b9f653f0c64b0a0d9ec074ee810710c0c3da21d67ba7/protobuf-7.34.1-cp310-abi3-manylinux2014_x86_64.whl", hash = "sha256:8ff40ce8cd688f7265326b38d5a1bed9bfdf5e6723d49961432f83e21d5713e4", size = 324267, upload-time = "2026-03-20T17:34:41.1Z" }, + { url = "https://files.pythonhosted.org/packages/85/29/64de04a0ac142fb685fd09999bc3d337943fb386f3a0ec57f92fd8203f97/protobuf-7.34.1-cp310-abi3-win32.whl", hash = "sha256:34b84ce27680df7cca9f231043ada0daa55d0c44a2ddfaa58ec1d0d89d8bf60a", size = 426628, upload-time = "2026-03-20T17:34:42.536Z" }, + { url = "https://files.pythonhosted.org/packages/4d/87/cb5e585192a22b8bd457df5a2c16a75ea0db9674c3a0a39fc9347d84e075/protobuf-7.34.1-cp310-abi3-win_amd64.whl", hash = "sha256:e97b55646e6ce5cbb0954a8c28cd39a5869b59090dfaa7df4598a7fba869468c", size = 437901, upload-time = "2026-03-20T17:34:44.112Z" }, + { url = "https://files.pythonhosted.org/packages/88/95/608f665226bca68b736b79e457fded9a2a38c4f4379a4a7614303d9db3bc/protobuf-7.34.1-py3-none-any.whl", hash = "sha256:bb3812cd53aefea2b028ef42bd780f5b96407247f20c6ef7c679807e9d188f11", size = 170715, upload-time = "2026-03-20T17:34:45.384Z" }, +] + +[[package]] +name = "psutil" +version = "7.2.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/aa/c6/d1ddf4abb55e93cebc4f2ed8b5d6dbad109ecb8d63748dd2b20ab5e57ebe/psutil-7.2.2.tar.gz", hash = "sha256:0746f5f8d406af344fd547f1c8daa5f5c33dbc293bb8d6a16d80b4bb88f59372", size = 493740, upload-time = "2026-01-28T18:14:54.428Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/51/08/510cbdb69c25a96f4ae523f733cdc963ae654904e8db864c07585ef99875/psutil-7.2.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:2edccc433cbfa046b980b0df0171cd25bcaeb3a68fe9022db0979e7aa74a826b", size = 130595, upload-time = "2026-01-28T18:14:57.293Z" }, + { url = "https://files.pythonhosted.org/packages/d6/f5/97baea3fe7a5a9af7436301f85490905379b1c6f2dd51fe3ecf24b4c5fbf/psutil-7.2.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e78c8603dcd9a04c7364f1a3e670cea95d51ee865e4efb3556a3a63adef958ea", size = 131082, upload-time = "2026-01-28T18:14:59.732Z" }, + { url = "https://files.pythonhosted.org/packages/37/d6/246513fbf9fa174af531f28412297dd05241d97a75911ac8febefa1a53c6/psutil-7.2.2-cp313-cp313t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1a571f2330c966c62aeda00dd24620425d4b0cc86881c89861fbc04549e5dc63", size = 181476, upload-time = "2026-01-28T18:15:01.884Z" }, + { url = "https://files.pythonhosted.org/packages/b8/b5/9182c9af3836cca61696dabe4fd1304e17bc56cb62f17439e1154f225dd3/psutil-7.2.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:917e891983ca3c1887b4ef36447b1e0873e70c933afc831c6b6da078ba474312", size = 184062, upload-time = "2026-01-28T18:15:04.436Z" }, + { url = "https://files.pythonhosted.org/packages/16/ba/0756dca669f5a9300d0cbcbfae9a4c30e446dfc7440ffe43ded5724bfd93/psutil-7.2.2-cp313-cp313t-win_amd64.whl", hash = "sha256:ab486563df44c17f5173621c7b198955bd6b613fb87c71c161f827d3fb149a9b", size = 139893, upload-time = "2026-01-28T18:15:06.378Z" }, + { url = "https://files.pythonhosted.org/packages/1c/61/8fa0e26f33623b49949346de05ec1ddaad02ed8ba64af45f40a147dbfa97/psutil-7.2.2-cp313-cp313t-win_arm64.whl", hash = "sha256:ae0aefdd8796a7737eccea863f80f81e468a1e4cf14d926bd9b6f5f2d5f90ca9", size = 135589, upload-time = "2026-01-28T18:15:08.03Z" }, + { url = "https://files.pythonhosted.org/packages/81/69/ef179ab5ca24f32acc1dac0c247fd6a13b501fd5534dbae0e05a1c48b66d/psutil-7.2.2-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:eed63d3b4d62449571547b60578c5b2c4bcccc5387148db46e0c2313dad0ee00", size = 130664, upload-time = "2026-01-28T18:15:09.469Z" }, + { url = "https://files.pythonhosted.org/packages/7b/64/665248b557a236d3fa9efc378d60d95ef56dd0a490c2cd37dafc7660d4a9/psutil-7.2.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7b6d09433a10592ce39b13d7be5a54fbac1d1228ed29abc880fb23df7cb694c9", size = 131087, upload-time = "2026-01-28T18:15:11.724Z" }, + { url = "https://files.pythonhosted.org/packages/d5/2e/e6782744700d6759ebce3043dcfa661fb61e2fb752b91cdeae9af12c2178/psutil-7.2.2-cp314-cp314t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1fa4ecf83bcdf6e6c8f4449aff98eefb5d0604bf88cb883d7da3d8d2d909546a", size = 182383, upload-time = "2026-01-28T18:15:13.445Z" }, + { url = "https://files.pythonhosted.org/packages/57/49/0a41cefd10cb7505cdc04dab3eacf24c0c2cb158a998b8c7b1d27ee2c1f5/psutil-7.2.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e452c464a02e7dc7822a05d25db4cde564444a67e58539a00f929c51eddda0cf", size = 185210, upload-time = "2026-01-28T18:15:16.002Z" }, + { url = "https://files.pythonhosted.org/packages/dd/2c/ff9bfb544f283ba5f83ba725a3c5fec6d6b10b8f27ac1dc641c473dc390d/psutil-7.2.2-cp314-cp314t-win_amd64.whl", hash = "sha256:c7663d4e37f13e884d13994247449e9f8f574bc4655d509c3b95e9ec9e2b9dc1", size = 141228, upload-time = "2026-01-28T18:15:18.385Z" }, + { url = "https://files.pythonhosted.org/packages/f2/fc/f8d9c31db14fcec13748d373e668bc3bed94d9077dbc17fb0eebc073233c/psutil-7.2.2-cp314-cp314t-win_arm64.whl", hash = "sha256:11fe5a4f613759764e79c65cf11ebdf26e33d6dd34336f8a337aa2996d71c841", size = 136284, upload-time = "2026-01-28T18:15:19.912Z" }, + { url = "https://files.pythonhosted.org/packages/e7/36/5ee6e05c9bd427237b11b3937ad82bb8ad2752d72c6969314590dd0c2f6e/psutil-7.2.2-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:ed0cace939114f62738d808fdcecd4c869222507e266e574799e9c0faa17d486", size = 129090, upload-time = "2026-01-28T18:15:22.168Z" }, + { url = "https://files.pythonhosted.org/packages/80/c4/f5af4c1ca8c1eeb2e92ccca14ce8effdeec651d5ab6053c589b074eda6e1/psutil-7.2.2-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:1a7b04c10f32cc88ab39cbf606e117fd74721c831c98a27dc04578deb0c16979", size = 129859, upload-time = "2026-01-28T18:15:23.795Z" }, + { url = "https://files.pythonhosted.org/packages/b5/70/5d8df3b09e25bce090399cf48e452d25c935ab72dad19406c77f4e828045/psutil-7.2.2-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:076a2d2f923fd4821644f5ba89f059523da90dc9014e85f8e45a5774ca5bc6f9", size = 155560, upload-time = "2026-01-28T18:15:25.976Z" }, + { url = "https://files.pythonhosted.org/packages/63/65/37648c0c158dc222aba51c089eb3bdfa238e621674dc42d48706e639204f/psutil-7.2.2-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b0726cecd84f9474419d67252add4ac0cd9811b04d61123054b9fb6f57df6e9e", size = 156997, upload-time = "2026-01-28T18:15:27.794Z" }, + { url = "https://files.pythonhosted.org/packages/8e/13/125093eadae863ce03c6ffdbae9929430d116a246ef69866dad94da3bfbc/psutil-7.2.2-cp36-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:fd04ef36b4a6d599bbdb225dd1d3f51e00105f6d48a28f006da7f9822f2606d8", size = 148972, upload-time = "2026-01-28T18:15:29.342Z" }, + { url = "https://files.pythonhosted.org/packages/04/78/0acd37ca84ce3ddffaa92ef0f571e073faa6d8ff1f0559ab1272188ea2be/psutil-7.2.2-cp36-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:b58fabe35e80b264a4e3bb23e6b96f9e45a3df7fb7eed419ac0e5947c61e47cc", size = 148266, upload-time = "2026-01-28T18:15:31.597Z" }, + { url = "https://files.pythonhosted.org/packages/b4/90/e2159492b5426be0c1fef7acba807a03511f97c5f86b3caeda6ad92351a7/psutil-7.2.2-cp37-abi3-win_amd64.whl", hash = "sha256:eb7e81434c8d223ec4a219b5fc1c47d0417b12be7ea866e24fb5ad6e84b3d988", size = 137737, upload-time = "2026-01-28T18:15:33.849Z" }, + { url = "https://files.pythonhosted.org/packages/8c/c7/7bb2e321574b10df20cbde462a94e2b71d05f9bbda251ef27d104668306a/psutil-7.2.2-cp37-abi3-win_arm64.whl", hash = "sha256:8c233660f575a5a89e6d4cb65d9f938126312bca76d8fe087b947b3a1aaac9ee", size = 134617, upload-time = "2026-01-28T18:15:36.514Z" }, +] + +[[package]] +name = "ptyprocess" +version = "0.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/20/e5/16ff212c1e452235a90aeb09066144d0c5a6a8c0834397e03f5224495c4e/ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220", size = 70762, upload-time = "2020-12-28T15:15:30.155Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/22/a6/858897256d0deac81a172289110f31629fc4cee19b6f01283303e18c8db3/ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35", size = 13993, upload-time = "2020-12-28T15:15:28.35Z" }, +] + +[[package]] +name = "pure-eval" +version = "0.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cd/05/0a34433a064256a578f1783a10da6df098ceaa4a57bbeaa96a6c0352786b/pure_eval-0.2.3.tar.gz", hash = "sha256:5f4e983f40564c576c7c8635ae88db5956bb2229d7e9237d03b3c0b0190eaf42", size = 19752, upload-time = "2024-07-21T12:58:21.801Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8e/37/efad0257dc6e593a18957422533ff0f87ede7c9c6ea010a2177d738fb82f/pure_eval-0.2.3-py3-none-any.whl", hash = "sha256:1db8e35b67b3d218d818ae653e27f06c3aa420901fa7b081ca98cbedc874e0d0", size = 11842, upload-time = "2024-07-21T12:58:20.04Z" }, +] + +[[package]] +name = "pycparser" +version = "3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1b/7d/92392ff7815c21062bea51aa7b87d45576f649f16458d78b7cf94b9ab2e6/pycparser-3.0.tar.gz", hash = "sha256:600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29", size = 103492, upload-time = "2026-01-21T14:26:51.89Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", hash = "sha256:b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992", size = 48172, upload-time = "2026-01-21T14:26:50.693Z" }, +] + +[[package]] +name = "pydub" +version = "0.25.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fe/9a/e6bca0eed82db26562c73b5076539a4a08d3cffd19c3cc5913a3e61145fd/pydub-0.25.1.tar.gz", hash = "sha256:980a33ce9949cab2a569606b65674d748ecbca4f0796887fd6f46173a7b0d30f", size = 38326, upload-time = "2021-03-10T02:09:54.659Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a6/53/d78dc063216e62fc55f6b2eebb447f6a4b0a59f55c8406376f76bf959b08/pydub-0.25.1-py2.py3-none-any.whl", hash = "sha256:65617e33033874b59d87db603aa1ed450633288aefead953b30bded59cb599a6", size = 32327, upload-time = "2021-03-10T02:09:53.503Z" }, +] + +[[package]] +name = "pygments" +version = "2.20.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c3/b2/bc9c9196916376152d655522fdcebac55e66de6603a76a02bca1b6414f6c/pygments-2.20.0.tar.gz", hash = "sha256:6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f", size = 4955991, upload-time = "2026-03-29T13:29:33.898Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", hash = "sha256:81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176", size = 1231151, upload-time = "2026-03-29T13:29:30.038Z" }, +] + +[[package]] +name = "pyparsing" +version = "3.3.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f3/91/9c6ee907786a473bf81c5f53cf703ba0957b23ab84c264080fb5a450416f/pyparsing-3.3.2.tar.gz", hash = "sha256:c777f4d763f140633dcb6d8a3eda953bf7a214dc4eff598413c070bcdc117cbc", size = 6851574, upload-time = "2026-01-21T03:57:59.36Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/10/bd/c038d7cc38edc1aa5bf91ab8068b63d4308c66c4c8bb3cbba7dfbc049f9c/pyparsing-3.3.2-py3-none-any.whl", hash = "sha256:850ba148bd908d7e2411587e247a1e4f0327839c40e2e5e6d05a007ecc69911d", size = 122781, upload-time = "2026-01-21T03:57:55.912Z" }, +] + +[[package]] +name = "pyrubberband" +version = "0.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, + { name = "soundfile" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b4/5f/e4e737a216c9327931cdee8ca2194c916ee8a1748a8c7c80d5d5a8368d81/pyrubberband-0.4.0.tar.gz", hash = "sha256:74707ec8ca6c6234e84ad2d9a4aa5c08a62fcfd83da011d535d41f4388ac49f7", size = 6416, upload-time = "2024-09-30T17:53:00.796Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d8/88/238aa67e353012d8dd999372aedada3f627bc9895d5d2a5305e7ffb1affd/pyrubberband-0.4.0-py3-none-any.whl", hash = "sha256:0a803191f38debbbdfd9135939c1f75999e98511f19867d357b84e191f139ca9", size = 4798, upload-time = "2024-09-30T17:52:59.621Z" }, +] + +[[package]] +name = "python-dateutil" +version = "2.9.0.post0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "six" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, upload-time = "2024-03-01T18:36:20.211Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload-time = "2024-03-01T18:36:18.57Z" }, +] + +[[package]] +name = "requests" +version = "2.33.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "charset-normalizer" }, + { name = "idna" }, + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/5f/a4/98b9c7c6428a668bf7e42ebb7c79d576a1c3c1e3ae2d47e674b468388871/requests-2.33.1.tar.gz", hash = "sha256:18817f8c57c6263968bc123d237e3b8b08ac046f5456bd1e307ee8f4250d3517", size = 134120, upload-time = "2026-03-30T16:09:15.531Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d7/8e/7540e8a2036f79a125c1d2ebadf69ed7901608859186c856fa0388ef4197/requests-2.33.1-py3-none-any.whl", hash = "sha256:4e6d1ef462f3626a1f0a0a9c42dd93c63bad33f9f1c1937509b8c5c8718ab56a", size = 64947, upload-time = "2026-03-30T16:09:13.83Z" }, +] + +[[package]] +name = "scikit-learn" +version = "1.8.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "joblib" }, + { name = "numpy" }, + { name = "scipy" }, + { name = "threadpoolctl" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0e/d4/40988bf3b8e34feec1d0e6a051446b1f66225f8529b9309becaeef62b6c4/scikit_learn-1.8.0.tar.gz", hash = "sha256:9bccbb3b40e3de10351f8f5068e105d0f4083b1a65fa07b6634fbc401a6287fd", size = 7335585, upload-time = "2025-12-10T07:08:53.618Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c9/92/53ea2181da8ac6bf27170191028aee7251f8f841f8d3edbfdcaf2008fde9/scikit_learn-1.8.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:146b4d36f800c013d267b29168813f7a03a43ecd2895d04861f1240b564421da", size = 8595835, upload-time = "2025-12-10T07:07:39.385Z" }, + { url = "https://files.pythonhosted.org/packages/01/18/d154dc1638803adf987910cdd07097d9c526663a55666a97c124d09fb96a/scikit_learn-1.8.0-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:f984ca4b14914e6b4094c5d52a32ea16b49832c03bd17a110f004db3c223e8e1", size = 8080381, upload-time = "2025-12-10T07:07:41.93Z" }, + { url = "https://files.pythonhosted.org/packages/8a/44/226142fcb7b7101e64fdee5f49dbe6288d4c7af8abf593237b70fca080a4/scikit_learn-1.8.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5e30adb87f0cc81c7690a84f7932dd66be5bac57cfe16b91cb9151683a4a2d3b", size = 8799632, upload-time = "2025-12-10T07:07:43.899Z" }, + { url = "https://files.pythonhosted.org/packages/36/4d/4a67f30778a45d542bbea5db2dbfa1e9e100bf9ba64aefe34215ba9f11f6/scikit_learn-1.8.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ada8121bcb4dac28d930febc791a69f7cb1673c8495e5eee274190b73a4559c1", size = 9103788, upload-time = "2025-12-10T07:07:45.982Z" }, + { url = "https://files.pythonhosted.org/packages/89/3c/45c352094cfa60050bcbb967b1faf246b22e93cb459f2f907b600f2ceda5/scikit_learn-1.8.0-cp311-cp311-win_amd64.whl", hash = "sha256:c57b1b610bd1f40ba43970e11ce62821c2e6569e4d74023db19c6b26f246cb3b", size = 8081706, upload-time = "2025-12-10T07:07:48.111Z" }, + { url = "https://files.pythonhosted.org/packages/3d/46/5416595bb395757f754feb20c3d776553a386b661658fb21b7c814e89efe/scikit_learn-1.8.0-cp311-cp311-win_arm64.whl", hash = "sha256:2838551e011a64e3053ad7618dda9310175f7515f1742fa2d756f7c874c05961", size = 7688451, upload-time = "2025-12-10T07:07:49.873Z" }, + { url = "https://files.pythonhosted.org/packages/90/74/e6a7cc4b820e95cc38cf36cd74d5aa2b42e8ffc2d21fe5a9a9c45c1c7630/scikit_learn-1.8.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:5fb63362b5a7ddab88e52b6dbb47dac3fd7dafeee740dc6c8d8a446ddedade8e", size = 8548242, upload-time = "2025-12-10T07:07:51.568Z" }, + { url = "https://files.pythonhosted.org/packages/49/d8/9be608c6024d021041c7f0b3928d4749a706f4e2c3832bbede4fb4f58c95/scikit_learn-1.8.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:5025ce924beccb28298246e589c691fe1b8c1c96507e6d27d12c5fadd85bfd76", size = 8079075, upload-time = "2025-12-10T07:07:53.697Z" }, + { url = "https://files.pythonhosted.org/packages/dd/47/f187b4636ff80cc63f21cd40b7b2d177134acaa10f6bb73746130ee8c2e5/scikit_learn-1.8.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4496bb2cf7a43ce1a2d7524a79e40bc5da45cf598dbf9545b7e8316ccba47bb4", size = 8660492, upload-time = "2025-12-10T07:07:55.574Z" }, + { url = "https://files.pythonhosted.org/packages/97/74/b7a304feb2b49df9fafa9382d4d09061a96ee9a9449a7cbea7988dda0828/scikit_learn-1.8.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a0bcfe4d0d14aec44921545fd2af2338c7471de9cb701f1da4c9d85906ab847a", size = 8931904, upload-time = "2025-12-10T07:07:57.666Z" }, + { url = "https://files.pythonhosted.org/packages/9f/c4/0ab22726a04ede56f689476b760f98f8f46607caecff993017ac1b64aa5d/scikit_learn-1.8.0-cp312-cp312-win_amd64.whl", hash = "sha256:35c007dedb2ffe38fe3ee7d201ebac4a2deccd2408e8621d53067733e3c74809", size = 8019359, upload-time = "2025-12-10T07:07:59.838Z" }, + { url = "https://files.pythonhosted.org/packages/24/90/344a67811cfd561d7335c1b96ca21455e7e472d281c3c279c4d3f2300236/scikit_learn-1.8.0-cp312-cp312-win_arm64.whl", hash = "sha256:8c497fff237d7b4e07e9ef1a640887fa4fb765647f86fbe00f969ff6280ce2bb", size = 7641898, upload-time = "2025-12-10T07:08:01.36Z" }, + { url = "https://files.pythonhosted.org/packages/03/aa/e22e0768512ce9255eba34775be2e85c2048da73da1193e841707f8f039c/scikit_learn-1.8.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:0d6ae97234d5d7079dc0040990a6f7aeb97cb7fa7e8945f1999a429b23569e0a", size = 8513770, upload-time = "2025-12-10T07:08:03.251Z" }, + { url = "https://files.pythonhosted.org/packages/58/37/31b83b2594105f61a381fc74ca19e8780ee923be2d496fcd8d2e1147bd99/scikit_learn-1.8.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:edec98c5e7c128328124a029bceb09eda2d526997780fef8d65e9a69eead963e", size = 8044458, upload-time = "2025-12-10T07:08:05.336Z" }, + { url = "https://files.pythonhosted.org/packages/2d/5a/3f1caed8765f33eabb723596666da4ebbf43d11e96550fb18bdec42b467b/scikit_learn-1.8.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:74b66d8689d52ed04c271e1329f0c61635bcaf5b926db9b12d58914cdc01fe57", size = 8610341, upload-time = "2025-12-10T07:08:07.732Z" }, + { url = "https://files.pythonhosted.org/packages/38/cf/06896db3f71c75902a8e9943b444a56e727418f6b4b4a90c98c934f51ed4/scikit_learn-1.8.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8fdf95767f989b0cfedb85f7ed8ca215d4be728031f56ff5a519ee1e3276dc2e", size = 8900022, upload-time = "2025-12-10T07:08:09.862Z" }, + { url = "https://files.pythonhosted.org/packages/1c/f9/9b7563caf3ec8873e17a31401858efab6b39a882daf6c1bfa88879c0aa11/scikit_learn-1.8.0-cp313-cp313-win_amd64.whl", hash = "sha256:2de443b9373b3b615aec1bb57f9baa6bb3a9bd093f1269ba95c17d870422b271", size = 7989409, upload-time = "2025-12-10T07:08:12.028Z" }, + { url = "https://files.pythonhosted.org/packages/49/bd/1f4001503650e72c4f6009ac0c4413cb17d2d601cef6f71c0453da2732fc/scikit_learn-1.8.0-cp313-cp313-win_arm64.whl", hash = "sha256:eddde82a035681427cbedded4e6eff5e57fa59216c2e3e90b10b19ab1d0a65c3", size = 7619760, upload-time = "2025-12-10T07:08:13.688Z" }, + { url = "https://files.pythonhosted.org/packages/d2/7d/a630359fc9dcc95496588c8d8e3245cc8fd81980251079bc09c70d41d951/scikit_learn-1.8.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:7cc267b6108f0a1499a734167282c00c4ebf61328566b55ef262d48e9849c735", size = 8826045, upload-time = "2025-12-10T07:08:15.215Z" }, + { url = "https://files.pythonhosted.org/packages/cc/56/a0c86f6930cfcd1c7054a2bc417e26960bb88d32444fe7f71d5c2cfae891/scikit_learn-1.8.0-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:fe1c011a640a9f0791146011dfd3c7d9669785f9fed2b2a5f9e207536cf5c2fd", size = 8420324, upload-time = "2025-12-10T07:08:17.561Z" }, + { url = "https://files.pythonhosted.org/packages/46/1e/05962ea1cebc1cf3876667ecb14c283ef755bf409993c5946ade3b77e303/scikit_learn-1.8.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:72358cce49465d140cc4e7792015bb1f0296a9742d5622c67e31399b75468b9e", size = 8680651, upload-time = "2025-12-10T07:08:19.952Z" }, + { url = "https://files.pythonhosted.org/packages/fe/56/a85473cd75f200c9759e3a5f0bcab2d116c92a8a02ee08ccd73b870f8bb4/scikit_learn-1.8.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:80832434a6cc114f5219211eec13dcbc16c2bac0e31ef64c6d346cde3cf054cb", size = 8925045, upload-time = "2025-12-10T07:08:22.11Z" }, + { url = "https://files.pythonhosted.org/packages/cc/b7/64d8cfa896c64435ae57f4917a548d7ac7a44762ff9802f75a79b77cb633/scikit_learn-1.8.0-cp313-cp313t-win_amd64.whl", hash = "sha256:ee787491dbfe082d9c3013f01f5991658b0f38aa8177e4cd4bf434c58f551702", size = 8507994, upload-time = "2025-12-10T07:08:23.943Z" }, + { url = "https://files.pythonhosted.org/packages/5e/37/e192ea709551799379958b4c4771ec507347027bb7c942662c7fbeba31cb/scikit_learn-1.8.0-cp313-cp313t-win_arm64.whl", hash = "sha256:bf97c10a3f5a7543f9b88cbf488d33d175e9146115a451ae34568597ba33dcde", size = 7869518, upload-time = "2025-12-10T07:08:25.71Z" }, + { url = "https://files.pythonhosted.org/packages/24/05/1af2c186174cc92dcab2233f327336058c077d38f6fe2aceb08e6ab4d509/scikit_learn-1.8.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:c22a2da7a198c28dd1a6e1136f19c830beab7fdca5b3e5c8bba8394f8a5c45b3", size = 8528667, upload-time = "2025-12-10T07:08:27.541Z" }, + { url = "https://files.pythonhosted.org/packages/a8/25/01c0af38fe969473fb292bba9dc2b8f9b451f3112ff242c647fee3d0dfe7/scikit_learn-1.8.0-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:6b595b07a03069a2b1740dc08c2299993850ea81cce4fe19b2421e0c970de6b7", size = 8066524, upload-time = "2025-12-10T07:08:29.822Z" }, + { url = "https://files.pythonhosted.org/packages/be/ce/a0623350aa0b68647333940ee46fe45086c6060ec604874e38e9ab7d8e6c/scikit_learn-1.8.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:29ffc74089f3d5e87dfca4c2c8450f88bdc61b0fc6ed5d267f3988f19a1309f6", size = 8657133, upload-time = "2025-12-10T07:08:31.865Z" }, + { url = "https://files.pythonhosted.org/packages/b8/cb/861b41341d6f1245e6ca80b1c1a8c4dfce43255b03df034429089ca2a2c5/scikit_learn-1.8.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fb65db5d7531bccf3a4f6bec3462223bea71384e2cda41da0f10b7c292b9e7c4", size = 8923223, upload-time = "2025-12-10T07:08:34.166Z" }, + { url = "https://files.pythonhosted.org/packages/76/18/a8def8f91b18cd1ba6e05dbe02540168cb24d47e8dcf69e8d00b7da42a08/scikit_learn-1.8.0-cp314-cp314-win_amd64.whl", hash = "sha256:56079a99c20d230e873ea40753102102734c5953366972a71d5cb39a32bc40c6", size = 8096518, upload-time = "2025-12-10T07:08:36.339Z" }, + { url = "https://files.pythonhosted.org/packages/d1/77/482076a678458307f0deb44e29891d6022617b2a64c840c725495bee343f/scikit_learn-1.8.0-cp314-cp314-win_arm64.whl", hash = "sha256:3bad7565bc9cf37ce19a7c0d107742b320c1285df7aab1a6e2d28780df167242", size = 7754546, upload-time = "2025-12-10T07:08:38.128Z" }, + { url = "https://files.pythonhosted.org/packages/2d/d1/ef294ca754826daa043b2a104e59960abfab4cf653891037d19dd5b6f3cf/scikit_learn-1.8.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:4511be56637e46c25721e83d1a9cea9614e7badc7040c4d573d75fbe257d6fd7", size = 8848305, upload-time = "2025-12-10T07:08:41.013Z" }, + { url = "https://files.pythonhosted.org/packages/5b/e2/b1f8b05138ee813b8e1a4149f2f0d289547e60851fd1bb268886915adbda/scikit_learn-1.8.0-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:a69525355a641bf8ef136a7fa447672fb54fe8d60cab5538d9eb7c6438543fb9", size = 8432257, upload-time = "2025-12-10T07:08:42.873Z" }, + { url = "https://files.pythonhosted.org/packages/26/11/c32b2138a85dcb0c99f6afd13a70a951bfdff8a6ab42d8160522542fb647/scikit_learn-1.8.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c2656924ec73e5939c76ac4c8b026fc203b83d8900362eb2599d8aee80e4880f", size = 8678673, upload-time = "2025-12-10T07:08:45.362Z" }, + { url = "https://files.pythonhosted.org/packages/c7/57/51f2384575bdec454f4fe4e7a919d696c9ebce914590abf3e52d47607ab8/scikit_learn-1.8.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:15fc3b5d19cc2be65404786857f2e13c70c83dd4782676dd6814e3b89dc8f5b9", size = 8922467, upload-time = "2025-12-10T07:08:47.408Z" }, + { url = "https://files.pythonhosted.org/packages/35/4d/748c9e2872637a57981a04adc038dacaa16ba8ca887b23e34953f0b3f742/scikit_learn-1.8.0-cp314-cp314t-win_amd64.whl", hash = "sha256:00d6f1d66fbcf4eba6e356e1420d33cc06c70a45bb1363cd6f6a8e4ebbbdece2", size = 8774395, upload-time = "2025-12-10T07:08:49.337Z" }, + { url = "https://files.pythonhosted.org/packages/60/22/d7b2ebe4704a5e50790ba089d5c2ae308ab6bb852719e6c3bd4f04c3a363/scikit_learn-1.8.0-cp314-cp314t-win_arm64.whl", hash = "sha256:f28dd15c6bb0b66ba09728cf09fd8736c304be29409bd8445a080c1280619e8c", size = 8002647, upload-time = "2025-12-10T07:08:51.601Z" }, +] + +[[package]] +name = "scipy" +version = "1.17.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7a/97/5a3609c4f8d58b039179648e62dd220f89864f56f7357f5d4f45c29eb2cc/scipy-1.17.1.tar.gz", hash = "sha256:95d8e012d8cb8816c226aef832200b1d45109ed4464303e997c5b13122b297c0", size = 30573822, upload-time = "2026-02-23T00:26:24.851Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/df/75/b4ce781849931fef6fd529afa6b63711d5a733065722d0c3e2724af9e40a/scipy-1.17.1-cp311-cp311-macosx_10_14_x86_64.whl", hash = "sha256:1f95b894f13729334fb990162e911c9e5dc1ab390c58aa6cbecb389c5b5e28ec", size = 31613675, upload-time = "2026-02-23T00:16:00.13Z" }, + { url = "https://files.pythonhosted.org/packages/f7/58/bccc2861b305abdd1b8663d6130c0b3d7cc22e8d86663edbc8401bfd40d4/scipy-1.17.1-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:e18f12c6b0bc5a592ed23d3f7b891f68fd7f8241d69b7883769eb5d5dfb52696", size = 28162057, upload-time = "2026-02-23T00:16:09.456Z" }, + { url = "https://files.pythonhosted.org/packages/6d/ee/18146b7757ed4976276b9c9819108adbc73c5aad636e5353e20746b73069/scipy-1.17.1-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:a3472cfbca0a54177d0faa68f697d8ba4c80bbdc19908c3465556d9f7efce9ee", size = 20334032, upload-time = "2026-02-23T00:16:17.358Z" }, + { url = "https://files.pythonhosted.org/packages/ec/e6/cef1cf3557f0c54954198554a10016b6a03b2ec9e22a4e1df734936bd99c/scipy-1.17.1-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:766e0dc5a616d026a3a1cffa379af959671729083882f50307e18175797b3dfd", size = 22709533, upload-time = "2026-02-23T00:16:25.791Z" }, + { url = "https://files.pythonhosted.org/packages/4d/60/8804678875fc59362b0fb759ab3ecce1f09c10a735680318ac30da8cd76b/scipy-1.17.1-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:744b2bf3640d907b79f3fd7874efe432d1cf171ee721243e350f55234b4cec4c", size = 33062057, upload-time = "2026-02-23T00:16:36.931Z" }, + { url = "https://files.pythonhosted.org/packages/09/7d/af933f0f6e0767995b4e2d705a0665e454d1c19402aa7e895de3951ebb04/scipy-1.17.1-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:43af8d1f3bea642559019edfe64e9b11192a8978efbd1539d7bc2aaa23d92de4", size = 35349300, upload-time = "2026-02-23T00:16:49.108Z" }, + { url = "https://files.pythonhosted.org/packages/b4/3d/7ccbbdcbb54c8fdc20d3b6930137c782a163fa626f0aef920349873421ba/scipy-1.17.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:cd96a1898c0a47be4520327e01f874acfd61fb48a9420f8aa9f6483412ffa444", size = 35127333, upload-time = "2026-02-23T00:17:01.293Z" }, + { url = "https://files.pythonhosted.org/packages/e8/19/f926cb11c42b15ba08e3a71e376d816ac08614f769b4f47e06c3580c836a/scipy-1.17.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:4eb6c25dd62ee8d5edf68a8e1c171dd71c292fdae95d8aeb3dd7d7de4c364082", size = 37741314, upload-time = "2026-02-23T00:17:12.576Z" }, + { url = "https://files.pythonhosted.org/packages/95/da/0d1df507cf574b3f224ccc3d45244c9a1d732c81dcb26b1e8a766ae271a8/scipy-1.17.1-cp311-cp311-win_amd64.whl", hash = "sha256:d30e57c72013c2a4fe441c2fcb8e77b14e152ad48b5464858e07e2ad9fbfceff", size = 36607512, upload-time = "2026-02-23T00:17:23.424Z" }, + { url = "https://files.pythonhosted.org/packages/68/7f/bdd79ceaad24b671543ffe0ef61ed8e659440eb683b66f033454dcee90eb/scipy-1.17.1-cp311-cp311-win_arm64.whl", hash = "sha256:9ecb4efb1cd6e8c4afea0daa91a87fbddbce1b99d2895d151596716c0b2e859d", size = 24599248, upload-time = "2026-02-23T00:17:34.561Z" }, + { url = "https://files.pythonhosted.org/packages/35/48/b992b488d6f299dbe3f11a20b24d3dda3d46f1a635ede1c46b5b17a7b163/scipy-1.17.1-cp312-cp312-macosx_10_14_x86_64.whl", hash = "sha256:35c3a56d2ef83efc372eaec584314bd0ef2e2f0d2adb21c55e6ad5b344c0dcb8", size = 31610954, upload-time = "2026-02-23T00:17:49.855Z" }, + { url = "https://files.pythonhosted.org/packages/b2/02/cf107b01494c19dc100f1d0b7ac3cc08666e96ba2d64db7626066cee895e/scipy-1.17.1-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:fcb310ddb270a06114bb64bbe53c94926b943f5b7f0842194d585c65eb4edd76", size = 28172662, upload-time = "2026-02-23T00:18:01.64Z" }, + { url = "https://files.pythonhosted.org/packages/cf/a9/599c28631bad314d219cf9ffd40e985b24d603fc8a2f4ccc5ae8419a535b/scipy-1.17.1-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:cc90d2e9c7e5c7f1a482c9875007c095c3194b1cfedca3c2f3291cdc2bc7c086", size = 20344366, upload-time = "2026-02-23T00:18:12.015Z" }, + { url = "https://files.pythonhosted.org/packages/35/f5/906eda513271c8deb5af284e5ef0206d17a96239af79f9fa0aebfe0e36b4/scipy-1.17.1-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:c80be5ede8f3f8eded4eff73cc99a25c388ce98e555b17d31da05287015ffa5b", size = 22704017, upload-time = "2026-02-23T00:18:21.502Z" }, + { url = "https://files.pythonhosted.org/packages/da/34/16f10e3042d2f1d6b66e0428308ab52224b6a23049cb2f5c1756f713815f/scipy-1.17.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e19ebea31758fac5893a2ac360fedd00116cbb7628e650842a6691ba7ca28a21", size = 32927842, upload-time = "2026-02-23T00:18:35.367Z" }, + { url = "https://files.pythonhosted.org/packages/01/8e/1e35281b8ab6d5d72ebe9911edcdffa3f36b04ed9d51dec6dd140396e220/scipy-1.17.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:02ae3b274fde71c5e92ac4d54bc06c42d80e399fec704383dcd99b301df37458", size = 35235890, upload-time = "2026-02-23T00:18:49.188Z" }, + { url = "https://files.pythonhosted.org/packages/c5/5c/9d7f4c88bea6e0d5a4f1bc0506a53a00e9fcb198de372bfe4d3652cef482/scipy-1.17.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8a604bae87c6195d8b1045eddece0514d041604b14f2727bbc2b3020172045eb", size = 35003557, upload-time = "2026-02-23T00:18:54.74Z" }, + { url = "https://files.pythonhosted.org/packages/65/94/7698add8f276dbab7a9de9fb6b0e02fc13ee61d51c7c3f85ac28b65e1239/scipy-1.17.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:f590cd684941912d10becc07325a3eeb77886fe981415660d9265c4c418d0bea", size = 37625856, upload-time = "2026-02-23T00:19:00.307Z" }, + { url = "https://files.pythonhosted.org/packages/a2/84/dc08d77fbf3d87d3ee27f6a0c6dcce1de5829a64f2eae85a0ecc1f0daa73/scipy-1.17.1-cp312-cp312-win_amd64.whl", hash = "sha256:41b71f4a3a4cab9d366cd9065b288efc4d4f3c0b37a91a8e0947fb5bd7f31d87", size = 36549682, upload-time = "2026-02-23T00:19:07.67Z" }, + { url = "https://files.pythonhosted.org/packages/bc/98/fe9ae9ffb3b54b62559f52dedaebe204b408db8109a8c66fdd04869e6424/scipy-1.17.1-cp312-cp312-win_arm64.whl", hash = "sha256:f4115102802df98b2b0db3cce5cb9b92572633a1197c77b7553e5203f284a5b3", size = 24547340, upload-time = "2026-02-23T00:19:12.024Z" }, + { url = "https://files.pythonhosted.org/packages/76/27/07ee1b57b65e92645f219b37148a7e7928b82e2b5dbeccecb4dff7c64f0b/scipy-1.17.1-cp313-cp313-macosx_10_14_x86_64.whl", hash = "sha256:5e3c5c011904115f88a39308379c17f91546f77c1667cea98739fe0fccea804c", size = 31590199, upload-time = "2026-02-23T00:19:17.192Z" }, + { url = "https://files.pythonhosted.org/packages/ec/ae/db19f8ab842e9b724bf5dbb7db29302a91f1e55bc4d04b1025d6d605a2c5/scipy-1.17.1-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:6fac755ca3d2c3edcb22f479fceaa241704111414831ddd3bc6056e18516892f", size = 28154001, upload-time = "2026-02-23T00:19:22.241Z" }, + { url = "https://files.pythonhosted.org/packages/5b/58/3ce96251560107b381cbd6e8413c483bbb1228a6b919fa8652b0d4090e7f/scipy-1.17.1-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:7ff200bf9d24f2e4d5dc6ee8c3ac64d739d3a89e2326ba68aaf6c4a2b838fd7d", size = 20325719, upload-time = "2026-02-23T00:19:26.329Z" }, + { url = "https://files.pythonhosted.org/packages/b2/83/15087d945e0e4d48ce2377498abf5ad171ae013232ae31d06f336e64c999/scipy-1.17.1-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:4b400bdc6f79fa02a4d86640310dde87a21fba0c979efff5248908c6f15fad1b", size = 22683595, upload-time = "2026-02-23T00:19:30.304Z" }, + { url = "https://files.pythonhosted.org/packages/b4/e0/e58fbde4a1a594c8be8114eb4aac1a55bcd6587047efc18a61eb1f5c0d30/scipy-1.17.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2b64ca7d4aee0102a97f3ba22124052b4bd2152522355073580bf4845e2550b6", size = 32896429, upload-time = "2026-02-23T00:19:35.536Z" }, + { url = "https://files.pythonhosted.org/packages/f5/5f/f17563f28ff03c7b6799c50d01d5d856a1d55f2676f537ca8d28c7f627cd/scipy-1.17.1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:581b2264fc0aa555f3f435a5944da7504ea3a065d7029ad60e7c3d1ae09c5464", size = 35203952, upload-time = "2026-02-23T00:19:42.259Z" }, + { url = "https://files.pythonhosted.org/packages/8d/a5/9afd17de24f657fdfe4df9a3f1ea049b39aef7c06000c13db1530d81ccca/scipy-1.17.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:beeda3d4ae615106d7094f7e7cef6218392e4465cc95d25f900bebabfded0950", size = 34979063, upload-time = "2026-02-23T00:19:47.547Z" }, + { url = "https://files.pythonhosted.org/packages/8b/13/88b1d2384b424bf7c924f2038c1c409f8d88bb2a8d49d097861dd64a57b2/scipy-1.17.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6609bc224e9568f65064cfa72edc0f24ee6655b47575954ec6339534b2798369", size = 37598449, upload-time = "2026-02-23T00:19:53.238Z" }, + { url = "https://files.pythonhosted.org/packages/35/e5/d6d0e51fc888f692a35134336866341c08655d92614f492c6860dc45bb2c/scipy-1.17.1-cp313-cp313-win_amd64.whl", hash = "sha256:37425bc9175607b0268f493d79a292c39f9d001a357bebb6b88fdfaff13f6448", size = 36510943, upload-time = "2026-02-23T00:20:50.89Z" }, + { url = "https://files.pythonhosted.org/packages/2a/fd/3be73c564e2a01e690e19cc618811540ba5354c67c8680dce3281123fb79/scipy-1.17.1-cp313-cp313-win_arm64.whl", hash = "sha256:5cf36e801231b6a2059bf354720274b7558746f3b1a4efb43fcf557ccd484a87", size = 24545621, upload-time = "2026-02-23T00:20:55.871Z" }, + { url = "https://files.pythonhosted.org/packages/6f/6b/17787db8b8114933a66f9dcc479a8272e4b4da75fe03b0c282f7b0ade8cd/scipy-1.17.1-cp313-cp313t-macosx_10_14_x86_64.whl", hash = "sha256:d59c30000a16d8edc7e64152e30220bfbd724c9bbb08368c054e24c651314f0a", size = 31936708, upload-time = "2026-02-23T00:19:58.694Z" }, + { url = "https://files.pythonhosted.org/packages/38/2e/524405c2b6392765ab1e2b722a41d5da33dc5c7b7278184a8ad29b6cb206/scipy-1.17.1-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:010f4333c96c9bb1a4516269e33cb5917b08ef2166d5556ca2fd9f082a9e6ea0", size = 28570135, upload-time = "2026-02-23T00:20:03.934Z" }, + { url = "https://files.pythonhosted.org/packages/fd/c3/5bd7199f4ea8556c0c8e39f04ccb014ac37d1468e6cfa6a95c6b3562b76e/scipy-1.17.1-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:2ceb2d3e01c5f1d83c4189737a42d9cb2fc38a6eeed225e7515eef71ad301dce", size = 20741977, upload-time = "2026-02-23T00:20:07.935Z" }, + { url = "https://files.pythonhosted.org/packages/d9/b8/8ccd9b766ad14c78386599708eb745f6b44f08400a5fd0ade7cf89b6fc93/scipy-1.17.1-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:844e165636711ef41f80b4103ed234181646b98a53c8f05da12ca5ca289134f6", size = 23029601, upload-time = "2026-02-23T00:20:12.161Z" }, + { url = "https://files.pythonhosted.org/packages/6d/a0/3cb6f4d2fb3e17428ad2880333cac878909ad1a89f678527b5328b93c1d4/scipy-1.17.1-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:158dd96d2207e21c966063e1635b1063cd7787b627b6f07305315dd73d9c679e", size = 33019667, upload-time = "2026-02-23T00:20:17.208Z" }, + { url = "https://files.pythonhosted.org/packages/f3/c3/2d834a5ac7bf3a0c806ad1508efc02dda3c8c61472a56132d7894c312dea/scipy-1.17.1-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:74cbb80d93260fe2ffa334efa24cb8f2f0f622a9b9febf8b483c0b865bfb3475", size = 35264159, upload-time = "2026-02-23T00:20:23.087Z" }, + { url = "https://files.pythonhosted.org/packages/4d/77/d3ed4becfdbd217c52062fafe35a72388d1bd82c2d0ba5ca19d6fcc93e11/scipy-1.17.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:dbc12c9f3d185f5c737d801da555fb74b3dcfa1a50b66a1a93e09190f41fab50", size = 35102771, upload-time = "2026-02-23T00:20:28.636Z" }, + { url = "https://files.pythonhosted.org/packages/bd/12/d19da97efde68ca1ee5538bb261d5d2c062f0c055575128f11a2730e3ac1/scipy-1.17.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:94055a11dfebe37c656e70317e1996dc197e1a15bbcc351bcdd4610e128fe1ca", size = 37665910, upload-time = "2026-02-23T00:20:34.743Z" }, + { url = "https://files.pythonhosted.org/packages/06/1c/1172a88d507a4baaf72c5a09bb6c018fe2ae0ab622e5830b703a46cc9e44/scipy-1.17.1-cp313-cp313t-win_amd64.whl", hash = "sha256:e30bdeaa5deed6bc27b4cc490823cd0347d7dae09119b8803ae576ea0ce52e4c", size = 36562980, upload-time = "2026-02-23T00:20:40.575Z" }, + { url = "https://files.pythonhosted.org/packages/70/b0/eb757336e5a76dfa7911f63252e3b7d1de00935d7705cf772db5b45ec238/scipy-1.17.1-cp313-cp313t-win_arm64.whl", hash = "sha256:a720477885a9d2411f94a93d16f9d89bad0f28ca23c3f8daa521e2dcc3f44d49", size = 24856543, upload-time = "2026-02-23T00:20:45.313Z" }, + { url = "https://files.pythonhosted.org/packages/cf/83/333afb452af6f0fd70414dc04f898647ee1423979ce02efa75c3b0f2c28e/scipy-1.17.1-cp314-cp314-macosx_10_14_x86_64.whl", hash = "sha256:a48a72c77a310327f6a3a920092fa2b8fd03d7deaa60f093038f22d98e096717", size = 31584510, upload-time = "2026-02-23T00:21:01.015Z" }, + { url = "https://files.pythonhosted.org/packages/ed/a6/d05a85fd51daeb2e4ea71d102f15b34fedca8e931af02594193ae4fd25f7/scipy-1.17.1-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:45abad819184f07240d8a696117a7aacd39787af9e0b719d00285549ed19a1e9", size = 28170131, upload-time = "2026-02-23T00:21:05.888Z" }, + { url = "https://files.pythonhosted.org/packages/db/7b/8624a203326675d7746a254083a187398090a179335b2e4a20e2ddc46e83/scipy-1.17.1-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:3fd1fcdab3ea951b610dc4cef356d416d5802991e7e32b5254828d342f7b7e0b", size = 20342032, upload-time = "2026-02-23T00:21:09.904Z" }, + { url = "https://files.pythonhosted.org/packages/c9/35/2c342897c00775d688d8ff3987aced3426858fd89d5a0e26e020b660b301/scipy-1.17.1-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:7bdf2da170b67fdf10bca777614b1c7d96ae3ca5794fd9587dce41eb2966e866", size = 22678766, upload-time = "2026-02-23T00:21:14.313Z" }, + { url = "https://files.pythonhosted.org/packages/ef/f2/7cdb8eb308a1a6ae1e19f945913c82c23c0c442a462a46480ce487fdc0ac/scipy-1.17.1-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:adb2642e060a6549c343603a3851ba76ef0b74cc8c079a9a58121c7ec9fe2350", size = 32957007, upload-time = "2026-02-23T00:21:19.663Z" }, + { url = "https://files.pythonhosted.org/packages/0b/2e/7eea398450457ecb54e18e9d10110993fa65561c4f3add5e8eccd2b9cd41/scipy-1.17.1-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:eee2cfda04c00a857206a4330f0c5e3e56535494e30ca445eb19ec624ae75118", size = 35221333, upload-time = "2026-02-23T00:21:25.278Z" }, + { url = "https://files.pythonhosted.org/packages/d9/77/5b8509d03b77f093a0d52e606d3c4f79e8b06d1d38c441dacb1e26cacf46/scipy-1.17.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:d2650c1fb97e184d12d8ba010493ee7b322864f7d3d00d3f9bb97d9c21de4068", size = 35042066, upload-time = "2026-02-23T00:21:31.358Z" }, + { url = "https://files.pythonhosted.org/packages/f9/df/18f80fb99df40b4070328d5ae5c596f2f00fffb50167e31439e932f29e7d/scipy-1.17.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:08b900519463543aa604a06bec02461558a6e1cef8fdbb8098f77a48a83c8118", size = 37612763, upload-time = "2026-02-23T00:21:37.247Z" }, + { url = "https://files.pythonhosted.org/packages/4b/39/f0e8ea762a764a9dc52aa7dabcfad51a354819de1f0d4652b6a1122424d6/scipy-1.17.1-cp314-cp314-win_amd64.whl", hash = "sha256:3877ac408e14da24a6196de0ddcace62092bfc12a83823e92e49e40747e52c19", size = 37290984, upload-time = "2026-02-23T00:22:35.023Z" }, + { url = "https://files.pythonhosted.org/packages/7c/56/fe201e3b0f93d1a8bcf75d3379affd228a63d7e2d80ab45467a74b494947/scipy-1.17.1-cp314-cp314-win_arm64.whl", hash = "sha256:f8885db0bc2bffa59d5c1b72fad7a6a92d3e80e7257f967dd81abb553a90d293", size = 25192877, upload-time = "2026-02-23T00:22:39.798Z" }, + { url = "https://files.pythonhosted.org/packages/96/ad/f8c414e121f82e02d76f310f16db9899c4fcde36710329502a6b2a3c0392/scipy-1.17.1-cp314-cp314t-macosx_10_14_x86_64.whl", hash = "sha256:1cc682cea2ae55524432f3cdff9e9a3be743d52a7443d0cba9017c23c87ae2f6", size = 31949750, upload-time = "2026-02-23T00:21:42.289Z" }, + { url = "https://files.pythonhosted.org/packages/7c/b0/c741e8865d61b67c81e255f4f0a832846c064e426636cd7de84e74d209be/scipy-1.17.1-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:2040ad4d1795a0ae89bfc7e8429677f365d45aa9fd5e4587cf1ea737f927b4a1", size = 28585858, upload-time = "2026-02-23T00:21:47.706Z" }, + { url = "https://files.pythonhosted.org/packages/ed/1b/3985219c6177866628fa7c2595bfd23f193ceebbe472c98a08824b9466ff/scipy-1.17.1-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:131f5aaea57602008f9822e2115029b55d4b5f7c070287699fe45c661d051e39", size = 20757723, upload-time = "2026-02-23T00:21:52.039Z" }, + { url = "https://files.pythonhosted.org/packages/c0/19/2a04aa25050d656d6f7b9e7b685cc83d6957fb101665bfd9369ca6534563/scipy-1.17.1-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:9cdc1a2fcfd5c52cfb3045feb399f7b3ce822abdde3a193a6b9a60b3cb5854ca", size = 23043098, upload-time = "2026-02-23T00:21:56.185Z" }, + { url = "https://files.pythonhosted.org/packages/86/f1/3383beb9b5d0dbddd030335bf8a8b32d4317185efe495374f134d8be6cce/scipy-1.17.1-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6e3dcd57ab780c741fde8dc68619de988b966db759a3c3152e8e9142c26295ad", size = 33030397, upload-time = "2026-02-23T00:22:01.404Z" }, + { url = "https://files.pythonhosted.org/packages/41/68/8f21e8a65a5a03f25a79165ec9d2b28c00e66dc80546cf5eb803aeeff35b/scipy-1.17.1-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a9956e4d4f4a301ebf6cde39850333a6b6110799d470dbbb1e25326ac447f52a", size = 35281163, upload-time = "2026-02-23T00:22:07.024Z" }, + { url = "https://files.pythonhosted.org/packages/84/8d/c8a5e19479554007a5632ed7529e665c315ae7492b4f946b0deb39870e39/scipy-1.17.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:a4328d245944d09fd639771de275701ccadf5f781ba0ff092ad141e017eccda4", size = 35116291, upload-time = "2026-02-23T00:22:12.585Z" }, + { url = "https://files.pythonhosted.org/packages/52/52/e57eceff0e342a1f50e274264ed47497b59e6a4e3118808ee58ddda7b74a/scipy-1.17.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:a77cbd07b940d326d39a1d1b37817e2ee4d79cb30e7338f3d0cddffae70fcaa2", size = 37682317, upload-time = "2026-02-23T00:22:18.513Z" }, + { url = "https://files.pythonhosted.org/packages/11/2f/b29eafe4a3fbc3d6de9662b36e028d5f039e72d345e05c250e121a230dd4/scipy-1.17.1-cp314-cp314t-win_amd64.whl", hash = "sha256:eb092099205ef62cd1782b006658db09e2fed75bffcae7cc0d44052d8aa0f484", size = 37345327, upload-time = "2026-02-23T00:22:24.442Z" }, + { url = "https://files.pythonhosted.org/packages/07/39/338d9219c4e87f3e708f18857ecd24d22a0c3094752393319553096b98af/scipy-1.17.1-cp314-cp314t-win_arm64.whl", hash = "sha256:200e1050faffacc162be6a486a984a0497866ec54149a01270adc8a59b7c7d21", size = 25489165, upload-time = "2026-02-23T00:22:29.563Z" }, +] + +[[package]] +name = "setuptools" +version = "81.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0d/1c/73e719955c59b8e424d015ab450f51c0af856ae46ea2da83eba51cc88de1/setuptools-81.0.0.tar.gz", hash = "sha256:487b53915f52501f0a79ccfd0c02c165ffe06631443a886740b91af4b7a5845a", size = 1198299, upload-time = "2026-02-06T21:10:39.601Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e1/e3/c164c88b2e5ce7b24d667b9bd83589cf4f3520d97cad01534cd3c4f55fdb/setuptools-81.0.0-py3-none-any.whl", hash = "sha256:fdd925d5c5d9f62e4b74b30d6dd7828ce236fd6ed998a08d81de62ce5a6310d6", size = 1062021, upload-time = "2026-02-06T21:10:37.175Z" }, +] + +[[package]] +name = "silero-vad" +version = "6.2.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "packaging" }, + { name = "torch" }, + { name = "torchaudio" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/32/d3/e31f526482782764aa4f70e20fd4545cf2e4a81a60b6fb0f089f6d107991/silero_vad-6.2.1.tar.gz", hash = "sha256:b23062b0e39fad17b1266fc23c1e7b4290219dbe82ce08510889e32f681f4b3b", size = 28913811, upload-time = "2026-02-24T08:41:59.329Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0b/2b/48566f29a8b53d856ceb1994f209122749b3fda0a733a07e82047257de7a/silero_vad-6.2.1-py3-none-any.whl", hash = "sha256:09de93c4d874bb19c53e62a47dd38be5f163cedad2b5599583231f2a84ef79cb", size = 9146242, upload-time = "2026-02-24T08:41:56.955Z" }, +] + +[[package]] +name = "six" +version = "1.17.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" }, +] + +[[package]] +name = "soundfile" +version = "0.13.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi" }, + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e1/41/9b873a8c055582859b239be17902a85339bec6a30ad162f98c9b0288a2cc/soundfile-0.13.1.tar.gz", hash = "sha256:b2c68dab1e30297317080a5b43df57e302584c49e2942defdde0acccc53f0e5b", size = 46156, upload-time = "2025-01-25T09:17:04.831Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/64/28/e2a36573ccbcf3d57c00626a21fe51989380636e821b341d36ccca0c1c3a/soundfile-0.13.1-py2.py3-none-any.whl", hash = "sha256:a23c717560da2cf4c7b5ae1142514e0fd82d6bbd9dfc93a50423447142f2c445", size = 25751, upload-time = "2025-01-25T09:16:44.235Z" }, + { url = "https://files.pythonhosted.org/packages/ea/ab/73e97a5b3cc46bba7ff8650a1504348fa1863a6f9d57d7001c6b67c5f20e/soundfile-0.13.1-py2.py3-none-macosx_10_9_x86_64.whl", hash = "sha256:82dc664d19831933fe59adad199bf3945ad06d84bc111a5b4c0d3089a5b9ec33", size = 1142250, upload-time = "2025-01-25T09:16:47.583Z" }, + { url = "https://files.pythonhosted.org/packages/a0/e5/58fd1a8d7b26fc113af244f966ee3aecf03cb9293cb935daaddc1e455e18/soundfile-0.13.1-py2.py3-none-macosx_11_0_arm64.whl", hash = "sha256:743f12c12c4054921e15736c6be09ac26b3b3d603aef6fd69f9dde68748f2593", size = 1101406, upload-time = "2025-01-25T09:16:49.662Z" }, + { url = "https://files.pythonhosted.org/packages/58/ae/c0e4a53d77cf6e9a04179535766b3321b0b9ced5f70522e4caf9329f0046/soundfile-0.13.1-py2.py3-none-manylinux_2_28_aarch64.whl", hash = "sha256:9c9e855f5a4d06ce4213f31918653ab7de0c5a8d8107cd2427e44b42df547deb", size = 1235729, upload-time = "2025-01-25T09:16:53.018Z" }, + { url = "https://files.pythonhosted.org/packages/57/5e/70bdd9579b35003a489fc850b5047beeda26328053ebadc1fb60f320f7db/soundfile-0.13.1-py2.py3-none-manylinux_2_28_x86_64.whl", hash = "sha256:03267c4e493315294834a0870f31dbb3b28a95561b80b134f0bd3cf2d5f0e618", size = 1313646, upload-time = "2025-01-25T09:16:54.872Z" }, + { url = "https://files.pythonhosted.org/packages/fe/df/8c11dc4dfceda14e3003bb81a0d0edcaaf0796dd7b4f826ea3e532146bba/soundfile-0.13.1-py2.py3-none-win32.whl", hash = "sha256:c734564fab7c5ddf8e9be5bf70bab68042cd17e9c214c06e365e20d64f9a69d5", size = 899881, upload-time = "2025-01-25T09:16:56.663Z" }, + { url = "https://files.pythonhosted.org/packages/14/e9/6b761de83277f2f02ded7e7ea6f07828ec78e4b229b80e4ca55dd205b9dc/soundfile-0.13.1-py2.py3-none-win_amd64.whl", hash = "sha256:1e70a05a0626524a69e9f0f4dd2ec174b4e9567f4d8b6c11d38b5c289be36ee9", size = 1019162, upload-time = "2025-01-25T09:16:59.573Z" }, +] + +[[package]] +name = "soxr" +version = "1.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ed/11/27cebce4a108f77afea7c80545115536b45e3f11ebfb914f638fdd9ba847/soxr-1.1.0.tar.gz", hash = "sha256:9f228ae21c78fa9359ca98d8a5e8e91f30639e438e574133dace62c5b5309e44", size = 173067, upload-time = "2026-05-03T00:15:18.214Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8e/49/3e6bc84f87439f222f40b616e9a29a170f41fb564710ea510df19dc26907/soxr-1.1.0-cp311-cp311-macosx_10_14_x86_64.whl", hash = "sha256:34cc92208c3c412c046813e69da639c04a792c6a41fbfd7d909d359cd3e97a2d", size = 205699, upload-time = "2026-05-03T00:14:46.67Z" }, + { url = "https://files.pythonhosted.org/packages/2f/94/216f46096a85b07d1e6ba7fd44491402e912a3d688cd4f36f0a600ca155f/soxr-1.1.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:bd30f7201eac896ebf5db7b09156e6f1a1b82601900d29d9c8449bdad8365b11", size = 167381, upload-time = "2026-05-03T00:14:48.012Z" }, + { url = "https://files.pythonhosted.org/packages/94/cb/06caa463b8181ec1981bd6376d4a873748b7008193188b8cfb60391eb131/soxr-1.1.0-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1577865e993f98ffb261257c3060fa76ec3db44ed3f181b16464268000424464", size = 210938, upload-time = "2026-05-03T00:14:49.768Z" }, + { url = "https://files.pythonhosted.org/packages/86/47/d5964551ca818b7f0c7ef7f3899056263b60ef098a801066350a9672ca8f/soxr-1.1.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3da87e3ffa3e41823d873b051c7ecb2acebd8d1b6b46b752f5facf10a0d84ab9", size = 245268, upload-time = "2026-05-03T00:14:51.422Z" }, + { url = "https://files.pythonhosted.org/packages/8f/29/371467eb86c7ba6810df0bfe9409bcd9c52ec5615b111190fafe23e4d2e1/soxr-1.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:ae30c48ac795378cf23ba3c7c640b8ff794af714ac388b9fd6b31a40b39e6e86", size = 176779, upload-time = "2026-05-03T00:14:53.09Z" }, + { url = "https://files.pythonhosted.org/packages/06/8a/f3da7973b5f1b05d2d7e94d5376b881dcbc05297900cae6c3d33d95b209b/soxr-1.1.0-cp312-abi3-macosx_10_14_x86_64.whl", hash = "sha256:e0e09fa633ce2e67df08b298afced4d184f6e753fc330f241022250f1d0d61da", size = 204124, upload-time = "2026-05-03T00:14:54.505Z" }, + { url = "https://files.pythonhosted.org/packages/03/dc/200013a74641f8774664bbcd2346c695c05c2e300ea792adcb40a293eed0/soxr-1.1.0-cp312-abi3-macosx_11_0_arm64.whl", hash = "sha256:d6a7ad82b8d5f3fcc04b1d2ca055562b96af571e1d4fa7c6c61d0fb509ac43b4", size = 165457, upload-time = "2026-05-03T00:14:56.007Z" }, + { url = "https://files.pythonhosted.org/packages/88/2b/2e5eba817a762a2ec589ff165b8bc5955b25a0ad140045f7cd8e45410543/soxr-1.1.0-cp312-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bf98c0d7b7d5ef5bf072fee8d3020e8b664f2d195933ea7bc5089267c2e22a06", size = 206529, upload-time = "2026-05-03T00:14:57.646Z" }, + { url = "https://files.pythonhosted.org/packages/5c/f1/0e55195893228609c9a08c3b13b7a83a46c3a992cd00d3304f0f320cfb07/soxr-1.1.0-cp312-abi3-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3b033078e86f3c4a658e5697fac8995764fad9e799563616b630136b613167f1", size = 240413, upload-time = "2026-05-03T00:14:59.363Z" }, + { url = "https://files.pythonhosted.org/packages/b0/4d/621e4150e4815246ad552d215a8a294a90143fedd19ee442cf82d3b3abc8/soxr-1.1.0-cp312-abi3-win_amd64.whl", hash = "sha256:6ae2a174bffea94e8ead857dad85999d3f49f091774dbad5b046c0417d7092f4", size = 174357, upload-time = "2026-05-03T00:15:00.724Z" }, + { url = "https://files.pythonhosted.org/packages/76/cd/77b74f1e95af0e11e52e9a034421aece7f7b45afd15a909afd41d5a5d102/soxr-1.1.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:a941f5aaa0b8abced24318105c1ea22576afcc1138c19f625716ce4e2f76ad64", size = 207990, upload-time = "2026-05-03T00:15:02.1Z" }, + { url = "https://files.pythonhosted.org/packages/30/86/600cc31f982288167a59972746f117790162012546f995a32b5a55394b16/soxr-1.1.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:feebcba99ac99adb8009d46c8f4c1956b8c167576b0ae8a6fb47502e9a6f78e7", size = 169288, upload-time = "2026-05-03T00:15:03.75Z" }, + { url = "https://files.pythonhosted.org/packages/39/e4/80cd9aae0645513db1076d4384e8b2d895faf5009218b4a04348012c54fc/soxr-1.1.0-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:52c9ca84e3dc656d83acc424574770e20ea8e0704dc3842d4e27b0fe9d3ba449", size = 211405, upload-time = "2026-05-03T00:15:05.395Z" }, + { url = "https://files.pythonhosted.org/packages/a6/d6/cc3c80ac9b2289da4cf46c5d53b05e4327e6f5560a25868d06f9e2213af1/soxr-1.1.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f4977323ef9c3aa3c2a26ff5fe0191c84b8fd759daf7afb1f25a91a55ad8b730", size = 244617, upload-time = "2026-05-03T00:15:07.134Z" }, + { url = "https://files.pythonhosted.org/packages/d3/9e/f7af5fae841ffe32ed8440234ea2ad6adecca3bd92b6101076268c429000/soxr-1.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:e17d4ef9b0185214b2c0935605ae63f827ea423bc74964be44763d68d2b6c21e", size = 187253, upload-time = "2026-05-03T00:15:08.813Z" }, +] + +[[package]] +name = "stack-data" +version = "0.6.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "asttokens" }, + { name = "executing" }, + { name = "pure-eval" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/28/e3/55dcc2cfbc3ca9c29519eb6884dd1415ecb53b0e934862d3559ddcb7e20b/stack_data-0.6.3.tar.gz", hash = "sha256:836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9", size = 44707, upload-time = "2023-09-30T13:58:05.479Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f1/7b/ce1eafaf1a76852e2ec9b22edecf1daa58175c090266e9f6c64afcd81d91/stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695", size = 24521, upload-time = "2023-09-30T13:58:03.53Z" }, +] + +[[package]] +name = "standard-aifc" +version = "3.13.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "audioop-lts", marker = "python_full_version >= '3.13'" }, + { name = "standard-chunk", marker = "python_full_version >= '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c4/53/6050dc3dde1671eb3db592c13b55a8005e5040131f7509cef0215212cb84/standard_aifc-3.13.0.tar.gz", hash = "sha256:64e249c7cb4b3daf2fdba4e95721f811bde8bdfc43ad9f936589b7bb2fae2e43", size = 15240, upload-time = "2024-10-30T16:01:31.772Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c3/52/5fbb203394cc852334d1575cc020f6bcec768d2265355984dfd361968f36/standard_aifc-3.13.0-py3-none-any.whl", hash = "sha256:f7ae09cc57de1224a0dd8e3eb8f73830be7c3d0bc485de4c1f82b4a7f645ac66", size = 10492, upload-time = "2024-10-30T16:01:07.071Z" }, +] + +[[package]] +name = "standard-chunk" +version = "3.13.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/43/06/ce1bb165c1f111c7d23a1ad17204d67224baa69725bb6857a264db61beaf/standard_chunk-3.13.0.tar.gz", hash = "sha256:4ac345d37d7e686d2755e01836b8d98eda0d1a3ee90375e597ae43aaf064d654", size = 4672, upload-time = "2024-10-30T16:18:28.326Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7a/90/a5c1084d87767d787a6caba615aa50dc587229646308d9420c960cb5e4c0/standard_chunk-3.13.0-py3-none-any.whl", hash = "sha256:17880a26c285189c644bd5bd8f8ed2bdb795d216e3293e6dbe55bbd848e2982c", size = 4944, upload-time = "2024-10-30T16:18:26.694Z" }, +] + +[[package]] +name = "standard-sunau" +version = "3.13.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "audioop-lts", marker = "python_full_version >= '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/66/e3/ce8d38cb2d70e05ffeddc28bb09bad77cfef979eb0a299c9117f7ed4e6a9/standard_sunau-3.13.0.tar.gz", hash = "sha256:b319a1ac95a09a2378a8442f403c66f4fd4b36616d6df6ae82b8e536ee790908", size = 9368, upload-time = "2024-10-30T16:01:41.626Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/34/ae/e3707f6c1bc6f7aa0df600ba8075bfb8a19252140cd595335be60e25f9ee/standard_sunau-3.13.0-py3-none-any.whl", hash = "sha256:53af624a9529c41062f4c2fd33837f297f3baa196b0cfceffea6555654602622", size = 7364, upload-time = "2024-10-30T16:01:28.003Z" }, +] + +[[package]] +name = "study-asr" +version = "0.1.0" +source = { virtual = "." } +dependencies = [ + { name = "ipython" }, + { name = "librosa" }, + { name = "matplotlib" }, + { name = "mutagen" }, + { name = "numpy" }, + { name = "pandas" }, + { name = "pillow" }, + { name = "pydub" }, + { name = "pyrubberband" }, + { name = "setuptools" }, + { name = "silero-vad" }, + { name = "tensorboard" }, + { name = "tensorboardx" }, + { name = "torch" }, + { name = "torch-audiomentations" }, + { name = "torchaudio" }, + { name = "torchcodec" }, + { name = "tqdm" }, + { name = "webrtcvad" }, +] + +[package.metadata] +requires-dist = [ + { name = "ipython", specifier = ">=9.10.1" }, + { name = "librosa", specifier = ">=0.11.0" }, + { name = "matplotlib", specifier = ">=3.10.8" }, + { name = "mutagen", specifier = ">=1.47.0" }, + { name = "numpy", specifier = ">=2.4.4" }, + { name = "pandas", specifier = ">=3.0.2" }, + { name = "pillow", specifier = ">=12.2.0" }, + { name = "pydub", specifier = ">=0.25.1" }, + { name = "pyrubberband", specifier = ">=0.4.0" }, + { name = "setuptools", specifier = "<82" }, + { name = "silero-vad", specifier = ">=6.2.1" }, + { name = "tensorboard", specifier = ">=2.20.0" }, + { name = "tensorboardx", specifier = ">=2.6.5" }, + { name = "torch", specifier = "==2.8.0" }, + { name = "torch-audiomentations", specifier = ">=0.12.0" }, + { name = "torchaudio", specifier = "==2.8.0" }, + { name = "torchcodec", specifier = "==0.7.0" }, + { name = "tqdm", specifier = ">=4.67.3" }, + { name = "webrtcvad", specifier = ">=2.0.10" }, +] + +[[package]] +name = "sympy" +version = "1.14.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "mpmath" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/83/d3/803453b36afefb7c2bb238361cd4ae6125a569b4db67cd9e79846ba2d68c/sympy-1.14.0.tar.gz", hash = "sha256:d3d3fe8df1e5a0b42f0e7bdf50541697dbe7d23746e894990c030e2b05e72517", size = 7793921, upload-time = "2025-04-27T18:05:01.611Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a2/09/77d55d46fd61b4a135c444fc97158ef34a095e5681d0a6c10b75bf356191/sympy-1.14.0-py3-none-any.whl", hash = "sha256:e091cc3e99d2141a0ba2847328f5479b05d94a6635cb96148ccb3f34671bd8f5", size = 6299353, upload-time = "2025-04-27T18:04:59.103Z" }, +] + +[[package]] +name = "tensorboard" +version = "2.20.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "absl-py" }, + { name = "grpcio" }, + { name = "markdown" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "pillow" }, + { name = "protobuf" }, + { name = "setuptools" }, + { name = "tensorboard-data-server" }, + { name = "werkzeug" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/9c/d9/a5db55f88f258ac669a92858b70a714bbbd5acd993820b41ec4a96a4d77f/tensorboard-2.20.0-py3-none-any.whl", hash = "sha256:9dc9f978cb84c0723acf9a345d96c184f0293d18f166bb8d59ee098e6cfaaba6", size = 5525680, upload-time = "2025-07-17T19:20:49.638Z" }, +] + +[[package]] +name = "tensorboard-data-server" +version = "0.7.2" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7a/13/e503968fefabd4c6b2650af21e110aa8466fe21432cd7c43a84577a89438/tensorboard_data_server-0.7.2-py3-none-any.whl", hash = "sha256:7e0610d205889588983836ec05dc098e80f97b7e7bbff7e994ebb78f578d0ddb", size = 2356, upload-time = "2023-10-23T21:23:32.16Z" }, + { url = "https://files.pythonhosted.org/packages/b7/85/dabeaf902892922777492e1d253bb7e1264cadce3cea932f7ff599e53fea/tensorboard_data_server-0.7.2-py3-none-macosx_10_9_x86_64.whl", hash = "sha256:9fe5d24221b29625dbc7328b0436ca7fc1c23de4acf4d272f1180856e32f9f60", size = 4823598, upload-time = "2023-10-23T21:23:33.714Z" }, + { url = "https://files.pythonhosted.org/packages/73/c6/825dab04195756cf8ff2e12698f22513b3db2f64925bdd41671bfb33aaa5/tensorboard_data_server-0.7.2-py3-none-manylinux_2_31_x86_64.whl", hash = "sha256:ef687163c24185ae9754ed5650eb5bc4d84ff257aabdc33f0cc6f74d8ba54530", size = 6590363, upload-time = "2023-10-23T21:23:35.583Z" }, +] + +[[package]] +name = "tensorboardx" +version = "2.6.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, + { name = "packaging" }, + { name = "protobuf" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/48/a9/fc520ea91ab1f3ba51cbf3fe24f2b6364ed3b49046969e0868d46d6da372/tensorboardx-2.6.5.tar.gz", hash = "sha256:ca176db3997ee8c07d2eb77381225956a3fd1c10c91beafab1f17069adc47017", size = 4770195, upload-time = "2026-04-03T15:40:23.803Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/87/0f/69fbab4c30b2f3a76e6de67585ea72a8eccf381751f5c0046b966fde9658/tensorboardx-2.6.5-py3-none-any.whl", hash = "sha256:c10b891d00af306537cb8b58a039b2ba41571f0da06f433a41c4ca8d6abe1373", size = 87510, upload-time = "2026-04-03T15:40:22.111Z" }, +] + +[[package]] +name = "threadpoolctl" +version = "3.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b7/4d/08c89e34946fce2aec4fbb45c9016efd5f4d7f24af8e5d93296e935631d8/threadpoolctl-3.6.0.tar.gz", hash = "sha256:8ab8b4aa3491d812b623328249fab5302a68d2d71745c8a4c719a2fcaba9f44e", size = 21274, upload-time = "2025-03-13T13:49:23.031Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/32/d5/f9a850d79b0851d1d4ef6456097579a9005b31fea68726a4ae5f2d82ddd9/threadpoolctl-3.6.0-py3-none-any.whl", hash = "sha256:43a0b8fd5a2928500110039e43a5eed8480b918967083ea48dc3ab9f13c4a7fb", size = 18638, upload-time = "2025-03-13T13:49:21.846Z" }, +] + +[[package]] +name = "torch" +version = "2.8.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "filelock" }, + { name = "fsspec" }, + { name = "jinja2" }, + { name = "networkx" }, + { name = "nvidia-cublas-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "nvidia-cuda-cupti-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "nvidia-cuda-nvrtc-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "nvidia-cuda-runtime-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "nvidia-cudnn-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "nvidia-cufft-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "nvidia-cufile-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "nvidia-curand-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "nvidia-cusolver-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "nvidia-cusparse-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "nvidia-cusparselt-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "nvidia-nccl-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "nvidia-nvjitlink-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "nvidia-nvtx-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "setuptools", marker = "python_full_version >= '3.12'" }, + { name = "sympy" }, + { name = "triton", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "typing-extensions" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/8f/c4/3e7a3887eba14e815e614db70b3b529112d1513d9dae6f4d43e373360b7f/torch-2.8.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:220a06fd7af8b653c35d359dfe1aaf32f65aa85befa342629f716acb134b9710", size = 102073391, upload-time = "2025-08-06T14:53:20.937Z" }, + { url = "https://files.pythonhosted.org/packages/5a/63/4fdc45a0304536e75a5e1b1bbfb1b56dd0e2743c48ee83ca729f7ce44162/torch-2.8.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:c12fa219f51a933d5f80eeb3a7a5d0cbe9168c0a14bbb4055f1979431660879b", size = 888063640, upload-time = "2025-08-06T14:55:05.325Z" }, + { url = "https://files.pythonhosted.org/packages/84/57/2f64161769610cf6b1c5ed782bd8a780e18a3c9d48931319f2887fa9d0b1/torch-2.8.0-cp311-cp311-win_amd64.whl", hash = "sha256:8c7ef765e27551b2fbfc0f41bcf270e1292d9bf79f8e0724848b1682be6e80aa", size = 241366752, upload-time = "2025-08-06T14:53:38.692Z" }, + { url = "https://files.pythonhosted.org/packages/a4/5e/05a5c46085d9b97e928f3f037081d3d2b87fb4b4195030fc099aaec5effc/torch-2.8.0-cp311-none-macosx_11_0_arm64.whl", hash = "sha256:5ae0524688fb6707c57a530c2325e13bb0090b745ba7b4a2cd6a3ce262572916", size = 73621174, upload-time = "2025-08-06T14:53:25.44Z" }, + { url = "https://files.pythonhosted.org/packages/49/0c/2fd4df0d83a495bb5e54dca4474c4ec5f9c62db185421563deeb5dabf609/torch-2.8.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:e2fab4153768d433f8ed9279c8133a114a034a61e77a3a104dcdf54388838705", size = 101906089, upload-time = "2025-08-06T14:53:52.631Z" }, + { url = "https://files.pythonhosted.org/packages/99/a8/6acf48d48838fb8fe480597d98a0668c2beb02ee4755cc136de92a0a956f/torch-2.8.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:b2aca0939fb7e4d842561febbd4ffda67a8e958ff725c1c27e244e85e982173c", size = 887913624, upload-time = "2025-08-06T14:56:44.33Z" }, + { url = "https://files.pythonhosted.org/packages/af/8a/5c87f08e3abd825c7dfecef5a0f1d9aa5df5dd0e3fd1fa2f490a8e512402/torch-2.8.0-cp312-cp312-win_amd64.whl", hash = "sha256:2f4ac52f0130275d7517b03a33d2493bab3693c83dcfadf4f81688ea82147d2e", size = 241326087, upload-time = "2025-08-06T14:53:46.503Z" }, + { url = "https://files.pythonhosted.org/packages/be/66/5c9a321b325aaecb92d4d1855421e3a055abd77903b7dab6575ca07796db/torch-2.8.0-cp312-none-macosx_11_0_arm64.whl", hash = "sha256:619c2869db3ada2c0105487ba21b5008defcc472d23f8b80ed91ac4a380283b0", size = 73630478, upload-time = "2025-08-06T14:53:57.144Z" }, + { url = "https://files.pythonhosted.org/packages/10/4e/469ced5a0603245d6a19a556e9053300033f9c5baccf43a3d25ba73e189e/torch-2.8.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:2b2f96814e0345f5a5aed9bf9734efa913678ed19caf6dc2cddb7930672d6128", size = 101936856, upload-time = "2025-08-06T14:54:01.526Z" }, + { url = "https://files.pythonhosted.org/packages/16/82/3948e54c01b2109238357c6f86242e6ecbf0c63a1af46906772902f82057/torch-2.8.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:65616ca8ec6f43245e1f5f296603e33923f4c30f93d65e103d9e50c25b35150b", size = 887922844, upload-time = "2025-08-06T14:55:50.78Z" }, + { url = "https://files.pythonhosted.org/packages/e3/54/941ea0a860f2717d86a811adf0c2cd01b3983bdd460d0803053c4e0b8649/torch-2.8.0-cp313-cp313-win_amd64.whl", hash = "sha256:659df54119ae03e83a800addc125856effda88b016dfc54d9f65215c3975be16", size = 241330968, upload-time = "2025-08-06T14:54:45.293Z" }, + { url = "https://files.pythonhosted.org/packages/de/69/8b7b13bba430f5e21d77708b616f767683629fc4f8037564a177d20f90ed/torch-2.8.0-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:1a62a1ec4b0498930e2543535cf70b1bef8c777713de7ceb84cd79115f553767", size = 73915128, upload-time = "2025-08-06T14:54:34.769Z" }, + { url = "https://files.pythonhosted.org/packages/15/0e/8a800e093b7f7430dbaefa80075aee9158ec22e4c4fc3c1a66e4fb96cb4f/torch-2.8.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:83c13411a26fac3d101fe8035a6b0476ae606deb8688e904e796a3534c197def", size = 102020139, upload-time = "2025-08-06T14:54:39.047Z" }, + { url = "https://files.pythonhosted.org/packages/4a/15/5e488ca0bc6162c86a33b58642bc577c84ded17c7b72d97e49b5833e2d73/torch-2.8.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:8f0a9d617a66509ded240add3754e462430a6c1fc5589f86c17b433dd808f97a", size = 887990692, upload-time = "2025-08-06T14:56:18.286Z" }, + { url = "https://files.pythonhosted.org/packages/b4/a8/6a04e4b54472fc5dba7ca2341ab219e529f3c07b6941059fbf18dccac31f/torch-2.8.0-cp313-cp313t-win_amd64.whl", hash = "sha256:a7242b86f42be98ac674b88a4988643b9bc6145437ec8f048fea23f72feb5eca", size = 241603453, upload-time = "2025-08-06T14:55:22.945Z" }, + { url = "https://files.pythonhosted.org/packages/04/6e/650bb7f28f771af0cb791b02348db8b7f5f64f40f6829ee82aa6ce99aabe/torch-2.8.0-cp313-none-macosx_11_0_arm64.whl", hash = "sha256:7b677e17f5a3e69fdef7eb3b9da72622f8d322692930297e4ccb52fefc6c8211", size = 73632395, upload-time = "2025-08-06T14:55:28.645Z" }, +] + +[[package]] +name = "torch-audiomentations" +version = "0.12.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "julius" }, + { name = "torch" }, + { name = "torch-pitch-shift" }, + { name = "torchaudio" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/31/8d/2f8fd7e34c75f5ee8de4310c3bd3f22270acd44d1f809e2fe7c12fbf35f8/torch_audiomentations-0.12.0.tar.gz", hash = "sha256:b02d4c5eb86376986a53eb405cca5e34f370ea9284411237508e720c529f7888", size = 52094, upload-time = "2025-01-15T09:07:01.071Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/21/9d/1ee04f49c15d2d632f6f7102061d7c07652858e6d91b58a091531034e84f/torch_audiomentations-0.12.0-py3-none-any.whl", hash = "sha256:1b80b91d2016ccf83979622cac8f702072a79b7dcc4c2bee40f00b26433a786b", size = 48506, upload-time = "2025-01-15T09:06:59.687Z" }, +] + +[[package]] +name = "torch-pitch-shift" +version = "1.2.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "packaging" }, + { name = "primepy" }, + { name = "torch" }, + { name = "torchaudio" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/79/a6/722a832bca75d5079f6731e005b3d0c2eec7c6c6863d030620952d143d57/torch_pitch_shift-1.2.5.tar.gz", hash = "sha256:6e1c7531f08d0f407a4c55e5ff8385a41355c5c5d27ab7fa08632e51defbd0ed", size = 4725, upload-time = "2024-09-25T19:10:12.922Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/27/4c/96ac2a09efb56cc3c41fb3ce9b6f4d8c0604499f7481d4a13a7b03e21382/torch_pitch_shift-1.2.5-py3-none-any.whl", hash = "sha256:6f8500cbc13f1c98b11cde1805ce5084f82cdd195c285f34287541f168a7c6a7", size = 5005, upload-time = "2024-09-25T19:10:11.521Z" }, +] + +[[package]] +name = "torchaudio" +version = "2.8.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "torch" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/dd/bf/6b01ef3defb8d0a772c863588711e9b2b011c27d6b37c1b9d15a359c8442/torchaudio-2.8.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c9276857d241c6de257af765c0f51fc011af38cb725401495121b280913007cf", size = 1859094, upload-time = "2025-08-06T14:58:35.078Z" }, + { url = "https://files.pythonhosted.org/packages/75/ca/da5d0a3bb7d114a8b590ecce14859ea0a05102bb4de68cdd1ed7a90634d6/torchaudio-2.8.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:4573c6042950c20278e3608a9a38050ba0bc72e0049e1bbfd249caf859a8029b", size = 1692033, upload-time = "2025-08-06T14:58:37.393Z" }, + { url = "https://files.pythonhosted.org/packages/b6/ef/62ac736d8f906cc414181050e08a495a637dab985186c34bd76ea37efbc0/torchaudio-2.8.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:776c0b4ba84b9e3ddf6304b9c47cd63549d7896a6f3d5184ece074cc3d76ed6b", size = 4011716, upload-time = "2025-08-06T14:58:40.138Z" }, + { url = "https://files.pythonhosted.org/packages/14/86/015337c8434abc604b8680371df783f66c421a7f211cbe40a374b0540b6d/torchaudio-2.8.0-cp311-cp311-win_amd64.whl", hash = "sha256:078105bf80f725c0215a0bebac8cb2fb1b3993ab32bdc3fcd50145a5b4127001", size = 2505194, upload-time = "2025-08-06T14:58:57.301Z" }, + { url = "https://files.pythonhosted.org/packages/ac/cc/c2e2a3eb6ee956f73c68541e439916f8146170ea9cc61e72adea5c995312/torchaudio-2.8.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ddef94bf181e6447cbb05f38beaca8f6c5bb8d2b9ddced1aa3452025b9fc70d3", size = 1856736, upload-time = "2025-08-06T14:58:36.3Z" }, + { url = "https://files.pythonhosted.org/packages/c7/0d/24dad878784f1edd62862f27173781669f0c71eb46368636787d1e364188/torchaudio-2.8.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:862e2e40bf09d865e5df080a84c1a39bbcef40e43140f4b1737eb3a389d3b38f", size = 1692930, upload-time = "2025-08-06T14:58:41.312Z" }, + { url = "https://files.pythonhosted.org/packages/c2/a6/84d80f34472503e9eb82245d7df501c59602d75d7360e717fb9b84f91c5e/torchaudio-2.8.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:93a8583f280fe83ba021aa713319381ea71362cc87b67ee38e97a43cb2254aee", size = 4014607, upload-time = "2025-08-06T14:58:47.234Z" }, + { url = "https://files.pythonhosted.org/packages/43/ab/96ad33afa320738a7cfb4b51ba97e2f3cfb1e04ae3115d5057655103ba4f/torchaudio-2.8.0-cp312-cp312-win_amd64.whl", hash = "sha256:4b82cacd1b8ccd543b1149d8cab257a40dfda8119023d2e3a96c66349c84bffb", size = 2499890, upload-time = "2025-08-06T14:58:55.066Z" }, + { url = "https://files.pythonhosted.org/packages/3b/ea/2a68259c4dbb5fe44ebfdcfa40b115010d8c677221a7ef0f5577f3c4f5f1/torchaudio-2.8.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f851d32e94ca05e470f0c60e25726ec1e0eb71cb2ca5a0206b7fd03272ccc3c8", size = 1857045, upload-time = "2025-08-06T14:58:51.984Z" }, + { url = "https://files.pythonhosted.org/packages/0d/a3/1c79a8ef29fe403b83bdfc033db852bc2a888b80c406325e5c6fb37a7f2d/torchaudio-2.8.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:09535a9b727c0793cd07c1ace99f3f353626281bcc3e30c2f2314e3ebc9d3f96", size = 1692755, upload-time = "2025-08-06T14:58:50.868Z" }, + { url = "https://files.pythonhosted.org/packages/49/df/61941198e9ac6bcebfdd57e1836e4f3c23409308e3d8d7458f0198a6a366/torchaudio-2.8.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:d2a85b124494736241884372fe1c6dd8c15e9bc1931bd325838c5c00238c7378", size = 4013897, upload-time = "2025-08-06T14:59:01.66Z" }, + { url = "https://files.pythonhosted.org/packages/c3/ab/7175d35a4bbc4a465a9f1388571842f16eb6dec5069d7ea9c8c2d7b5b401/torchaudio-2.8.0-cp313-cp313-win_amd64.whl", hash = "sha256:c1b5139c840367a7855a062a06688a416619f6fd2ca46d9b9299b49a7d133dfd", size = 2500085, upload-time = "2025-08-06T14:58:44.95Z" }, + { url = "https://files.pythonhosted.org/packages/34/1a/69b9f8349d9d57953d5e7e445075cbf74000173fb5f5d5d9e9d59415fc63/torchaudio-2.8.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:68df9c9068984edff8065c2b6656725e6114fe89281b0cf122c7505305fc98a4", size = 1935600, upload-time = "2025-08-06T14:58:46.051Z" }, + { url = "https://files.pythonhosted.org/packages/71/76/40fec21b65bccfdc5c8cdb9d511033ab07a7ad4b05f0a5b07f85c68279fc/torchaudio-2.8.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:1951f10ed092f2dda57634f6a3950ef21c9d9352551aa84a9fccd51bbda18095", size = 1704199, upload-time = "2025-08-06T14:58:43.594Z" }, + { url = "https://files.pythonhosted.org/packages/8e/53/95c3363413c2f2009f805144160b093a385f641224465fbcd717449c71fb/torchaudio-2.8.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:4f7d97494698d98854129349b12061e8c3398d33bd84c929fa9aed5fd1389f73", size = 4020596, upload-time = "2025-08-06T14:59:03.031Z" }, + { url = "https://files.pythonhosted.org/packages/52/27/7fc2d7435af044ffbe0b9b8e98d99eac096d43f128a5cde23c04825d5dcf/torchaudio-2.8.0-cp313-cp313t-win_amd64.whl", hash = "sha256:d4a715d09ac28c920d031ee1e60ecbc91e8a5079ad8c61c0277e658436c821a6", size = 2549553, upload-time = "2025-08-06T14:59:00.019Z" }, +] + +[[package]] +name = "torchcodec" +version = "0.7.0" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6a/f1/bb2b5ab929ef3f092cb6508673510ffc2aafd8324493c94a2d41f1c8a683/torchcodec-0.7.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:967a14b31e04721901ddbf965f9e9f733f328c5e98a51e22f414e25ac32e20ba", size = 3388626, upload-time = "2025-09-08T14:17:50.433Z" }, + { url = "https://files.pythonhosted.org/packages/06/14/8ff28247988365fc47e8471e28cdfd8d037232fcf73abb67ee815ac80f1d/torchcodec-0.7.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:afb1c48b52bd4ee8f485f5a427bb4e82380590255a26b8e9e3fe099e0779287f", size = 1419444, upload-time = "2025-09-08T14:17:41.479Z" }, + { url = "https://files.pythonhosted.org/packages/1f/80/04f23dff2c7ac406d2d6b24a52be7654a946d2fdfe158b19341a524dae20/torchcodec-0.7.0-cp311-cp311-win_amd64.whl", hash = "sha256:a68765cd29159da3cf36eb5716481c617ad9d168fe06418bcde2a9360cc7eb5e", size = 1563430, upload-time = "2025-09-08T14:17:58.571Z" }, + { url = "https://files.pythonhosted.org/packages/c7/b2/6d3e190fcd18c65b35f6da734d4415c72b42c8a72ffc2494d998bad8caf3/torchcodec-0.7.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:d9d082bbb599f4f7715bfc3b1afa5bc16d8fb9d852e68084c63f1973cc78a1cb", size = 3574506, upload-time = "2025-09-08T14:17:52.071Z" }, + { url = "https://files.pythonhosted.org/packages/41/10/4a1a8407d0fad37cb43d1f749e7b422e5a0f6def17f3b90ab9ab9a105e32/torchcodec-0.7.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:3cd23c3296c9b071d56bb2c534a6a98275d65c1a6a7213cdb72a26ec9f9d2fd8", size = 1421871, upload-time = "2025-09-08T14:17:43.419Z" }, + { url = "https://files.pythonhosted.org/packages/9b/e7/a2fa7ed9c81d7d683d37ca7204007b421c0537132364a9cfd8d577f19a96/torchcodec-0.7.0-cp312-cp312-win_amd64.whl", hash = "sha256:ac942831bff02e6041d8718b71c6f63e4e37c05dd95e72863725c9dbef0d4a7b", size = 1565029, upload-time = "2025-09-08T14:18:02.83Z" }, + { url = "https://files.pythonhosted.org/packages/3c/82/7c7691d538f67704b2b2444deb0e234ae564f9329bc9becf66d69998bc9b/torchcodec-0.7.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:32a0115035a7f0a77fa451f67c101e0273a3a37d33b69e1bcd777f00aceb7340", size = 3537881, upload-time = "2025-09-08T14:17:54.254Z" }, + { url = "https://files.pythonhosted.org/packages/01/25/177ea01d138598ab68d5e3b000789e8617bf97874bd8f761d89093f419ba/torchcodec-0.7.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:9c70f910f9f48e6625aacaed534f766e13d447b895dc7299e96d4db9a93f1514", size = 1422493, upload-time = "2025-09-08T14:17:45.41Z" }, + { url = "https://files.pythonhosted.org/packages/5c/a9/e2b6301fbf4590d352e183bef64927f74ef4d4f660cca3ed7a32dda60484/torchcodec-0.7.0-cp313-cp313-win_amd64.whl", hash = "sha256:31b402c9ae3c6e9f33c41fddf7058f9492c443ad55d02f022395f8fa196b58f6", size = 1565405, upload-time = "2025-09-08T14:18:04.217Z" }, +] + +[[package]] +name = "tqdm" +version = "4.67.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/09/a9/6ba95a270c6f1fbcd8dac228323f2777d886cb206987444e4bce66338dd4/tqdm-4.67.3.tar.gz", hash = "sha256:7d825f03f89244ef73f1d4ce193cb1774a8179fd96f31d7e1dcde62092b960bb", size = 169598, upload-time = "2026-02-03T17:35:53.048Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/16/e1/3079a9ff9b8e11b846c6ac5c8b5bfb7ff225eee721825310c91b3b50304f/tqdm-4.67.3-py3-none-any.whl", hash = "sha256:ee1e4c0e59148062281c49d80b25b67771a127c85fc9676d3be5f243206826bf", size = 78374, upload-time = "2026-02-03T17:35:50.982Z" }, +] + +[[package]] +name = "traitlets" +version = "5.14.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/eb/79/72064e6a701c2183016abbbfedaba506d81e30e232a68c9f0d6f6fcd1574/traitlets-5.14.3.tar.gz", hash = "sha256:9ed0579d3502c94b4b3732ac120375cda96f923114522847de4b3bb98b96b6b7", size = 161621, upload-time = "2024-04-19T11:11:49.746Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/00/c0/8f5d070730d7836adc9c9b6408dec68c6ced86b304a9b26a14df072a6e8c/traitlets-5.14.3-py3-none-any.whl", hash = "sha256:b74e89e397b1ed28cc831db7aea759ba6640cb3de13090ca145426688ff1ac4f", size = 85359, upload-time = "2024-04-19T11:11:46.763Z" }, +] + +[[package]] +name = "triton" +version = "3.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "setuptools", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/7d/39/43325b3b651d50187e591eefa22e236b2981afcebaefd4f2fc0ea99df191/triton-3.4.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7b70f5e6a41e52e48cfc087436c8a28c17ff98db369447bcaff3b887a3ab4467", size = 155531138, upload-time = "2025-07-30T19:58:29.908Z" }, + { url = "https://files.pythonhosted.org/packages/d0/66/b1eb52839f563623d185f0927eb3530ee4d5ffe9d377cdaf5346b306689e/triton-3.4.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:31c1d84a5c0ec2c0f8e8a072d7fd150cab84a9c239eaddc6706c081bfae4eb04", size = 155560068, upload-time = "2025-07-30T19:58:37.081Z" }, + { url = "https://files.pythonhosted.org/packages/30/7b/0a685684ed5322d2af0bddefed7906674f67974aa88b0fae6e82e3b766f6/triton-3.4.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00be2964616f4c619193cb0d1b29a99bd4b001d7dc333816073f92cf2a8ccdeb", size = 155569223, upload-time = "2025-07-30T19:58:44.017Z" }, + { url = "https://files.pythonhosted.org/packages/20/63/8cb444ad5cdb25d999b7d647abac25af0ee37d292afc009940c05b82dda0/triton-3.4.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7936b18a3499ed62059414d7df563e6c163c5e16c3773678a3ee3d417865035d", size = 155659780, upload-time = "2025-07-30T19:58:51.171Z" }, +] + +[[package]] +name = "typing-extensions" +version = "4.15.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" }, +] + +[[package]] +name = "tzdata" +version = "2026.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ba/19/1b9b0e29f30c6d35cb345486df41110984ea67ae69dddbc0e8a100999493/tzdata-2026.2.tar.gz", hash = "sha256:9173fde7d80d9018e02a662e168e5a2d04f87c41ea174b139fbef642eda62d10", size = 198254, upload-time = "2026-04-24T15:22:08.651Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ce/e4/dccd7f47c4b64213ac01ef921a1337ee6e30e8c6466046018326977efd95/tzdata-2026.2-py2.py3-none-any.whl", hash = "sha256:bbe9af844f658da81a5f95019480da3a89415801f6cc966806612cc7169bffe7", size = 349321, upload-time = "2026-04-24T15:22:05.876Z" }, +] + +[[package]] +name = "urllib3" +version = "2.6.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c7/24/5f1b3bdffd70275f6661c76461e25f024d5a38a46f04aaca912426a2b1d3/urllib3-2.6.3.tar.gz", hash = "sha256:1b62b6884944a57dbe321509ab94fd4d3b307075e0c2eae991ac71ee15ad38ed", size = 435556, upload-time = "2026-01-07T16:24:43.925Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/39/08/aaaad47bc4e9dc8c725e68f9d04865dbcb2052843ff09c97b08904852d84/urllib3-2.6.3-py3-none-any.whl", hash = "sha256:bf272323e553dfb2e87d9bfd225ca7b0f467b919d7bbd355436d3fd37cb0acd4", size = 131584, upload-time = "2026-01-07T16:24:42.685Z" }, +] + +[[package]] +name = "wcwidth" +version = "0.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/2c/ee/afaf0f85a9a18fe47a67f1e4422ed6cf1fe642f0ae0a2f81166231303c52/wcwidth-0.7.0.tar.gz", hash = "sha256:90e3a7ea092341c44b99562e75d09e4d5160fe7a3974c6fb842a101a95e7eed0", size = 182132, upload-time = "2026-05-02T16:04:12.653Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/41/52/e465037f5375f43533d1a80b6923955201596a99142ed524d77b571a1418/wcwidth-0.7.0-py3-none-any.whl", hash = "sha256:5d69154c429a82910e241c738cd0e2976fac8a2dd47a1a805f4afed1c0f136f2", size = 110825, upload-time = "2026-05-02T16:04:11.033Z" }, +] + +[[package]] +name = "webrtcvad" +version = "2.0.10" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/89/34/e2de2d97f3288512b9ea56f92e7452f8207eb5a0096500badf9dfd48f5e6/webrtcvad-2.0.10.tar.gz", hash = "sha256:f1bed2fb25b63fb7b1a55d64090c993c9c9167b28485ae0bcdd81cf6ede96aea", size = 66156, upload-time = "2017-01-07T23:05:18.732Z" } + +[[package]] +name = "werkzeug" +version = "3.1.8" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markupsafe" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/dd/b2/381be8cfdee792dd117872481b6e378f85c957dd7c5bca38897b08f765fd/werkzeug-3.1.8.tar.gz", hash = "sha256:9bad61a4268dac112f1c5cd4630a56ede601b6ed420300677a869083d70a4c44", size = 875852, upload-time = "2026-04-02T18:49:14.268Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/93/8c/2e650f2afeb7ee576912636c23ddb621c91ac6a98e66dc8d29c3c69446e1/werkzeug-3.1.8-py3-none-any.whl", hash = "sha256:63a77fb8892bf28ebc3178683445222aa500e48ebad5ec77b0ad80f8726b1f50", size = 226459, upload-time = "2026-04-02T18:49:12.72Z" }, +]