diff --git a/.gitattributes b/.gitattributes index 40be2afbc15b7b218391d78c3380ef661be772a2..d3e5d14906d06490c6940cb8f1e3e5e084a68e18 100644 --- a/.gitattributes +++ b/.gitattributes @@ -49,3 +49,10 @@ models/ailia-models/code/babble_15dB.wav filter=lfs diff=lfs merge=lfs -text models/ailia-models/code/denoised.wav filter=lfs diff=lfs merge=lfs -text models/rnnoise-wrapper/weights_5h_b_500k.hdf5 filter=lfs diff=lfs merge=lfs -text models/rnnoise-wrapper/weights_5h_ru_500k.hdf5 filter=lfs diff=lfs merge=lfs -text +models/WaveRNNModel/assets/tacotron_wavernn.png filter=lfs diff=lfs merge=lfs -text +models/WaveRNNModel/assets/training_viz.gif filter=lfs diff=lfs merge=lfs -text +models/WaveRNNModel/assets/wavernn_alt_model_hrz2.png filter=lfs diff=lfs merge=lfs -text +models/WaveRNNModel/notebooks/outputs/nb2/3k_steps.wav filter=lfs diff=lfs merge=lfs -text +models/WaveRNNModel/notebooks/outputs/nb3/12k_steps.wav filter=lfs diff=lfs merge=lfs -text +models/WaveRNNModel/quick_start/tts_weights/latest_weights.pyt filter=lfs diff=lfs merge=lfs -text +models/WaveRNNModel/quick_start/voc_weights/latest_weights.pyt filter=lfs diff=lfs merge=lfs -text diff --git a/models/WaveRNNModel/.gitattributes b/models/WaveRNNModel/.gitattributes new file mode 100644 index 0000000000000000000000000000000000000000..327ba52a0eefacdcd8ce408556858f640b11b328 --- /dev/null +++ b/models/WaveRNNModel/.gitattributes @@ -0,0 +1 @@ +*.ipynb linguist-language=Python \ No newline at end of file diff --git a/models/WaveRNNModel/.gitignore b/models/WaveRNNModel/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..f9ba1dcf91baa1b2016d48856985a0ce325157a8 --- /dev/null +++ b/models/WaveRNNModel/.gitignore @@ -0,0 +1,48 @@ +# IDE files +.idea +.vscode + +# Mac files +.DS_Store + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +pip-wheel-metadata/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Jupyter Notebook +.ipynb_checkpoints diff --git a/models/WaveRNNModel/LICENSE.txt b/models/WaveRNNModel/LICENSE.txt new file mode 100644 index 0000000000000000000000000000000000000000..c37d3b1c09f1325a05d5a623bd43607bec339fbb --- /dev/null +++ b/models/WaveRNNModel/LICENSE.txt @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2019 fatchord (https://github.com/fatchord) + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/models/WaveRNNModel/README.md b/models/WaveRNNModel/README.md new file mode 100644 index 0000000000000000000000000000000000000000..e9a901210671cceb709c0cf9c34d63627f22e242 --- /dev/null +++ b/models/WaveRNNModel/README.md @@ -0,0 +1,102 @@ +# WaveRNN + +##### (Update: Vanilla Tacotron One TTS system just implemented - more coming soon!) + +![Tacotron with WaveRNN diagrams](assets/tacotron_wavernn.png) + +Pytorch implementation of Deepmind's WaveRNN model from [Efficient Neural Audio Synthesis](https://arxiv.org/abs/1802.08435v1) + +# Installation + +Ensure you have: + +* Python >= 3.6 +* [Pytorch 1 with CUDA](https://pytorch.org/) + +Then install the rest with pip: + +> pip install -r requirements.txt + +# How to Use + +### Quick Start + +If you want to use TTS functionality immediately you can simply use: + +> python quick_start.py + +This will generate everything in the default sentences.txt file and output to a new 'quick_start' folder where you can playback the wav files and take a look at the attention plots + +You can also use that script to generate custom tts sentences and/or use '-u' to generate unbatched (better audio quality): + +> python quick_start.py -u --input_text "What will happen if I run this command?" + + +### Training your own Models +![Attenion and Mel Training GIF](assets/training_viz.gif) + +Download the [LJSpeech](https://keithito.com/LJ-Speech-Dataset/) Dataset. + +Edit **hparams.py**, point **wav_path** to your dataset and run: + +> python preprocess.py + +or use preprocess.py --path to point directly to the dataset +___ + +Here's my recommendation on what order to run things: + +1 - Train Tacotron with: + +> python train_tacotron.py + +2 - You can leave that finish training or at any point you can use: + +> python train_tacotron.py --force_gta + +this will force tactron to create a GTA dataset even if it hasn't finish training. + +3 - Train WaveRNN with: + +> python train_wavernn.py --gta + +NB: You can always just run train_wavernn.py without --gta if you're not interested in TTS. + +4 - Generate Sentences with both models using: + +> python gen_tacotron.py wavernn + +this will generate default sentences. If you want generate custom sentences you can use + +> python gen_tacotron.py --input_text "this is whatever you want it to be" wavernn + +And finally, you can always use --help on any of those scripts to see what options are available :) + + + +# Samples + +[Can be found here.](https://fatchord.github.io/model_outputs/) + +# Pretrained Models + +Currently there are two pretrained models available in the /pretrained/ folder': + +Both are trained on LJSpeech + +* WaveRNN (Mixture of Logistics output) trained to 800k steps +* Tacotron trained to 180k steps + +____ + +### References + +* [Efficient Neural Audio Synthesis](https://arxiv.org/abs/1802.08435v1) +* [Tacotron: Towards End-to-End Speech Synthesis](https://arxiv.org/abs/1703.10135) +* [Natural TTS Synthesis by Conditioning WaveNet on Mel Spectrogram Predictions](https://arxiv.org/abs/1712.05884) + +### Acknowlegements + +* [https://github.com/keithito/tacotron](https://github.com/keithito/tacotron) +* [https://github.com/r9y9/wavenet_vocoder](https://github.com/r9y9/wavenet_vocoder) +* Special thanks to github users [G-Wang](https://github.com/G-Wang), [geneing](https://github.com/geneing) & [erogol](https://github.com/erogol) diff --git a/models/WaveRNNModel/__init__.py b/models/WaveRNNModel/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..5d331f1f5eb0fd0e48986f0fdb00f0293e6618a4 --- /dev/null +++ b/models/WaveRNNModel/__init__.py @@ -0,0 +1,13 @@ +import sys +import os +from pathlib import Path + +# 获取当前包的绝对路径(即 WaveRNN_master 的目录) +package_dir = Path(__file__).resolve().parent + +# 将该路径加入 sys.path,使其成为模块搜索的根目录 +if str(package_dir) not in sys.path: + sys.path.insert(0, str(package_dir)) + +# 设置环境变量 PYTHONPATH(可选,增强兼容性) +os.environ["PYTHONPATH"] = str(package_dir) + os.pathsep + os.environ.get("PYTHONPATH", "") diff --git a/models/WaveRNNModel/assets/WaveRNN.png b/models/WaveRNNModel/assets/WaveRNN.png new file mode 100644 index 0000000000000000000000000000000000000000..ddd4b2f529d79dea38f8c5c5340289dd6e01a5a9 Binary files /dev/null and b/models/WaveRNNModel/assets/WaveRNN.png differ diff --git a/models/WaveRNNModel/assets/tacotron_wavernn.png b/models/WaveRNNModel/assets/tacotron_wavernn.png new file mode 100644 index 0000000000000000000000000000000000000000..33a361637841b8643a77ca56166f0ea90dec969d --- /dev/null +++ b/models/WaveRNNModel/assets/tacotron_wavernn.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1357e893810079e088224833c4677bdf59eb7b3a3ea52e0836ef5ab3d2c73544 +size 203216 diff --git a/models/WaveRNNModel/assets/training_viz.gif b/models/WaveRNNModel/assets/training_viz.gif new file mode 100644 index 0000000000000000000000000000000000000000..ad61ec182d4881fb05ec5f44fbf67040296d1bf7 --- /dev/null +++ b/models/WaveRNNModel/assets/training_viz.gif @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:73728a59e80755d3e924b060ec8c88f4d1e91aa0469f7e18240cf869deb88aca +size 8581148 diff --git a/models/WaveRNNModel/assets/wavernn_alt_model_hrz2.png b/models/WaveRNNModel/assets/wavernn_alt_model_hrz2.png new file mode 100644 index 0000000000000000000000000000000000000000..22d544b471605ebae359db28b0aaf6511ed1888a --- /dev/null +++ b/models/WaveRNNModel/assets/wavernn_alt_model_hrz2.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:31b5fb4a0b8a5bce580719f699707be9f2b36d7671269b840b975750a3bec827 +size 200144 diff --git a/models/WaveRNNModel/data/dataset.pkl b/models/WaveRNNModel/data/dataset.pkl new file mode 100644 index 0000000000000000000000000000000000000000..06d185dc25bc0e5cff4f43d828179bfeba9033b2 --- /dev/null +++ b/models/WaveRNNModel/data/dataset.pkl @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5f323c9bfdfcd5709ad210f538851303c62f63e4285acaee1af791d7da671d88 +size 234790 diff --git a/models/WaveRNNModel/data/text_dict.pkl b/models/WaveRNNModel/data/text_dict.pkl new file mode 100644 index 0000000000000000000000000000000000000000..4bfa0bdf49d29f0cf8231508a0a13b780aaf90a3 --- /dev/null +++ b/models/WaveRNNModel/data/text_dict.pkl @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3a9c7752b430df10a503697b4c563a7ce82cbf732ca211dfeed5d0bffae6e5a6 +size 1531658 diff --git a/models/WaveRNNModel/gen_tacotron.py b/models/WaveRNNModel/gen_tacotron.py new file mode 100644 index 0000000000000000000000000000000000000000..f1fce6de18e62d1cfa3e0d0b3653606f5fcb96b0 --- /dev/null +++ b/models/WaveRNNModel/gen_tacotron.py @@ -0,0 +1,178 @@ +import torch +from models.fatchord_version import WaveRNN +from utils import hparams as hp +from utils.text.symbols import symbols +from utils.paths import Paths +from models.tacotron import Tacotron +import argparse +from utils.text import text_to_sequence +from utils.display import save_attention, simple_table +from utils.dsp import reconstruct_waveform, save_wav +import numpy as np + +def gen_tacotron_from_inputtext(args_list=None): + # Parse Arguments + parser = argparse.ArgumentParser(description='TTS Generator') + parser.add_argument('--input_text', '-i', type=str, help='[string] Type in something here and TTS will generate it!') + parser.add_argument('--tts_weights', type=str, help='[string/path] Load in different Tacotron weights') + parser.add_argument('--save_attention', '-a', dest='save_attn', action='store_true', help='Save Attention Plots') + parser.add_argument('--force_cpu', '-c', action='store_true', help='Forces CPU-only training, even when in CUDA capable environment') + parser.add_argument('--hp_file', metavar='FILE', default='hparams.py', help='The file to use for the hyperparameters') + + parser.set_defaults(input_text=None) + parser.set_defaults(weights_path=None) + + # name of subcommand goes to args.vocoder + subparsers = parser.add_subparsers(required=True, dest='vocoder') + + wr_parser = subparsers.add_parser('wavernn', aliases=['wr']) + wr_parser.add_argument('--batched', '-b', dest='batched', action='store_true', help='Fast Batched Generation') + wr_parser.add_argument('--unbatched', '-u', dest='batched', action='store_false', help='Slow Unbatched Generation') + wr_parser.add_argument('--overlap', '-o', type=int, help='[int] number of crossover samples') + wr_parser.add_argument('--target', '-t', type=int, help='[int] number of samples in each batch index') + wr_parser.add_argument('--voc_weights', type=str, help='[string/path] Load in different WaveRNN weights') + wr_parser.set_defaults(batched=None) + + gl_parser = subparsers.add_parser('griffinlim', aliases=['gl']) + gl_parser.add_argument('--iters', type=int, default=32, help='[int] number of griffinlim iterations') + + args = parser.parse_args(args=args_list) + + if args.vocoder in ['griffinlim', 'gl']: + args.vocoder = 'griffinlim' + elif args.vocoder in ['wavernn', 'wr']: + args.vocoder = 'wavernn' + else: + raise argparse.ArgumentError('Must provide a valid vocoder type!') + + if not hp.is_configured(): + print("args.hp_file:",args.hp_file) + hp.configure(args.hp_file) # Load hparams from file + # set defaults for any arguments that depend on hparams + if args.vocoder == 'wavernn': + if args.target is None: + args.target = hp.voc_target + if args.overlap is None: + args.overlap = hp.voc_overlap + if args.batched is None: + args.batched = hp.voc_gen_batched + + batched = args.batched + target = args.target + overlap = args.overlap + + input_text = args.input_text + tts_weights = args.tts_weights + save_attn = args.save_attn + + paths = Paths(hp.data_path, hp.voc_model_id, hp.tts_model_id) + + if not args.force_cpu and torch.cuda.is_available(): + device = torch.device('cuda') + else: + device = torch.device('cpu') + print('Using device:', device) + + if args.vocoder == 'wavernn': + print('\nInitialising WaveRNN Model...\n') + # Instantiate WaveRNN Model + voc_model = WaveRNN(rnn_dims=hp.voc_rnn_dims, + fc_dims=hp.voc_fc_dims, + bits=hp.bits, + pad=hp.voc_pad, + upsample_factors=hp.voc_upsample_factors, + feat_dims=hp.num_mels, + compute_dims=hp.voc_compute_dims, + res_out_dims=hp.voc_res_out_dims, + res_blocks=hp.voc_res_blocks, + hop_length=hp.hop_length, + sample_rate=hp.sample_rate, + mode=hp.voc_mode).to(device) + + voc_load_path = args.voc_weights if args.voc_weights else paths.voc_latest_weights + voc_model.load(voc_load_path) + + print('\nInitialising Tacotron Model...\n') + + # Instantiate Tacotron Model + tts_model = Tacotron(embed_dims=hp.tts_embed_dims, + num_chars=len(symbols), + encoder_dims=hp.tts_encoder_dims, + decoder_dims=hp.tts_decoder_dims, + n_mels=hp.num_mels, + fft_bins=hp.num_mels, + postnet_dims=hp.tts_postnet_dims, + encoder_K=hp.tts_encoder_K, + lstm_dims=hp.tts_lstm_dims, + postnet_K=hp.tts_postnet_K, + num_highways=hp.tts_num_highways, + dropout=hp.tts_dropout, + stop_threshold=hp.tts_stop_threshold).to(device) + + tts_load_path = tts_weights if tts_weights else paths.tts_latest_weights + tts_model.load(tts_load_path) + + if input_text: + inputs = [text_to_sequence(input_text.strip(), hp.tts_cleaner_names)] + else: + with open('sentences.txt') as f: + inputs = [text_to_sequence(l.strip(), hp.tts_cleaner_names) for l in f] + + if args.vocoder == 'wavernn': + voc_k = voc_model.get_step() // 1000 + tts_k = tts_model.get_step() // 1000 + + simple_table([('Tacotron', str(tts_k) + 'k'), + ('r', tts_model.r), + ('Vocoder Type', 'WaveRNN'), + ('WaveRNN', str(voc_k) + 'k'), + ('Generation Mode', 'Batched' if batched else 'Unbatched'), + ('Target Samples', target if batched else 'N/A'), + ('Overlap Samples', overlap if batched else 'N/A')]) + + elif args.vocoder == 'griffinlim': + tts_k = tts_model.get_step() // 1000 + simple_table([('Tacotron', str(tts_k) + 'k'), + ('r', tts_model.r), + ('Vocoder Type', 'Griffin-Lim'), + ('GL Iters', args.iters)]) + + for i, x in enumerate(inputs, 1): + + print(f'\n| Generating {i}/{len(inputs)}') + _, m, attention = tts_model.generate(x) + # Fix mel spectrogram scaling to be from 0 to 1 + m = (m + 4) / 8 + np.clip(m, 0, 1, out=m) + + if args.vocoder == 'griffinlim': + v_type = args.vocoder + elif args.vocoder == 'wavernn' and args.batched: + v_type = 'wavernn_batched' + else: + v_type = 'wavernn_unbatched' + + if input_text: + print("path:",paths.tts_output) + save_path = paths.tts_output/f'__input_{input_text[:10]}_{v_type}_{tts_k}k.wav' + else: + print("path:",paths.tts_output) + save_path = paths.tts_output/f'{i}_{v_type}_{tts_k}k.wav' + + if save_attn: save_attention(attention, save_path) + + if args.vocoder == 'wavernn': + m = torch.tensor(m).unsqueeze(0) + voc_model.generate(m, save_path, batched, hp.voc_target, hp.voc_overlap, hp.mu_law) + elif args.vocoder == 'griffinlim': + wav = reconstruct_waveform(m, n_iter=args.iters) + save_wav(wav, save_path) + + print('\n\nDone.\n') + return save_path + + + +if __name__ == "__main__": + + gen_tacotron_from_inputtext() \ No newline at end of file diff --git a/models/WaveRNNModel/gen_wavernn.py b/models/WaveRNNModel/gen_wavernn.py new file mode 100644 index 0000000000000000000000000000000000000000..dfbb4639bff4844257bb01425fba886f488eb31f --- /dev/null +++ b/models/WaveRNNModel/gen_wavernn.py @@ -0,0 +1,142 @@ +from utils.dataset import get_vocoder_datasets +from utils.dsp import * +from models.fatchord_version import WaveRNN +from utils.paths import Paths +from utils.display import simple_table +import torch +import argparse +from pathlib import Path + + +def gen_testset(model: WaveRNN, test_set, samples, batched, target, overlap, save_path: Path): + + k = model.get_step() // 1000 + + for i, (m, x) in enumerate(test_set, 1): + + if i > samples: break + + print('\n| Generating: %i/%i' % (i, samples)) + + x = x[0].numpy() + + bits = 16 if hp.voc_mode == 'MOL' else hp.bits + + if hp.mu_law and hp.voc_mode != 'MOL': + x = decode_mu_law(x, 2**bits, from_labels=True) + else: + x = label_2_float(x, bits) + + save_wav(x, save_path/f'{k}k_steps_{i}_target.wav') + + batch_str = f'gen_batched_target{target}_overlap{overlap}' if batched else 'gen_NOT_BATCHED' + save_str = str(save_path/f'{k}k_steps_{i}_{batch_str}.wav') + + _ = model.generate(m, save_str, batched, target, overlap, hp.mu_law) + + +def gen_from_file(model: WaveRNN, load_path: Path, save_path: Path, batched, target, overlap): + + k = model.get_step() // 1000 + file_name = load_path.stem + + suffix = load_path.suffix + if suffix == ".wav": + wav = load_wav(load_path) + save_wav(wav, save_path/f'__{file_name}__{k}k_steps_target.wav') + mel = melspectrogram(wav) + elif suffix == ".npy": + mel = np.load(load_path) + if mel.ndim != 2 or mel.shape[0] != hp.num_mels: + raise ValueError(f'Expected a numpy array shaped (n_mels, n_hops), but got {wav.shape}!') + _max = np.max(mel) + _min = np.min(mel) + if _max >= 1.01 or _min <= -0.01: + raise ValueError(f'Expected spectrogram range in [0,1] but was instead [{_min}, {_max}]') + else: + raise ValueError(f"Expected an extension of .wav or .npy, but got {suffix}!") + + + mel = torch.tensor(mel).unsqueeze(0) + + batch_str = f'gen_batched_target{target}_overlap{overlap}' if batched else 'gen_NOT_BATCHED' + save_str = save_path/f'__{file_name}__{k}k_steps_{batch_str}.wav' + + _ = model.generate(mel, save_str, batched, target, overlap, hp.mu_law) + + +if __name__ == "__main__": + + parser = argparse.ArgumentParser(description='Generate WaveRNN Samples') + parser.add_argument('--batched', '-b', dest='batched', action='store_true', help='Fast Batched Generation') + parser.add_argument('--unbatched', '-u', dest='batched', action='store_false', help='Slow Unbatched Generation') + parser.add_argument('--samples', '-s', type=int, help='[int] number of utterances to generate') + parser.add_argument('--target', '-t', type=int, help='[int] number of samples in each batch index') + parser.add_argument('--overlap', '-o', type=int, help='[int] number of crossover samples') + parser.add_argument('--file', '-f', type=str, help='[string/path] for testing a wav outside dataset') + parser.add_argument('--voc_weights', '-w', type=str, help='[string/path] Load in different WaveRNN weights') + parser.add_argument('--gta', '-g', dest='gta', action='store_true', help='Generate from GTA testset') + parser.add_argument('--force_cpu', '-c', action='store_true', help='Forces CPU-only training, even when in CUDA capable environment') + parser.add_argument('--hp_file', metavar='FILE', default='hparams.py', help='The file to use for the hyperparameters') + + parser.set_defaults(batched=None) + + args = parser.parse_args() + + hp.configure(args.hp_file) # Load hparams from file + # set defaults for any arguments that depend on hparams + if args.target is None: + args.target = hp.voc_target + if args.overlap is None: + args.overlap = hp.voc_overlap + if args.batched is None: + args.batched = hp.voc_gen_batched + if args.samples is None: + args.samples = hp.voc_gen_at_checkpoint + + batched = args.batched + samples = args.samples + target = args.target + overlap = args.overlap + file = args.file + gta = args.gta + + if not args.force_cpu and torch.cuda.is_available(): + device = torch.device('cuda') + else: + device = torch.device('cpu') + print('Using device:', device) + + print('\nInitialising Model...\n') + + model = WaveRNN(rnn_dims=hp.voc_rnn_dims, + fc_dims=hp.voc_fc_dims, + bits=hp.bits, + pad=hp.voc_pad, + upsample_factors=hp.voc_upsample_factors, + feat_dims=hp.num_mels, + compute_dims=hp.voc_compute_dims, + res_out_dims=hp.voc_res_out_dims, + res_blocks=hp.voc_res_blocks, + hop_length=hp.hop_length, + sample_rate=hp.sample_rate, + mode=hp.voc_mode).to(device) + + paths = Paths(hp.data_path, hp.voc_model_id, hp.tts_model_id) + + voc_weights = args.voc_weights if args.voc_weights else paths.voc_latest_weights + + model.load(voc_weights) + + simple_table([('Generation Mode', 'Batched' if batched else 'Unbatched'), + ('Target Samples', target if batched else 'N/A'), + ('Overlap Samples', overlap if batched else 'N/A')]) + + if file: + file = Path(file).expanduser() + gen_from_file(model, file, paths.voc_output, batched, target, overlap) + else: + _, test_set = get_vocoder_datasets(paths.data, 1, gta) + gen_testset(model, test_set, samples, batched, target, overlap, paths.voc_output) + + print('\n\nExiting...\n') diff --git a/models/WaveRNNModel/hparams.py b/models/WaveRNNModel/hparams.py new file mode 100644 index 0000000000000000000000000000000000000000..1ef1609b1d7e788119cf902f95e1be0d0734671d --- /dev/null +++ b/models/WaveRNNModel/hparams.py @@ -0,0 +1,101 @@ + +# CONFIG -----------------------------------------------------------------------------------------------------------# + +# Here are the input and output data paths (Note: you can override wav_path in preprocess.py) +wav_path = 'E:\\智能语音处理系统\\Noise-suppression-and-speech-recognition-systems-master\\WaveRNNModel\\data\\LJSpeech-1.1\\wavs' +data_path = 'E:\\智能语音处理系统\\Noise-suppression-and-speech-recognition-systems-master\\WaveRNNModel\\data' + +# model ids are separate - that way you can use a new tts with an old wavernn and vice versa +# NB: expect undefined behaviour if models were trained on different DSP settings +voc_model_id = 'ljspeech_mol' +tts_model_id = 'ljspeech_lsa_smooth_attention' + +# set this to True if you are only interested in WaveRNN +ignore_tts = False + + +# DSP --------------------------------------------------------------------------------------------------------------# + +# Settings for all models +sample_rate = 22050 +n_fft = 2048 +fft_bins = n_fft // 2 + 1 +num_mels = 80 +hop_length = 275 # 12.5ms - in line with Tacotron 2 paper +win_length = 1100 # 50ms - same reason as above +fmin = 40 +min_level_db = -100 +ref_level_db = 20 +bits = 9 # bit depth of signal +mu_law = True # Recommended to suppress noise if using raw bits in hp.voc_mode below +peak_norm = False # Normalise to the peak of each wav file + + +# WAVERNN / VOCODER ------------------------------------------------------------------------------------------------# + + +# Model Hparams +voc_mode = 'MOL' # either 'RAW' (softmax on raw bits) or 'MOL' (sample from mixture of logistics) +voc_upsample_factors = (5, 5, 11) # NB - this needs to correctly factorise hop_length +voc_rnn_dims = 512 +voc_fc_dims = 512 +voc_compute_dims = 128 +voc_res_out_dims = 128 +voc_res_blocks = 10 + +# Training +voc_batch_size = 32 +voc_lr = 1e-4 +voc_checkpoint_every = 25_000 +voc_gen_at_checkpoint = 5 # number of samples to generate at each checkpoint +voc_total_steps = 1_000_000 # Total number of training steps +voc_test_samples = 50 # How many unseen samples to put aside for testing +voc_pad = 2 # this will pad the input so that the resnet can 'see' wider than input length +voc_seq_len = hop_length * 5 # must be a multiple of hop_length +voc_clip_grad_norm = 4 # set to None if no gradient clipping needed + +# Generating / Synthesizing +voc_gen_batched = True # very fast (realtime+) single utterance batched generation +voc_target = 11_000 # target number of samples to be generated in each batch entry +voc_overlap = 550 # number of samples for crossfading between batches + + +# TACOTRON/TTS -----------------------------------------------------------------------------------------------------# + + +# Model Hparams +tts_embed_dims = 256 # embedding dimension for the graphemes/phoneme inputs +tts_encoder_dims = 128 +tts_decoder_dims = 256 +tts_postnet_dims = 128 +tts_encoder_K = 16 +tts_lstm_dims = 512 +tts_postnet_K = 8 +tts_num_highways = 4 +tts_dropout = 0.5 +tts_cleaner_names = ['english_cleaners'] +tts_stop_threshold = -3.4 # Value below which audio generation ends. + # For example, for a range of [-4, 4], this + # will terminate the sequence at the first + # frame that has all values < -3.4 + +# Training + +#tts_schedule = [(7, 1e-3, 10_000, 32), # progressive training schedule +# (5, 1e-4, 100_000, 32), # (r, lr, step, batch_size) +# (2, 1e-4, 180_000, 16), +# (2, 1e-4, 350_000, 8)] +tts_schedule = [(7, 1e-3, 10_000, 32)] # progressive training schedule + #(5, 1e-4, 100_000, 64), # (r, lr, step, batch_size) + #(2, 1e-4, 180_000, 64), + #(2, 1e-4, 350_000, 64)] + +tts_max_mel_len = 1250 # if you have a couple of extremely long spectrograms you might want to use this +tts_bin_lengths = True # bins the spectrogram lengths before sampling in data loader - speeds up training +tts_clip_grad_norm = 1.0 # clips the gradient norm to prevent explosion - set to None if not needed +tts_checkpoint_every = 2_000 # checkpoints the model every X steps +# TODO: tts_phoneme_prob = 0.0 # [0 <-> 1] probability for feeding model phonemes vrs graphemes + + +# ------------------------------------------------------------------------------------------------------------------# + diff --git a/models/WaveRNNModel/loss_plot.py b/models/WaveRNNModel/loss_plot.py new file mode 100644 index 0000000000000000000000000000000000000000..ba265da8bc58763c063514a2cc1fe977f80967ac --- /dev/null +++ b/models/WaveRNNModel/loss_plot.py @@ -0,0 +1,70 @@ +import matplotlib.pyplot as plt +import re +import numpy as np + +# 设置中文字体 +plt.rcParams['font.sans-serif'] = ['SimHei'] # 简体中文(根据系统调整) +plt.rcParams['axes.unicode_minus'] = False # 解决负号显示问题 + +# 从txt文件读取日志数据 +def parse_log_file(file_path): + epochs = [] + losses = [] + + with open(file_path, 'r', encoding='utf-8') as f: + for line in f: + # 使用正则匹配有效行 + match = re.search( + r'Epoch:\s+(\d+)/*.*Loss:\s+(\d+\.\d+)', + line.strip() + ) + if match: + epoch = int(match.group(1)) + loss = float(match.group(2)) + epochs.append(epoch) + losses.append(loss) + + return epochs, losses + +# 文件路径 +log_file = "E:\\智能语音处理系统\\Noise-suppression-and-speech-recognition-systems-master\\WaveRNNModel\\checkpoints\\ljspeech_lsa_smooth_attention.tacotron\\log_test.txt" + +# 提取数据 +try: + epochs_read, losses = parse_log_file(log_file) + print(epochs_read) + epochs=np.arange(len(epochs_read)) + print(epochs) +except FileNotFoundError: + print(f"错误:文件 {log_file} 不存在,请检查路径!") + exit() +except Exception as e: + print(f"解析文件时出错: {str(e)}") + exit() + +# 绘制曲线 +plt.figure(figsize=(10, 6)) +plt.plot(epochs, losses, 'b-', linewidth=2, label='训练损失') + +# 图表美化 +plt.title('训练损失随轮次变化曲线', fontsize=14) +plt.xlabel('训练轮次 (Epoch)', fontsize=12) +plt.ylabel('损失值 (Loss)', fontsize=12) +#plt.xticks(range(1, len(epochs))) # 强制显示所有epoch刻度 +plt.grid(True, linestyle='--', alpha=0.7) +plt.legend() + +# 标注最低损失 +min_loss = min(losses) +min_idx = losses.index(min_loss) +plt.annotate( + f'最低损失: {min_loss:.3f}', + xy=(epochs[min_idx], min_loss), + xytext=(epochs[min_idx]-3, min_loss+0.1), + arrowprops=dict(arrowstyle='->', color='red'), + fontsize=10, + color='red' +) + +plt.tight_layout() +plt.show() \ No newline at end of file diff --git a/models/WaveRNNModel/model_outputs/ljspeech_lsa_smooth_attention.tacotron.zip b/models/WaveRNNModel/model_outputs/ljspeech_lsa_smooth_attention.tacotron.zip new file mode 100644 index 0000000000000000000000000000000000000000..069978d058605d7894e041b3676049f07485f3f5 --- /dev/null +++ b/models/WaveRNNModel/model_outputs/ljspeech_lsa_smooth_attention.tacotron.zip @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ed4c5cc52ae740080b0bcea155133d430f01dcb1a2d0097ff9aaef9ee698886a +size 45040845 diff --git a/models/WaveRNNModel/model_outputs/ljspeech_mol.wavernn.zip b/models/WaveRNNModel/model_outputs/ljspeech_mol.wavernn.zip new file mode 100644 index 0000000000000000000000000000000000000000..f649d5dd4df4c5eac08c74e4b28bca0a659ef52c --- /dev/null +++ b/models/WaveRNNModel/model_outputs/ljspeech_mol.wavernn.zip @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:78a9cff91b58f6163f4cc9e9e878961829f07c7bf40e71778f0bf5447a4900fc +size 15610590 diff --git a/models/WaveRNNModel/models/__init__.py b/models/WaveRNNModel/models/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/models/WaveRNNModel/models/deepmind_version.py b/models/WaveRNNModel/models/deepmind_version.py new file mode 100644 index 0000000000000000000000000000000000000000..569d548345ba4a2f969ee0a5a100a0e5737d4a72 --- /dev/null +++ b/models/WaveRNNModel/models/deepmind_version.py @@ -0,0 +1,176 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F +from utils.display import * +from utils.dsp import * +import numpy as np + +class WaveRNN(nn.Module): + def __init__(self, hidden_size=896, quantisation=256): + super(WaveRNN, self).__init__() + + self.hidden_size = hidden_size + self.split_size = hidden_size // 2 + + # The main matmul + self.R = nn.Linear(self.hidden_size, 3 * self.hidden_size, bias=False) + + # Output fc layers + self.O1 = nn.Linear(self.split_size, self.split_size) + self.O2 = nn.Linear(self.split_size, quantisation) + self.O3 = nn.Linear(self.split_size, self.split_size) + self.O4 = nn.Linear(self.split_size, quantisation) + + # Input fc layers + self.I_coarse = nn.Linear(2, 3 * self.split_size, bias=False) + self.I_fine = nn.Linear(3, 3 * self.split_size, bias=False) + + # biases for the gates + self.bias_u = nn.Parameter(torch.zeros(self.hidden_size)) + self.bias_r = nn.Parameter(torch.zeros(self.hidden_size)) + self.bias_e = nn.Parameter(torch.zeros(self.hidden_size)) + + # display num params + self.num_params() + + + def forward(self, prev_y, prev_hidden, current_coarse): + + # Main matmul - the projection is split 3 ways + R_hidden = self.R(prev_hidden) + R_u, R_r, R_e, = torch.split(R_hidden, self.hidden_size, dim=1) + + # Project the prev input + coarse_input_proj = self.I_coarse(prev_y) + I_coarse_u, I_coarse_r, I_coarse_e = \ + torch.split(coarse_input_proj, self.split_size, dim=1) + + # Project the prev input and current coarse sample + fine_input = torch.cat([prev_y, current_coarse], dim=1) + fine_input_proj = self.I_fine(fine_input) + I_fine_u, I_fine_r, I_fine_e = \ + torch.split(fine_input_proj, self.split_size, dim=1) + + # concatenate for the gates + I_u = torch.cat([I_coarse_u, I_fine_u], dim=1) + I_r = torch.cat([I_coarse_r, I_fine_r], dim=1) + I_e = torch.cat([I_coarse_e, I_fine_e], dim=1) + + # Compute all gates for coarse and fine + u = F.sigmoid(R_u + I_u + self.bias_u) + r = F.sigmoid(R_r + I_r + self.bias_r) + e = F.tanh(r * R_e + I_e + self.bias_e) + hidden = u * prev_hidden + (1. - u) * e + + # Split the hidden state + hidden_coarse, hidden_fine = torch.split(hidden, self.split_size, dim=1) + + # Compute outputs + out_coarse = self.O2(F.relu(self.O1(hidden_coarse))) + out_fine = self.O4(F.relu(self.O3(hidden_fine))) + + return out_coarse, out_fine, hidden + + + def generate(self, seq_len): + device = next(self.parameters()).device # use same device as parameters + + with torch.no_grad(): + + # First split up the biases for the gates + b_coarse_u, b_fine_u = torch.split(self.bias_u, self.split_size) + b_coarse_r, b_fine_r = torch.split(self.bias_r, self.split_size) + b_coarse_e, b_fine_e = torch.split(self.bias_e, self.split_size) + + # Lists for the two output seqs + c_outputs, f_outputs = [], [] + + # Some initial inputs + out_coarse = torch.tensor([0], dtype=torch.long, device=device) + out_fine = torch.tensor([0], dtype=torch.long, device=device) + + # We'll meed a hidden state + hidden = self.get_initial_hidden() + + # Need a clock for display + start = time.time() + + # Loop for generation + for i in range(seq_len): + + # Split into two hidden states + hidden_coarse, hidden_fine = \ + torch.split(hidden, self.split_size, dim=1) + + # Scale and concat previous predictions + out_coarse = out_coarse.unsqueeze(0).float() / 127.5 - 1. + out_fine = out_fine.unsqueeze(0).float() / 127.5 - 1. + prev_outputs = torch.cat([out_coarse, out_fine], dim=1) + + # Project input + coarse_input_proj = self.I_coarse(prev_outputs) + I_coarse_u, I_coarse_r, I_coarse_e = \ + torch.split(coarse_input_proj, self.split_size, dim=1) + + # Project hidden state and split 6 ways + R_hidden = self.R(hidden) + R_coarse_u , R_fine_u, \ + R_coarse_r, R_fine_r, \ + R_coarse_e, R_fine_e = torch.split(R_hidden, self.split_size, dim=1) + + # Compute the coarse gates + u = F.sigmoid(R_coarse_u + I_coarse_u + b_coarse_u) + r = F.sigmoid(R_coarse_r + I_coarse_r + b_coarse_r) + e = F.tanh(r * R_coarse_e + I_coarse_e + b_coarse_e) + hidden_coarse = u * hidden_coarse + (1. - u) * e + + # Compute the coarse output + out_coarse = self.O2(F.relu(self.O1(hidden_coarse))) + posterior = F.softmax(out_coarse, dim=1) + distrib = torch.distributions.Categorical(posterior) + out_coarse = distrib.sample() + c_outputs.append(out_coarse) + + # Project the [prev outputs and predicted coarse sample] + coarse_pred = out_coarse.float() / 127.5 - 1. + fine_input = torch.cat([prev_outputs, coarse_pred.unsqueeze(0)], dim=1) + fine_input_proj = self.I_fine(fine_input) + I_fine_u, I_fine_r, I_fine_e = \ + torch.split(fine_input_proj, self.split_size, dim=1) + + # Compute the fine gates + u = F.sigmoid(R_fine_u + I_fine_u + b_fine_u) + r = F.sigmoid(R_fine_r + I_fine_r + b_fine_r) + e = F.tanh(r * R_fine_e + I_fine_e + b_fine_e) + hidden_fine = u * hidden_fine + (1. - u) * e + + # Compute the fine output + out_fine = self.O4(F.relu(self.O3(hidden_fine))) + posterior = F.softmax(out_fine, dim=1) + distrib = torch.distributions.Categorical(posterior) + out_fine = distrib.sample() + f_outputs.append(out_fine) + + # Put the hidden state back together + hidden = torch.cat([hidden_coarse, hidden_fine], dim=1) + + # Display progress + speed = (i + 1) / (time.time() - start) + stream('Gen: %i/%i -- Speed: %i', (i + 1, seq_len, speed)) + + coarse = torch.stack(c_outputs).squeeze(1).cpu().data.numpy() + fine = torch.stack(f_outputs).squeeze(1).cpu().data.numpy() + output = combine_signal(coarse, fine) + + return output, coarse, fine + + def get_initial_hidden(self, batch_size=1): + device = next(self.parameters()).device # use same device as parameters + return torch.zeros(batch_size, self.hidden_size, device=device) + + def num_params(self, print_out=True): + parameters = filter(lambda p: p.requires_grad, self.parameters()) + parameters = sum([np.prod(p.size()) for p in parameters]) / 1_000_000 + if print_out: + print('Trainable Parameters: %.3f million' % parameters) + return parameters \ No newline at end of file diff --git a/models/WaveRNNModel/models/fatchord_version.py b/models/WaveRNNModel/models/fatchord_version.py new file mode 100644 index 0000000000000000000000000000000000000000..1ade0670697f1a0727a8c4a15c6a11192e9bd817 --- /dev/null +++ b/models/WaveRNNModel/models/fatchord_version.py @@ -0,0 +1,435 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F +from utils.distribution import sample_from_discretized_mix_logistic +from utils.display import * +from utils.dsp import * +import os +import numpy as np +from pathlib import Path +from typing import Union + + +class ResBlock(nn.Module): + def __init__(self, dims): + super().__init__() + self.conv1 = nn.Conv1d(dims, dims, kernel_size=1, bias=False) + self.conv2 = nn.Conv1d(dims, dims, kernel_size=1, bias=False) + self.batch_norm1 = nn.BatchNorm1d(dims) + self.batch_norm2 = nn.BatchNorm1d(dims) + + def forward(self, x): + residual = x + x = self.conv1(x) + x = self.batch_norm1(x) + x = F.relu(x) + x = self.conv2(x) + x = self.batch_norm2(x) + return x + residual + + +class MelResNet(nn.Module): + def __init__(self, res_blocks, in_dims, compute_dims, res_out_dims, pad): + super().__init__() + k_size = pad * 2 + 1 + self.conv_in = nn.Conv1d(in_dims, compute_dims, kernel_size=k_size, bias=False) + self.batch_norm = nn.BatchNorm1d(compute_dims) + self.layers = nn.ModuleList() + for i in range(res_blocks): + self.layers.append(ResBlock(compute_dims)) + self.conv_out = nn.Conv1d(compute_dims, res_out_dims, kernel_size=1) + + def forward(self, x): + x = self.conv_in(x) + x = self.batch_norm(x) + x = F.relu(x) + for f in self.layers: x = f(x) + x = self.conv_out(x) + return x + + +class Stretch2d(nn.Module): + def __init__(self, x_scale, y_scale): + super().__init__() + self.x_scale = x_scale + self.y_scale = y_scale + + def forward(self, x): + b, c, h, w = x.size() + x = x.unsqueeze(-1).unsqueeze(3) + x = x.repeat(1, 1, 1, self.y_scale, 1, self.x_scale) + return x.view(b, c, h * self.y_scale, w * self.x_scale) + + +class UpsampleNetwork(nn.Module): + def __init__(self, feat_dims, upsample_scales, compute_dims, + res_blocks, res_out_dims, pad): + super().__init__() + total_scale = np.cumproduct(upsample_scales)[-1] + self.indent = pad * total_scale + self.resnet = MelResNet(res_blocks, feat_dims, compute_dims, res_out_dims, pad) + self.resnet_stretch = Stretch2d(total_scale, 1) + self.up_layers = nn.ModuleList() + for scale in upsample_scales: + k_size = (1, scale * 2 + 1) + padding = (0, scale) + stretch = Stretch2d(scale, 1) + conv = nn.Conv2d(1, 1, kernel_size=k_size, padding=padding, bias=False) + conv.weight.data.fill_(1. / k_size[1]) + self.up_layers.append(stretch) + self.up_layers.append(conv) + + def forward(self, m): + aux = self.resnet(m).unsqueeze(1) + aux = self.resnet_stretch(aux) + aux = aux.squeeze(1) + m = m.unsqueeze(1) + for f in self.up_layers: m = f(m) + m = m.squeeze(1)[:, :, self.indent:-self.indent] + return m.transpose(1, 2), aux.transpose(1, 2) + + +class WaveRNN(nn.Module): + def __init__(self, rnn_dims, fc_dims, bits, pad, upsample_factors, + feat_dims, compute_dims, res_out_dims, res_blocks, + hop_length, sample_rate, mode='RAW'): + super().__init__() + self.mode = mode + self.pad = pad + if self.mode == 'RAW': + self.n_classes = 2 ** bits + elif self.mode == 'MOL': + self.n_classes = 30 + else: + RuntimeError("Unknown model mode value - ", self.mode) + + # List of rnns to call `flatten_parameters()` on + self._to_flatten = [] + + self.rnn_dims = rnn_dims + self.aux_dims = res_out_dims // 4 + self.hop_length = hop_length + self.sample_rate = sample_rate + + self.upsample = UpsampleNetwork(feat_dims, upsample_factors, compute_dims, res_blocks, res_out_dims, pad) + self.I = nn.Linear(feat_dims + self.aux_dims + 1, rnn_dims) + + self.rnn1 = nn.GRU(rnn_dims, rnn_dims, batch_first=True) + self.rnn2 = nn.GRU(rnn_dims + self.aux_dims, rnn_dims, batch_first=True) + self._to_flatten += [self.rnn1, self.rnn2] + + self.fc1 = nn.Linear(rnn_dims + self.aux_dims, fc_dims) + self.fc2 = nn.Linear(fc_dims + self.aux_dims, fc_dims) + self.fc3 = nn.Linear(fc_dims, self.n_classes) + + self.register_buffer('step', torch.zeros(1, dtype=torch.long)) + self.num_params() + + # Avoid fragmentation of RNN parameters and associated warning + self._flatten_parameters() + + def forward(self, x, mels): + device = next(self.parameters()).device # use same device as parameters + + # Although we `_flatten_parameters()` on init, when using DataParallel + # the model gets replicated, making it no longer guaranteed that the + # weights are contiguous in GPU memory. Hence, we must call it again + self._flatten_parameters() + + self.step += 1 + bsize = x.size(0) + h1 = torch.zeros(1, bsize, self.rnn_dims, device=device) + h2 = torch.zeros(1, bsize, self.rnn_dims, device=device) + mels, aux = self.upsample(mels) + + aux_idx = [self.aux_dims * i for i in range(5)] + a1 = aux[:, :, aux_idx[0]:aux_idx[1]] + a2 = aux[:, :, aux_idx[1]:aux_idx[2]] + a3 = aux[:, :, aux_idx[2]:aux_idx[3]] + a4 = aux[:, :, aux_idx[3]:aux_idx[4]] + + x = torch.cat([x.unsqueeze(-1), mels, a1], dim=2) + x = self.I(x) + res = x + x, _ = self.rnn1(x, h1) + + x = x + res + res = x + x = torch.cat([x, a2], dim=2) + x, _ = self.rnn2(x, h2) + + x = x + res + x = torch.cat([x, a3], dim=2) + x = F.relu(self.fc1(x)) + + x = torch.cat([x, a4], dim=2) + x = F.relu(self.fc2(x)) + return self.fc3(x) + + def generate(self, mels, save_path: Union[str, Path], batched, target, overlap, mu_law): + self.eval() + + device = next(self.parameters()).device # use same device as parameters + + mu_law = mu_law if self.mode == 'RAW' else False + + output = [] + start = time.time() + rnn1 = self.get_gru_cell(self.rnn1) + rnn2 = self.get_gru_cell(self.rnn2) + + with torch.no_grad(): + + mels = torch.as_tensor(mels, device=device) + wave_len = (mels.size(-1) - 1) * self.hop_length + mels = self.pad_tensor(mels.transpose(1, 2), pad=self.pad, side='both') + mels, aux = self.upsample(mels.transpose(1, 2)) + + if batched: + mels = self.fold_with_overlap(mels, target, overlap) + aux = self.fold_with_overlap(aux, target, overlap) + + b_size, seq_len, _ = mels.size() + + h1 = torch.zeros(b_size, self.rnn_dims, device=device) + h2 = torch.zeros(b_size, self.rnn_dims, device=device) + x = torch.zeros(b_size, 1, device=device) + + d = self.aux_dims + aux_split = [aux[:, :, d * i:d * (i + 1)] for i in range(4)] + + for i in range(seq_len): + + m_t = mels[:, i, :] + + a1_t, a2_t, a3_t, a4_t = \ + (a[:, i, :] for a in aux_split) + + x = torch.cat([x, m_t, a1_t], dim=1) + x = self.I(x) + h1 = rnn1(x, h1) + + x = x + h1 + inp = torch.cat([x, a2_t], dim=1) + h2 = rnn2(inp, h2) + + x = x + h2 + x = torch.cat([x, a3_t], dim=1) + x = F.relu(self.fc1(x)) + + x = torch.cat([x, a4_t], dim=1) + x = F.relu(self.fc2(x)) + + logits = self.fc3(x) + + if self.mode == 'MOL': + sample = sample_from_discretized_mix_logistic(logits.unsqueeze(0).transpose(1, 2)) + output.append(sample.view(-1)) + # x = torch.FloatTensor([[sample]]).cuda() + x = sample.transpose(0, 1) + + elif self.mode == 'RAW': + posterior = F.softmax(logits, dim=1) + distrib = torch.distributions.Categorical(posterior) + + sample = 2 * distrib.sample().float() / (self.n_classes - 1.) - 1. + output.append(sample) + x = sample.unsqueeze(-1) + else: + raise RuntimeError("Unknown model mode value - ", self.mode) + + if i % 100 == 0: self.gen_display(i, seq_len, b_size, start) + + output = torch.stack(output).transpose(0, 1) + output = output.cpu().numpy() + output = output.astype(np.float64) + + if mu_law: + output = decode_mu_law(output, self.n_classes, False) + + if batched: + output = self.xfade_and_unfold(output, target, overlap) + else: + output = output[0] + + # Fade-out at the end to avoid signal cutting out suddenly + fade_out = np.linspace(1, 0, 20 * self.hop_length) + output = output[:wave_len] + output[-20 * self.hop_length:] *= fade_out + + save_wav(output, save_path) + + self.train() + + return output + + + def gen_display(self, i, seq_len, b_size, start): + gen_rate = (i + 1) / (time.time() - start) * b_size / 1000 + pbar = progbar(i, seq_len) + msg = f'| {pbar} {i*b_size}/{seq_len*b_size} | Batch Size: {b_size} | Gen Rate: {gen_rate:.1f}kHz | ' + stream(msg) + + def get_gru_cell(self, gru): + gru_cell = nn.GRUCell(gru.input_size, gru.hidden_size) + gru_cell.weight_hh.data = gru.weight_hh_l0.data + gru_cell.weight_ih.data = gru.weight_ih_l0.data + gru_cell.bias_hh.data = gru.bias_hh_l0.data + gru_cell.bias_ih.data = gru.bias_ih_l0.data + return gru_cell + + def pad_tensor(self, x, pad, side='both'): + # NB - this is just a quick method i need right now + # i.e., it won't generalise to other shapes/dims + b, t, c = x.size() + total = t + 2 * pad if side == 'both' else t + pad + padded = torch.zeros(b, total, c, device=x.device) + if side == 'before' or side == 'both': + padded[:, pad:pad + t, :] = x + elif side == 'after': + padded[:, :t, :] = x + return padded + + def fold_with_overlap(self, x, target, overlap): + + ''' Fold the tensor with overlap for quick batched inference. + Overlap will be used for crossfading in xfade_and_unfold() + + Args: + x (tensor) : Upsampled conditioning features. + shape=(1, timesteps, features) + target (int) : Target timesteps for each index of batch + overlap (int) : Timesteps for both xfade and rnn warmup + + Return: + (tensor) : shape=(num_folds, target + 2 * overlap, features) + + Details: + x = [[h1, h2, ... hn]] + + Where each h is a vector of conditioning features + + Eg: target=2, overlap=1 with x.size(1)=10 + + folded = [[h1, h2, h3, h4], + [h4, h5, h6, h7], + [h7, h8, h9, h10]] + ''' + + _, total_len, features = x.size() + + # Calculate variables needed + num_folds = (total_len - overlap) // (target + overlap) + extended_len = num_folds * (overlap + target) + overlap + remaining = total_len - extended_len + + # Pad if some time steps poking out + if remaining != 0: + num_folds += 1 + padding = target + 2 * overlap - remaining + x = self.pad_tensor(x, padding, side='after') + + folded = torch.zeros(num_folds, target + 2 * overlap, features, device=x.device) + + # Get the values for the folded tensor + for i in range(num_folds): + start = i * (target + overlap) + end = start + target + 2 * overlap + folded[i] = x[:, start:end, :] + + return folded + + def xfade_and_unfold(self, y, target, overlap): + + ''' Applies a crossfade and unfolds into a 1d array. + + Args: + y (ndarry) : Batched sequences of audio samples + shape=(num_folds, target + 2 * overlap) + dtype=np.float64 + overlap (int) : Timesteps for both xfade and rnn warmup + + Return: + (ndarry) : audio samples in a 1d array + shape=(total_len) + dtype=np.float64 + + Details: + y = [[seq1], + [seq2], + [seq3]] + + Apply a gain envelope at both ends of the sequences + + y = [[seq1_in, seq1_target, seq1_out], + [seq2_in, seq2_target, seq2_out], + [seq3_in, seq3_target, seq3_out]] + + Stagger and add up the groups of samples: + + [seq1_in, seq1_target, (seq1_out + seq2_in), seq2_target, ...] + + ''' + + num_folds, length = y.shape + target = length - 2 * overlap + total_len = num_folds * (target + overlap) + overlap + + # Need some silence for the rnn warmup + silence_len = overlap // 2 + fade_len = overlap - silence_len + silence = np.zeros((silence_len), dtype=np.float64) + linear = np.ones((silence_len), dtype=np.float64) + + # Equal power crossfade + t = np.linspace(-1, 1, fade_len, dtype=np.float64) + fade_in = np.sqrt(0.5 * (1 + t)) + fade_out = np.sqrt(0.5 * (1 - t)) + + # Concat the silence to the fades + fade_in = np.concatenate([silence, fade_in]) + fade_out = np.concatenate([linear, fade_out]) + + # Apply the gain to the overlap samples + y[:, :overlap] *= fade_in + y[:, -overlap:] *= fade_out + + unfolded = np.zeros((total_len), dtype=np.float64) + + # Loop to add up all the samples + for i in range(num_folds): + start = i * (target + overlap) + end = start + target + 2 * overlap + unfolded[start:end] += y[i] + + return unfolded + + def get_step(self): + return self.step.data.item() + + def log(self, path, msg): + with open(path, 'a') as f: + print(msg, file=f) + + def load(self, path: Union[str, Path]): + # Use device of model params as location for loaded state + device = next(self.parameters()).device + self.load_state_dict(torch.load(path, map_location=device), strict=False) + + def save(self, path: Union[str, Path]): + # No optimizer argument because saving a model should not include data + # only relevant in the training process - it should only be properties + # of the model itself. Let caller take care of saving optimzier state. + torch.save(self.state_dict(), path) + + def num_params(self, print_out=True): + parameters = filter(lambda p: p.requires_grad, self.parameters()) + parameters = sum([np.prod(p.size()) for p in parameters]) / 1_000_000 + if print_out: + print('Trainable Parameters: %.3fM' % parameters) + return parameters + + def _flatten_parameters(self): + """Calls `flatten_parameters` on all the rnns used by the WaveRNN. Used + to improve efficiency and avoid PyTorch yelling at us.""" + [m.flatten_parameters() for m in self._to_flatten] diff --git a/models/WaveRNNModel/models/tacotron.py b/models/WaveRNNModel/models/tacotron.py new file mode 100644 index 0000000000000000000000000000000000000000..aa495ab840c692a2f58d1e0975d0bedbfafd7ee8 --- /dev/null +++ b/models/WaveRNNModel/models/tacotron.py @@ -0,0 +1,469 @@ +import os +import numpy as np +import torch +import torch.nn as nn +import torch.nn.functional as F +from pathlib import Path +from typing import Union + + +class HighwayNetwork(nn.Module): + def __init__(self, size): + super().__init__() + self.W1 = nn.Linear(size, size) + self.W2 = nn.Linear(size, size) + self.W1.bias.data.fill_(0.) + + def forward(self, x): + x1 = self.W1(x) + x2 = self.W2(x) + g = torch.sigmoid(x2) + y = g * F.relu(x1) + (1. - g) * x + return y + + +class Encoder(nn.Module): + def __init__(self, embed_dims, num_chars, cbhg_channels, K, num_highways, dropout): + super().__init__() + self.embedding = nn.Embedding(num_chars, embed_dims) + self.pre_net = PreNet(embed_dims) + self.cbhg = CBHG(K=K, in_channels=cbhg_channels, channels=cbhg_channels, + proj_channels=[cbhg_channels, cbhg_channels], + num_highways=num_highways) + + def forward(self, x): + x = self.embedding(x) + x = self.pre_net(x) + x.transpose_(1, 2) + x = self.cbhg(x) + return x + + +class BatchNormConv(nn.Module): + def __init__(self, in_channels, out_channels, kernel, relu=True): + super().__init__() + self.conv = nn.Conv1d(in_channels, out_channels, kernel, stride=1, padding=kernel // 2, bias=False) + self.bnorm = nn.BatchNorm1d(out_channels) + self.relu = relu + + def forward(self, x): + x = self.conv(x) + x = F.relu(x) if self.relu is True else x + return self.bnorm(x) + + +class CBHG(nn.Module): + def __init__(self, K, in_channels, channels, proj_channels, num_highways): + super().__init__() + + # List of all rnns to call `flatten_parameters()` on + self._to_flatten = [] + + self.bank_kernels = [i for i in range(1, K + 1)] + self.conv1d_bank = nn.ModuleList() + for k in self.bank_kernels: + conv = BatchNormConv(in_channels, channels, k) + self.conv1d_bank.append(conv) + + self.maxpool = nn.MaxPool1d(kernel_size=2, stride=1, padding=1) + + self.conv_project1 = BatchNormConv(len(self.bank_kernels) * channels, proj_channels[0], 3) + self.conv_project2 = BatchNormConv(proj_channels[0], proj_channels[1], 3, relu=False) + + # Fix the highway input if necessary + if proj_channels[-1] != channels: + self.highway_mismatch = True + self.pre_highway = nn.Linear(proj_channels[-1], channels, bias=False) + else: + self.highway_mismatch = False + + self.highways = nn.ModuleList() + for i in range(num_highways): + hn = HighwayNetwork(channels) + self.highways.append(hn) + + self.rnn = nn.GRU(channels, channels, batch_first=True, bidirectional=True) + self._to_flatten.append(self.rnn) + + # Avoid fragmentation of RNN parameters and associated warning + self._flatten_parameters() + + def forward(self, x): + # Although we `_flatten_parameters()` on init, when using DataParallel + # the model gets replicated, making it no longer guaranteed that the + # weights are contiguous in GPU memory. Hence, we must call it again + self._flatten_parameters() + + # Save these for later + residual = x + seq_len = x.size(-1) + conv_bank = [] + + # Convolution Bank + for conv in self.conv1d_bank: + c = conv(x) # Convolution + conv_bank.append(c[:, :, :seq_len]) + + # Stack along the channel axis + conv_bank = torch.cat(conv_bank, dim=1) + + # dump the last padding to fit residual + x = self.maxpool(conv_bank)[:, :, :seq_len] + + # Conv1d projections + x = self.conv_project1(x) + x = self.conv_project2(x) + + # Residual Connect + x = x + residual + + # Through the highways + x = x.transpose(1, 2) + if self.highway_mismatch is True: + x = self.pre_highway(x) + for h in self.highways: x = h(x) + + # And then the RNN + x, _ = self.rnn(x) + return x + + def _flatten_parameters(self): + """Calls `flatten_parameters` on all the rnns used by the WaveRNN. Used + to improve efficiency and avoid PyTorch yelling at us.""" + [m.flatten_parameters() for m in self._to_flatten] + +class PreNet(nn.Module): + def __init__(self, in_dims, fc1_dims=256, fc2_dims=128, dropout=0.5): + super().__init__() + self.fc1 = nn.Linear(in_dims, fc1_dims) + self.fc2 = nn.Linear(fc1_dims, fc2_dims) + self.p = dropout + + def forward(self, x): + x = self.fc1(x) + x = F.relu(x) + x = F.dropout(x, self.p, training=self.training) + x = self.fc2(x) + x = F.relu(x) + x = F.dropout(x, self.p, training=self.training) + return x + + +class Attention(nn.Module): + def __init__(self, attn_dims): + super().__init__() + self.W = nn.Linear(attn_dims, attn_dims, bias=False) + self.v = nn.Linear(attn_dims, 1, bias=False) + + def forward(self, encoder_seq_proj, query, t): + + # print(encoder_seq_proj.shape) + # Transform the query vector + query_proj = self.W(query).unsqueeze(1) + + # Compute the scores + u = self.v(torch.tanh(encoder_seq_proj + query_proj)) + scores = F.softmax(u, dim=1) + + return scores.transpose(1, 2) + + +class LSA(nn.Module): + def __init__(self, attn_dim, kernel_size=31, filters=32): + super().__init__() + self.conv = nn.Conv1d(2, filters, padding=(kernel_size - 1) // 2, kernel_size=kernel_size, bias=False) + self.L = nn.Linear(filters, attn_dim, bias=True) + self.W = nn.Linear(attn_dim, attn_dim, bias=True) + self.v = nn.Linear(attn_dim, 1, bias=False) + self.cumulative = None + self.attention = None + + def init_attention(self, encoder_seq_proj): + device = next(self.parameters()).device # use same device as parameters + b, t, c = encoder_seq_proj.size() + self.cumulative = torch.zeros(b, t, device=device) + self.attention = torch.zeros(b, t, device=device) + + def forward(self, encoder_seq_proj, query, t): + + if t == 0: self.init_attention(encoder_seq_proj) + + processed_query = self.W(query).unsqueeze(1) + + location = torch.cat([self.cumulative.unsqueeze(1), self.attention.unsqueeze(1)], dim=1) + processed_loc = self.L(self.conv(location).transpose(1, 2)) + + u = self.v(torch.tanh(processed_query + encoder_seq_proj + processed_loc)) + u = u.squeeze(-1) + + # Smooth Attention + scores = torch.sigmoid(u) / torch.sigmoid(u).sum(dim=1, keepdim=True) + # scores = F.softmax(u, dim=1) + self.attention = scores + self.cumulative += self.attention + + return scores.unsqueeze(-1).transpose(1, 2) + + +class Decoder(nn.Module): + # Class variable because its value doesn't change between classes + # yet ought to be scoped by class because its a property of a Decoder + max_r = 20 + def __init__(self, n_mels, decoder_dims, lstm_dims): + super().__init__() + self.register_buffer('r', torch.tensor(1, dtype=torch.int)) + self.n_mels = n_mels + self.prenet = PreNet(n_mels) + self.attn_net = LSA(decoder_dims) + self.attn_rnn = nn.GRUCell(decoder_dims + decoder_dims // 2, decoder_dims) + self.rnn_input = nn.Linear(2 * decoder_dims, lstm_dims) + self.res_rnn1 = nn.LSTMCell(lstm_dims, lstm_dims) + self.res_rnn2 = nn.LSTMCell(lstm_dims, lstm_dims) + self.mel_proj = nn.Linear(lstm_dims, n_mels * self.max_r, bias=False) + + def zoneout(self, prev, current, p=0.1): + device = next(self.parameters()).device # Use same device as parameters + mask = torch.zeros(prev.size(), device=device).bernoulli_(p) + return prev * mask + current * (1 - mask) + + def forward(self, encoder_seq, encoder_seq_proj, prenet_in, + hidden_states, cell_states, context_vec, t): + + # Need this for reshaping mels + batch_size = encoder_seq.size(0) + + # Unpack the hidden and cell states + attn_hidden, rnn1_hidden, rnn2_hidden = hidden_states + rnn1_cell, rnn2_cell = cell_states + + # PreNet for the Attention RNN + prenet_out = self.prenet(prenet_in) + + # Compute the Attention RNN hidden state + attn_rnn_in = torch.cat([context_vec, prenet_out], dim=-1) + attn_hidden = self.attn_rnn(attn_rnn_in.squeeze(1), attn_hidden) + + # Compute the attention scores + scores = self.attn_net(encoder_seq_proj, attn_hidden, t) + + # Dot product to create the context vector + context_vec = scores @ encoder_seq + context_vec = context_vec.squeeze(1) + + # Concat Attention RNN output w. Context Vector & project + x = torch.cat([context_vec, attn_hidden], dim=1) + x = self.rnn_input(x) + + # Compute first Residual RNN + rnn1_hidden_next, rnn1_cell = self.res_rnn1(x, (rnn1_hidden, rnn1_cell)) + if self.training: + rnn1_hidden = self.zoneout(rnn1_hidden, rnn1_hidden_next) + else: + rnn1_hidden = rnn1_hidden_next + x = x + rnn1_hidden + + # Compute second Residual RNN + rnn2_hidden_next, rnn2_cell = self.res_rnn2(x, (rnn2_hidden, rnn2_cell)) + if self.training: + rnn2_hidden = self.zoneout(rnn2_hidden, rnn2_hidden_next) + else: + rnn2_hidden = rnn2_hidden_next + x = x + rnn2_hidden + + # Project Mels + mels = self.mel_proj(x) + mels = mels.view(batch_size, self.n_mels, self.max_r)[:, :, :self.r] + hidden_states = (attn_hidden, rnn1_hidden, rnn2_hidden) + cell_states = (rnn1_cell, rnn2_cell) + + return mels, scores, hidden_states, cell_states, context_vec + + +class Tacotron(nn.Module): + def __init__(self, embed_dims, num_chars, encoder_dims, decoder_dims, n_mels, fft_bins, postnet_dims, + encoder_K, lstm_dims, postnet_K, num_highways, dropout, stop_threshold): + super().__init__() + self.n_mels = n_mels + self.lstm_dims = lstm_dims + self.decoder_dims = decoder_dims + self.encoder = Encoder(embed_dims, num_chars, encoder_dims, + encoder_K, num_highways, dropout) + self.encoder_proj = nn.Linear(decoder_dims, decoder_dims, bias=False) + self.decoder = Decoder(n_mels, decoder_dims, lstm_dims) + self.postnet = CBHG(postnet_K, n_mels, postnet_dims, [256, 80], num_highways) + self.post_proj = nn.Linear(postnet_dims * 2, fft_bins, bias=False) + + self.init_model() + self.num_params() + + self.register_buffer('step', torch.zeros(1, dtype=torch.long)) + self.register_buffer('stop_threshold', torch.tensor(stop_threshold, dtype=torch.float32)) + + @property + def r(self): + return self.decoder.r.item() + + @r.setter + def r(self, value): + self.decoder.r = self.decoder.r.new_tensor(value, requires_grad=False) + + def forward(self, x, m, generate_gta=False): + device = next(self.parameters()).device # use same device as parameters + + self.step += 1 + + if generate_gta: + self.eval() + else: + self.train() + + batch_size, _, steps = m.size() + + # Initialise all hidden states and pack into tuple + attn_hidden = torch.zeros(batch_size, self.decoder_dims, device=device) + rnn1_hidden = torch.zeros(batch_size, self.lstm_dims, device=device) + rnn2_hidden = torch.zeros(batch_size, self.lstm_dims, device=device) + hidden_states = (attn_hidden, rnn1_hidden, rnn2_hidden) + + # Initialise all lstm cell states and pack into tuple + rnn1_cell = torch.zeros(batch_size, self.lstm_dims, device=device) + rnn2_cell = torch.zeros(batch_size, self.lstm_dims, device=device) + cell_states = (rnn1_cell, rnn2_cell) + + # Frame for start of decoder loop + go_frame = torch.zeros(batch_size, self.n_mels, device=device) + + # Need an initial context vector + context_vec = torch.zeros(batch_size, self.decoder_dims, device=device) + + # Project the encoder outputs to avoid + # unnecessary matmuls in the decoder loop + encoder_seq = self.encoder(x) + encoder_seq_proj = self.encoder_proj(encoder_seq) + + # Need a couple of lists for outputs + mel_outputs, attn_scores = [], [] + + # Run the decoder loop + for t in range(0, steps, self.r): + prenet_in = m[:, :, t - 1] if t > 0 else go_frame + mel_frames, scores, hidden_states, cell_states, context_vec = \ + self.decoder(encoder_seq, encoder_seq_proj, prenet_in, + hidden_states, cell_states, context_vec, t) + mel_outputs.append(mel_frames) + attn_scores.append(scores) + + # Concat the mel outputs into sequence + mel_outputs = torch.cat(mel_outputs, dim=2) + + # Post-Process for Linear Spectrograms + postnet_out = self.postnet(mel_outputs) + linear = self.post_proj(postnet_out) + linear = linear.transpose(1, 2) + + # For easy visualisation + attn_scores = torch.cat(attn_scores, 1) + # attn_scores = attn_scores.cpu().data.numpy() + + return mel_outputs, linear, attn_scores + + def generate(self, x, steps=2000): + self.eval() + device = next(self.parameters()).device # use same device as parameters + + batch_size = 1 + x = torch.as_tensor(x, dtype=torch.long, device=device).unsqueeze(0) + + # Need to initialise all hidden states and pack into tuple for tidyness + attn_hidden = torch.zeros(batch_size, self.decoder_dims, device=device) + rnn1_hidden = torch.zeros(batch_size, self.lstm_dims, device=device) + rnn2_hidden = torch.zeros(batch_size, self.lstm_dims, device=device) + hidden_states = (attn_hidden, rnn1_hidden, rnn2_hidden) + + # Need to initialise all lstm cell states and pack into tuple for tidyness + rnn1_cell = torch.zeros(batch_size, self.lstm_dims, device=device) + rnn2_cell = torch.zeros(batch_size, self.lstm_dims, device=device) + cell_states = (rnn1_cell, rnn2_cell) + + # Need a Frame for start of decoder loop + go_frame = torch.zeros(batch_size, self.n_mels, device=device) + + # Need an initial context vector + context_vec = torch.zeros(batch_size, self.decoder_dims, device=device) + + # Project the encoder outputs to avoid + # unnecessary matmuls in the decoder loop + encoder_seq = self.encoder(x) + encoder_seq_proj = self.encoder_proj(encoder_seq) + + # Need a couple of lists for outputs + mel_outputs, attn_scores = [], [] + + # Run the decoder loop + for t in range(0, steps, self.r): + prenet_in = mel_outputs[-1][:, :, -1] if t > 0 else go_frame + mel_frames, scores, hidden_states, cell_states, context_vec = \ + self.decoder(encoder_seq, encoder_seq_proj, prenet_in, + hidden_states, cell_states, context_vec, t) + mel_outputs.append(mel_frames) + attn_scores.append(scores) + # Stop the loop if silent frames present + if (mel_frames < self.stop_threshold).all() and t > 10: break + + # Concat the mel outputs into sequence + mel_outputs = torch.cat(mel_outputs, dim=2) + + # Post-Process for Linear Spectrograms + postnet_out = self.postnet(mel_outputs) + linear = self.post_proj(postnet_out) + + + linear = linear.transpose(1, 2)[0].cpu().data.numpy() + mel_outputs = mel_outputs[0].cpu().data.numpy() + + # For easy visualisation + attn_scores = torch.cat(attn_scores, 1) + attn_scores = attn_scores.cpu().data.numpy()[0] + + self.train() + + return mel_outputs, linear, attn_scores + + def init_model(self): + for p in self.parameters(): + if p.dim() > 1: nn.init.xavier_uniform_(p) + + def get_step(self): + return self.step.data.item() + + def reset_step(self): + # assignment to parameters or buffers is overloaded, updates internal dict entry + self.step = self.step.data.new_tensor(1) + + def log(self, path, msg): + with open(path, 'a') as f: + print(msg, file=f) + + def load(self, path: Union[str, Path]): + # Use device of model params as location for loaded state + device = next(self.parameters()).device + state_dict = torch.load(path, map_location=device) + + # Backwards compatibility with old saved models + if 'r' in state_dict and not 'decoder.r' in state_dict: + self.r = state_dict['r'] + + self.load_state_dict(state_dict, strict=False) + + def save(self, path: Union[str, Path]): + # No optimizer argument because saving a model should not include data + # only relevant in the training process - it should only be properties + # of the model itself. Let caller take care of saving optimzier state. + torch.save(self.state_dict(), path) + + def num_params(self, print_out=True): + parameters = filter(lambda p: p.requires_grad, self.parameters()) + parameters = sum([np.prod(p.size()) for p in parameters]) / 1_000_000 + if print_out: + print('Trainable Parameters: %.3fM' % parameters) + return parameters diff --git a/models/WaveRNNModel/notebooks/NB1 - Fit a Sine Wave.ipynb b/models/WaveRNNModel/notebooks/NB1 - Fit a Sine Wave.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..b55b52985898e61189eb1f9052dae49002782040 --- /dev/null +++ b/models/WaveRNNModel/notebooks/NB1 - Fit a Sine Wave.ipynb @@ -0,0 +1,574 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# WaveRNN - Fit a Sine Wave" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", + "import time, sys, math\n", + "import numpy as np\n", + "import torch\n", + "from torch import optim\n", + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "from scipy.io import wavfile\n", + "from utils.display import *\n", + "from models.wavernn import WaveRNN" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [], + "source": [ + "notebook_name = 'nb1'\n", + "sample_rate = 24000" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [], + "source": [ + "def sine_wave(freq, length, sample_rate=sample_rate) : \n", + " return np.sin(np.arange(length) * 2 * math.pi * freq / sample_rate).astype(np.float32)" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [], + "source": [ + "signal = sine_wave(1, 100000)" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot(signal[:sample_rate])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Splitting the Signal" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [], + "source": [ + "def encode_16bits(x) : \n", + " return np.clip(x * 2**15, -2**15, 2**15 - 1).astype(np.int16)" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [], + "source": [ + "def split_signal(x) :\n", + " encoded = encode_16bits(x)\n", + " unsigned = encoded + 2**15\n", + " coarse = unsigned // 256\n", + " fine = unsigned % 256\n", + " return coarse, fine" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [], + "source": [ + "c, f = split_signal(signal)" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot(c[30000:32000])" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot(f[30000:32000])" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(255, 0, 255, 0)" + ] + }, + "execution_count": 52, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "c.max(), c.min(), f.max(), f.min()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Reconstructing the Signal" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [], + "source": [ + "def combine_signal(coarse, fine) :\n", + " signal = coarse * 256 + fine \n", + " signal -= 2**15\n", + " return signal.astype(np.int16) " + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [], + "source": [ + "reconstructed = combine_signal(c, f)" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot(reconstructed[:sample_rate])" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [], + "source": [ + "before_signal = sine_wave(freq=500, length=sample_rate * 5)\n", + "c, f = split_signal(before_signal)\n", + "before_signal = encode_16bits(before_signal)\n", + "reconstructed = combine_signal(c, f)" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [], + "source": [ + "wavfile.write('model_outputs/nb1/combine_test_before.wav', sample_rate, before_signal)\n", + "wavfile.write('model_outputs/nb1/combine_test_after.wav', sample_rate, reconstructed)" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Trainable Parameters: 3.050 million\n" + ] + } + ], + "source": [ + "model = WaveRNN().cuda()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Check Tensor Shapes" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [], + "source": [ + "hidden = model.init_hidden()" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [], + "source": [ + "x = torch.rand(1, 2).cuda()\n", + "current_course = torch.rand(1, 1).cuda()" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [], + "source": [ + "c, f, hidden = model(x, hidden, current_course)" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(torch.Size([1, 256]), torch.Size([1, 256]), torch.Size([1, 896]))" + ] + }, + "execution_count": 66, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "c.size(), f.size(), hidden.size()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Train Model" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [], + "source": [ + "x = sine_wave(freq=500, length=sample_rate * 30)\n", + "coarse_classes, fine_classes = split_signal(x)\n", + "coarse_classes = np.reshape(coarse_classes, (1, -1))\n", + "fine_classes = np.reshape(fine_classes, (1, -1))" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [], + "source": [ + "def train(model, optimizer, num_steps, seq_len=960) :\n", + " \n", + " start = time.time()\n", + " running_loss = 0\n", + " \n", + " for step in range(num_steps) :\n", + " \n", + " loss = 0\n", + " hidden = model.init_hidden()\n", + " optimizer.zero_grad()\n", + " rand_idx = np.random.randint(0, coarse_classes.shape[1] - seq_len - 1)\n", + " \n", + " for i in range(seq_len) :\n", + " \n", + " j = rand_idx + i\n", + " \n", + " x_coarse = coarse_classes[:, j:j + 1]\n", + " x_fine = fine_classes[:, j:j + 1]\n", + " x_input = np.concatenate([x_coarse, x_fine], axis=1)\n", + " x_input = x_input / 127.5 - 1.\n", + " x_input = torch.FloatTensor(x_input).cuda()\n", + " \n", + " y_coarse = coarse_classes[:, j + 1]\n", + " y_fine = fine_classes[:, j + 1]\n", + " y_coarse = torch.LongTensor(y_coarse).cuda()\n", + " y_fine = torch.LongTensor(y_fine).cuda()\n", + " \n", + " current_coarse = y_coarse.float() / 127.5 - 1.\n", + " current_coarse = current_coarse.unsqueeze(-1)\n", + " \n", + " out_coarse, out_fine, hidden = model(x_input, hidden, current_coarse)\n", + " \n", + " loss_coarse = F.cross_entropy(out_coarse, y_coarse)\n", + " loss_fine = F.cross_entropy(out_fine, y_fine)\n", + " loss += (loss_coarse + loss_fine)\n", + " \n", + " running_loss += (loss.item() / seq_len)\n", + " loss.backward()\n", + " optimizer.step()\n", + " \n", + " speed = (step + 1) / (time.time() - start)\n", + " \n", + " stream('Step: %i/%i --- Loss: %.1f --- Speed: %.1f batches/second ', \n", + " (step + 1, num_steps, running_loss / (step + 1), speed)) " + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [], + "source": [ + "optimizer = optim.Adam(model.parameters(), lr=1e-3)" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Step: 300/300 --- Loss: 0.6 --- Speed: 0.9 batches/second " + ] + } + ], + "source": [ + "train(model, optimizer, num_steps=300)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Generate" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gen: 10000/10000 -- Speed: 1163" + ] + } + ], + "source": [ + "output, c, f = model.generate(10000)" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot(output[:300])" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot(c[:300])" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot(f[:300])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And compare the fine output to the ground truth..." + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABs4AAAE/CAYAAADmEzaPAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4wLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvpW3flQAAIABJREFUeJzsvXmQJNld5/n1MzIjsvLqu9VVuiWQQK3Sgi0sx47NzN5mszsMYmDZHcMYlmGx3dkdWzDtjI1NELDDwAw77LIDCCGZxAJiJBCHWisOIYEAqRv1kd1dfZ/VmVXV3dVdmRGZGZef+4f7c3+RleH+nkc8P7p+H7O2qq6MqPCKiJ+/3/n9aWEYgiAIgiAIgiAIgiAIgiAIgiAIgiBudPSqL4AgCIIgCIIgCIIgCIIgCIIgCIIg6gAVzgiCIAiCIAiCIAiCIAiCIAiCIAgCVDgjCIIgCIIgCIIgCIIgCIIgCIIgCABUOCMIgiAIgiAIgiAIgiAIgiAIgiAIAFQ4IwiCIAiCIAiCIAiCIAiCIAiCIAgAVDgjCIIgCIIgCIIgCIIgCIIgCIIgCABUOCMIgiAIgiAIgiAIgiAIgiAIgiAIAFQ4IwiCIAiCIAiCIAiCIAiCIAiCIAgAVDgjCIIgCIIgCIIgCIIgCIIgCIIgCACAWfUFlMXNN98cvuUtb6n6MgiCIAiCIAiCIAiCIAiCIAiCIIiSefDBB18Pw/CWvMfdMIWzt7zlLXjggQeqvgyCIAiCIAiCIAiCIAiCIAiCIAiiZDRNe0nkcSTVSBAEQRAEQRAEQRAEQRAEQRAEQRCgwhlBEARBEARBEARBEARBEARBEARBAKDCGUEQBEEQBEEQBEEQBEEQBEEQBEEAoMIZQRAEQRAEQRAEQRAEQRAEQRAEQQCgwhlBEARBEARBEARBEARBEARBEARBAKDCGUEQBEEQBEEQBEEQBEEQBEEQBEEAoMIZQRAEQRAEQRAEQRAEQRAEQRAEQQCgwhlBEARBEARBEARBEARBEARBEARBAKDCGUEQBEEQBEEQBEEQBEEQBEEQBEEAoMIZQQAA+iMHD760X/VlEASxBMIwxJ8/fRV+EFZ9KQRBLIHHLg9w9XBS9WUQBLEErh5O8NjlQdWXQRDEEvCDyOcOQ/K5CeKNwIMvHeBg6FR9GQRBELWBCmcEAeDffek5/P1fuQ9HE7fqSyEIYkG+9uI+fuDj9+PzF16u+lIIgliQIAjx/R/9a/zLzz9Z9aUQBLEEfuYPn8L3/ep91NxCEG8A/vjxV/ADH78f975wrepLIQhiQYZTD9/7kXvx/3zpuaovhSAIojZQ4YwgADzw0gG8IMSjl6gDliCazgMvHQCIOuYIgmg2z712jMHYJXsmiDcID7x0gKOJh2evHlV9KQRBLMgDF6Oz+SE6owmi8TxyqQ/XD/HgLtkzQRAEgwpnxA3P1PPxxJVDAMAOOQkE0Xh2dvvRr3v9iq+EIIhFYefypYMxrh6RXCNBNJnXj6fY3R8BSM9qgiCay85edEaTPRNE82F2/MSVASauX/HVEARB1AMqnBFLZeL6+NT9u43SOX/8yiEcPwDQPKf/scsDPHCRdrMR6vijx17Gqw3aLRSGIR6Og/imOf2DsYvf27lU9WUQb2CaeGbw5/LDDTujf3/nMgYjkoAm1NDEM4O34aY1qz340j7tZiOU0rQzY+r5ePxy3Hy6129U/H/1cII/JEl3QiFNPDOYz+36IR6PG8ubQBiG+NT9u42K+4lmQWfGjQ0Vzoil8uVnXsOHPnMBT73SHPkV5iB8xztvbpzT/3/96TPo3fNE1ZdBvEHx/AD/428+hE/fv1f1pQhz6WCM148dfMc7b26c0/+HF17GP/nUI40qVBLN4ue/8Ax+8nPNOjN2dvv4lrdtw9S1Rk2Rvn48xf/6qYdxz6NXqr4U4g3K5+Mz42qDzoydvQOYuoZvedt245rVfupzT+Ln/uTpqi+DeIPy2lF0ZnzuQnPOjCfi5tPveOfN2B86yTRpE/jtBy/hRz/5EBwvqPpSiDcoP/m5J/F/NujMYM2n3/HOmwE0q7nlmVeP8aHPXMCfP3216ksh3qB8+oE9/OgnH4Lr05lxI0KFM2KpsC6PaYOc0J3dA9y5sYL//Btub5zTP3EDTD3qrCHU4PohwrBZ9vxQ7OT/4Le9FUCznP7k/uk25/0mmsXE8xv1/TqauHjm6hG+9W034z13rjfTnht0/ySaRRO/Yzu7fXz9Hev4j95+M569Gu0vbAoTt1n3T6JZNNEHZMXvH/z2t878fxOYuD7CEJQEJZQxdf1Gnc+s+fQ/fe/teNPmaqOa1ZroDxHNYuIGdGbcwFDhjFgqrGvLa9ANZWe3j/PntnD+7Fby/03B9QPqlCOUwb5bbtCc79jObh+rloHveOfNjXP6vSCadnV8KoYTanC8oFH2/OilAcIQOH9uE+fPbuLRS4PG+BeeH9szndGEIpIzuiE24QchHtnrR/Z8bhMA8OilZp3RTkPea6J5sO+W16Azemevjzs2VvCd77wFbdtoVHOLS2c0oRjHCxJfsAmw5tPzZ6Mzukny6Oy+SYUzQhXsjHYbZNPE8qDCGbFU2I2kKTeUq4cTXO6Pcf7cJt5121rjnH4vCBvzXhPNIwniG/Qd29nr4313bcA0dLy/YU5/GsQ35/0mmoXjh82y5/g8vvvsJs6f28LI8fHMq8cVX5UYLIhvSlGDaB5ukmhvhk0/e/UIQ8fH+XObuPvsJjStWc1qnh+QPRPKcBuYlNvZPcD5c5swdA1337XZrGY1n85oQi2O36xmtZ3dPlYsHV93+xmcP7eFy/1xY9YHpDnI5rzfRLNo4oAIsTyocEYsFbdhTihz8M+f24Rp6HjfXRuNcvpdP6DuV0IZTbPnievjiSsDnD8XTY+eP7vZMKe/We830Txcr1mJ353dPt5x6xo2Vq1kQmVnrxnNLawA3qT3m2gWTsMmJliR7PzZLayvWHjHLWuNalZz/bAx7zXRPNyGnRlXjya4dDBOFFvOn9vEE1cOE8m0usPeZ4qjCVW4DWu2iJpPo5xY4nM3pLkliaHpjCYU0cTmFmJ5UOGMWCpuw2Qmdnb7sAwN771zAwBw/txWw5z+sFEOGdEsmuYgPH7lEK4fJs4+K6A1xemn7ldCNVEQ3wx7DsMQO3t9nD8b2fO57Ta2O3Zz7DmgpByhlqZNnO3sHmCrbeHNN7UBRIn2nb0+wrAZ19+0JCjRLJqm8sAUHXif2wtCPHZ5UOVlCeMGzVLJIZqH2yCVh7T5NLLn9965DtvQG9Os5jVM9YpoHtTgfGNDhTNiqTCnvylSYzu7B3jPHetYsQwA0YRKo5x+P6DOGkIZTXMQdjhtdiBy+i1Da4zT7yY7zprxfhPNw/WDxjS27O6PsD90kgK4pmk4f3azMRMqiWxMQ/whonm4DZONYTuFNU0DECXa+yMXF6+NKr4yMUgenVBJ4nM35Ize2evD1DV8w5ui5tP3n23WhAo1qxGqaZLKQ9J8Gk+QtkwD77lzvTH2TBOkhGpIDvTGhgpnxFJhCaImJOY8P8Cjl1JZN6CZEyoUxBOqYAXwxiTl9vp40+Yqbl1fAQCsWAbee+dGY+yZJUHJpglVuH7YmGaLnRPd7ADwgTdv4fnXhhiM3KouS5imNR4QzaNJiaLB2MWzV4+TxhYA+EDiczekGN6gJCjRPFKpsWb4gDu7B3jvnWnz6S1nWji7vdqcZrWGSd0SzcNpUJ6GncMf4Hzu8+c28eilfiPyAFTUIFTjNEzlgVguVDgjlorbIJmJp189wtj1Z5JyTXT6HT9ojMwN0SzS7tdmfL8e3u3P2DPQLKefOWJNKWwQzSNaVN4Me97ZPUDbNvCu284kf8aS7g9fqn8x3KMgnlAM23HWBJ/70UusEJ42q73j1jWstczmNLcEVDgj1NGkdQenNZ8C0f7CxtgzNbcQinH9oBHxJ3B98ykQndcTN8BTrxxVeGVisPsm2TOhirTBmb5jNyJUOCOWitOg7lfm2H/gDeH01z9pQjQPJ+l+rb89v3o4weX++PogvkFOf5Pun0QzcRo0MbGz18fdd23C0LXkz953dhOa1owJlWQaqAH3T6KZOA0K4nd2+9A04H1nN5I/M3QNd5/daFSz2pTsmVBEk+z5mVePMXL8U5vVXh5M8PJgXNGViUNnNKESzw8QhGmDS905tfmUya/u1T8vxuyY7JlQhUN51xsaKpwRS8VJ9i3U/4ays9vHzWs27tpanfnzJjn9yYRKA4Isonkk+1MaMKFymqwb0Cynn/YtEKpx/QBhCPg1t+loSfnhdfa81jLx7tvONKK5pUkyekQzaVLz1M7uAd556xrWV6yZPz9/dgtPvnyEseNXdGVihGEIPwjpfCaU4SRTyg2w5z22U/j6ZjUgSsLXHa9B7zfRPNj3qgkTpPOaT+/aWsXNa61GNKulOTGyZ0INqbJa/W2aWD5UOCOWSpNkJnb2DvD+s+mSckaTnH6SmSBU4jTo+7WzdwDb0PHeO9dn/rxRTj/tWyAU05Qz47HLA3hBeF0QD0TF8Yf3+ghqXvyjxhZCNU3xucMwxM5e/7okOxDZsx+EuHB5UMGVieNSkp1QTNKs1oAzY2e3j5s6Ns5uzzafvueOddim3ohmNZfOaEIhyT6kBpwZ85pPNU2LfO4G5MQ8alYjFMP2j5IfeGNChTNiqTRF9qA/cvDCa8PrHASgYU4/OQmEQpq0aHdnt4/33LmOlmnM/HmTnH6SACBUEoZhY2yaBfHvP3v9GX3+7BYGYxcvXhuWfVlSNGkaiGgmTSmEX7w2Qn/knupzMxuve3MLe4/9IKz9xC7RTJp0ZuzsHuD8uc3rmk9tU8c33Llee3sG0kIlxdCECpqUo5nXfApExbQXXh/iYOhUcGXiJBO7Nc9BEs2lSQ3lxPKhwhmxVNKx9Ho7/Q/vnd5ZAzTL6SeZCUIlbkO65aIl5ddrszOa4vR7DSlqEM2EPyfqbtM7ewc4u72KW860rvsZs/O6yzU2pUhJNJemSLsxf/q0CdKb1lp4803t2tszf88kmyZU0JRC+GDk4vnXhqfaMxDZ+aOXBrX/d7BJ3bpfJ9FMmiTrNq/5FEjlWB++VPczmuyZUEtTVB4INVDhjFgqTkOchJ3dPnQNeN9d8xLt9Xf6wzBMpaCou4ZQQBLE17wQ/tQrR5i4wfwgvilOPwXxhEL475Vbc6d/Z/d0WTcAePstazjTMmvf3JLIxtD5TCjCbche4Z3dPtZaJt5x69qpPz9/dhMP7R4gDOv77+DvmXRGEypwmtJ8GvvS50+ZCAei5papF+Cpl4/KvCxpqLmFUAmTdQtqvlc4r/n0fXdtQNfq36xGO84I1TRpKpxYPlQ4I5ZKKnuQfUM5nLj49p/9Eh6qKPG1s9fHu247g7WWeerPq3b6f+jX7sdH/uL5zMe41P1KKIYlfEUKs//4t3bw8194RvUlnQqTVZ0XxFft9P/6vRfx/R+9L/dx7L7ZBFkPonnMFM5yzujffegS/ptf/IrqSzqVlwdjvDyYzA3idV3D+89tVmbPL74+xH/403+KK/1x5uOaMj1ANBfR79grgwm+5ae/iBdeOy7jsq5jZ+8Ad5/dgKFrp/78/LktXD2a4uXBpOQri/iuX/oKfvuBvczHyNw/CaIIMmfGf/+xv8YnvvKi6ks6lZ3dA2ga8L65hbOo6WVnr5oY/xe++Cz+p08+lPu45P32yJ6J5eP44s0WH/3LF/CDn7hf9SWdSl7zaadl4t23V6fE9PBeH9/2M1/CYOxmPs4h6VVCMaLNFs+8eoRv/VdfxNWjanxaQg1UOCOWiujE2dXDKS4djPHky4dlXNYMQRDi4d2DuQ4CUL3T/+BLB3gyp2jHjwlPqaOdUIAjMZJ+4fIAj1Y00bWze4Cb11q4a2v11J9X7fQ/emmAR/cGuY+jCRVCJfz3Ku+MfuqVIzy8169kevzhZEl5xhl9dhNPvXKIkeOVdVkJz7x6hFcPp9jdH2U+zqVCOKEY0X0Lu/sjvHI4wTOvll84Gzs+nnz5aO4EKVCt/KofhHhot4+nX8nxubliGZ3RhAqSZjWBM+ORvT4uXC4/hgYiO313RvPpnRsruPVMq7Lmlkf2+njssojPHdn0lM5oQgEzPnfOxNkTLx/iwZeqayYH5jefAtEZ/fBeH0EFk3NPvnyIy/0xXsspQrBcBZ3PhCocQZWH568e4+XBBC9dy44TiWZBhTNiqaTar9k3FPa44bT8pNcLrw9xOPHmdrMD1Tv9w6mfm2yjiTNCNTIyUI4XYDj1VV/SqTy82z91STlPlU7/0PGEkue044xQiSMxMcGCg6FTvk3v7PVhmzrec8f1S8oZ589tIQijonTZML8lz04T6VXqZicUkQTxNfa5L1wewA/CTJ/7625fR8vUK2luGTpi9uxKTA8QRBFk9gq7fliJPQdBiIf35su6AYCmaTh/brOyZrXjqSc0FeomZzTZM7F8+HMirwmN2XMVcsV5zadAVFQ7mnh44fXym2/Yfc7J8aUphiZUI9qsxh53XMEZTaiDCmfEUmEJorxuDze5oVSQlIsd+Q/U1Ol3vACOH+Q68iQbQ6hGZmLC9YNKHISDoYMXXh9mBvFAtU7/8dQXcuRTh4zsmVg+Ms0WVSbad3YP8A13rsM257uo7z9b3YSKaOGM9qcQqkmlxsSC+GEFE5rMj35/Rje7ber4xjdtJJ3vZZIk5XLOXf7+SVOkhApEk3LsMVXY84vXhhiM3cwJUiBqbrl4bYT9oVPSlaWINquRnDKhEv57ldsM7QXwgrASBSGx5tPI3h+qwOc+FvS5Ze6fBFEE0R1n7OdVxNCXDkZ47Wha+uveCFDhjFgqotJuVd5QHrs8wJmWibfdfPqScsbdZzdx8dooV1N52bD3JK+D2KOJM0IxqfRqfiHHC8JKgvjHrkQTJ++/K7twxpJ2VU2oiCyHJpkJQiWz3a9i50vZZ3QYhrhweYC7M5LsALDVsfHmm9q4cLmKID5q+MkPnGjfAqGWpDgr6C9W0dzy6OUBzm6v4qa1Vubj7j67iQuXB6VPhSc+N02cERXDmk/zzpYwDOEFYSX2fCH2ofPO6Ltjn/yCgGTishlOfSGZaZpQIVTiyPjcQTXNakcTFy+8PsxsbAGAt93cwZkVM7H/MknzYjkqD0mzLzWfEmpIlJhyv4vVNZ/+k089jH/8Wzulv+6NABXOiKUiumiXPa6K/SSvHU9x+8YK9DlLyhlv2oxG1q8dl1u1LyIbQ4k5QgUy3ZhuRVKNrKvmzs35EhP8z6vowhGWdqMgnlAIX5B1c5tbqpFqPJp6mLhBcv5mcefGaiX2PBI8o8meCdWk0m5i9jyq6Iy+c0PAnjdX4XgBjiblxgXDpBCeJ73KNauR/CqhAFey+bQqewaAOzdXMh/3pop9biGpRkq0Ewrhv4N5hTP2HRyV7HO/fhxNhObZs65ruGNjpRp7jt+TXKlGkl4lFJOcGYKqYFXkxfaHDrY7dumveyNAhTNiqSSJdsGkXBVSjftDB1sCN5StdvSYg1G5MhPsJit6UwbISSDUIFM4c/ygks4aJgOTZ9Nt24Bt6tgv2Z4B8WI4yUwQKpE5M5yKuuUOmD2388/o7Y5diQyUqGyMqKQHQRRF9IxOfe5q5JRFgvjtjgUApZ/RaWOLWMMfQM1qhBrEZaCqs+f9kQPL0LDWMjMftxXb80EVUo1Tkmokqof3s0WkGoHybXpfwufeatvVxNCiUo0eNasR6gjDkFNWEyuEV5EXOxi52Gxbpb/ujQAVzoilwpz9uspAAcDB0MWWwA2FORH7w3KlGo9FpRr57ldKzBEKSOxZQDrJC0KMXT9XjnDZHIwcGLqG9ZXsIF7TNGy1rYqC+KgYLnpfJHsmVDDT/VpTabe0EJ5/Rm+2LRyMyj2fAZlEe2zP1NhCKII1WNV538LByMGmQFJuM/G5yz2jZQvhIo8liCKINk8lMXQFqi0Hw8ies/YhAcBay4Spa6Un2oMgxNARlWqkCRVCHTPy6HnSbhVJNco0q2217coK4YD4e0jnM6ECPm7OO1/Yz49LPqODIER/RBNnqqDCGbFU0iBerJu9qm45kRtKVd1y4p01FMQTahG1Zz8Ik4JZ2YH8flwIzwvigbhbruRCOCCfmKNudkIFjkz3a1UTZyO5ibP+yKlgJ5KYtBvZM6Ea0UR7Kr1a/s7Cg5GbTJNlsc1UHsr2uYXl0dP7DO0hJVQgG0NXpfKwLXA+a5qGrU75ifaRG53PInuFU6lGsmdi+fDfqzx5X6eqZrXY5xbLi9mlqzAB6XuSJ9WY+Nx0PhMKmFUdEPsuln1GH05cBKFYDE3IQ4UzYqmkQXw9byhhGOJg6Agn5YDqZGPyDn6+84GcBEIFvD2H4Xyb5p2Jsm26PxKzZyBNtJeJ6weJfeYXK8S0swmiCDPdr7n7Fqrqfo0K20JBfNtGEEaBQpkkhfDcMzq1+6z7J0EURVTloSp59MOJBz8IpXzushNzx0khPG8Kl5rVCLWkOwvF7Nn1Q0y9cm26P3KFJsKBqBhe/rqD1GfJLYbThAqhEKm9wl41O5FYTCyywmS7E6k8lO3Pijer0c5CQh28PedNnKVSjeXaM1NsoIkzNVDhjFgq4ouN40XlJS9BPZ568IJQ6IayahlomXr5Tr8juKi8pH0LYRji/ov7lPirGSPHw2OXB0pfg08MZ3VuzhbOyncSRBx+IAoMyi6E88vbcxNzJQXxT79yhEEFEndENg++dCAkL1QUxxd3+tMJlXLt+UAqiK9G2m3kyEk1hgKd74vw2tEUL74+VPb3E8V48fUhrh5NlP39/KR3XlKOBfyjimSgRLvZgfILZ+w9EW1siX6v7j7tByEefOlA2d9PFGMwcvH0K0dKXyOR95WQDR2V7XNLyEBtdaykGaYs+MJZlk37QQgW1uZNsizKY5cHlUwHEvMpI7cxI48u2lBegWqLbejo2EbuY7faNvwgxOGk3GsUnQpPpFcVx9BX+mPs7Y+UvgYhzzOvHiltjp6JoXOnmatVbaEdZ2qgwhmxVFxBmQm3opF05sCL7FuIdiKVLzMxFNxx5pTU/bqz18cHP3wvHrmktkhDyPHbD1zC3/2lr2DiqguaZ3d6zP8+8gFBFU6CiGwMgEp2nPH61rnFCsH756L8t796Hz7yl88rfQ1CjksHI/y9X/4qvvjUVWWv4Uo0W1S1h3R/6MDUNZxpZe8sBKpLtCcTKoINQtHv1SVnfu6Pn8aP/PqDyv5+ohg/+psP4d/80dPK/n6Z7xfzJ6uSgRIphHdsA7ahly6nnPjcEsUKlR3tX3rqKv7eL3+VEnM142N/9QK+9yP3Kn0NfpIs+3Hpz8uPo+VUHspXbUljoqxiRVk7Cyeuj+/6pa/iU/fvKXsNQp4Llwf44IfvxUO76poUZL5j7IyuYsfZVkds3UEyFV5VXkx0r7DiGPpf/MFj+NBnHlX6GoQ8/91H/xof/vILyv5+Gblur8JCOEATZ6qgwhmxVNJDq56V+FTLWawSv9UpfyeSsAxUSd2vrHvjqGQ5LCKbw7EL1w+V2tBMh3VGkrhKqcb9oZxsTH/sKp3+OIlo9ysAuGx6QGH3a7RzxsFRyR2DRDbs81DZLScj1ZhKu5VfCN9s24I7CyO7ryrRnmen/Huscio8smc6n+vG4djFgcLJ3ll7FpSBKjmIZwk2kUS7pmnYrKK5RVSqkfOB8vzzRWCNAGVL0BLZHE485TJlLBknqtoClGvTQRD5j6KFs80Kmk+PBaUayyqcjR0fjh+Qz10zDsfR56FyIlLmO+Z41eXFRO2ZPa6qYrjobmbVhbODkUv2XEMOJ67aGJqXasw9o1mzWsmqLRI+NyEPFc6IpRGGYXKoiQbxI8dHUGISW/aGEuk5V7TjTCaIV9j9OnFp2WodYbY2Ufi5OIKJdv5xZSbawzCU2nG21bERhsBgXF5CajaIF9uhojLJ7vohgpDsuW6wz4Pdb1XAF3rynH6nwokz4caWdrXdrzJyWko72r1A6T2DKIbjB0r3D81KB4o2q1W0b6HWEyqi9lxOs9o0VhGgM7peTOPPY6rwc+Enzuq4V/hw4iIIxSZIgXTHWZlx/kyzWsZnVVbz6cRjSf9y771ENuzzmCg8o0VjaKC6PaQyE6RbFUychWEoLtUYpM37KhscJq5P53MNcbygNBWm2u4JH9GOM5VQ4YxYGry0oKhsDFBut5zsDWWrwsXGuYlNLgmq8gBnhxAtT64XSeGsNKlGsQC0THs+kthZCHAyEyXatOiicj+IClp5j1uUNIgne64Tbgn2zH/meY0ZVSXaD0aulAxU9JxqOtprUzijIL6WuH55QXxuN3tF8uj9eOJOdCp8q20r7Rg+DSanLNrNfvL3y4Y1T6hsiCPkYZ/5VGVzC78TSXCvcJmJdjZBK6PaEoQodTqDj0FEJ85USq+SPdcTlkMpq1lN1F+sZN2BRCE8ek55zacjx092Ecr53GoLZ5QTqxcsh6LSnmdjaEGpxgomSG1DR1tgZyEhDxXOiKUhF8Tz3XLlOf2s+1VkxxmASnacJbIxeVKNQblBvMrAgpDHTZx+hYl2T+w7VlkQLzlBulnBhIpo4azMJHv0GmTPdSIthCt0+nmZCUGnv4r9KaJBfNs2YJt6qRMqnh8kEwcyDUIq5Venrk/2XENcLyjPnnMarZJpZi8oNeGzP3JgGRrWBHYWAvHEWck+90hwfwr/c5VTR9SsVk+S5haVEyozZ3RW4Sz92ajEM3q/gGoLUK60G++zZBYfA775VN1nOqEJ0lpSRrPaTFyXM3VZ1V7hg5H4ugP2uOpiaPHdjyqbQycuqTzUjTLO55nGFsHvYiU7SAV3FhLyUOGMWBqiSXZgNolU9sSZoWtYXxEL4rc65e9EGiUj6WITAUBJE2fk9NcKt4REu2j3Fu9AVhLES+w4459XBnxjQNZ76M0E8SploOKkP9lzrWDfDbVOv4xsTPTzUdk7keIdZyJomoatknciDR3ensW7X1XKNE3ccoshhBiuH5Y2QSrjL45Kbm4R3VkIINpxVmI3O5Ce0bXpZqep8FpSfqJdtFmtxBi6YLNamT43f3/Llmosbzoleg2y5zoahAmMAAAgAElEQVRRtspDXrNaIu1Wos/tB3LrDtZaJkxdK7UQLuNzz9i0yjjao4mzulGGCpNMnptdTzQxWV4OeX8ortpCyEOFM2JpzDgIOYWmRfXZv/DEq3js8kD6eeyGIhrEb7etQjuRwjDEx/7qxULLvY+nqWxMtsZ9ufrs5CTUi1Q2RqXTz3fXZAXxXCG8gD0/d/UY9zxyRfp5TKJNXJ/dmnmeDF966lU8eqkv/bwZ2ZgMR971KIi/kXG9cpNyeUlZ9vMiE6RTz8ev/sUL0t+xMAxxMHKFZaCAyPb3Cyx3f+G1Y/zBw5elnyc6QRr9nC+Gq020e0FY6h4ZIhu287esQrioVCOQShPK8NlHruD5146ln7c/dIT3mwHRxFm/wE4k1w/wkb94vtBOOXHp1ZJ8bmpuqSVlSLs5gonfRWPoC5cG+OKTr0o/b19y3cH2AioPn3v0Cp599Uj6ece1U3lgE+pkz3UiiaFV7gmXaShfQB79aOLiY3/1ovS5eTiOdxbKNKt1iikxPX5lgD95/BXp58n53OXZNKk81Is0hq6+mZy/Hj8IC91jPnX/Lq70x9LP60tIrxLyUOGMWBpSI6xcJ12Rbrl/8QeP4aN/+YL08yIZKImkXKdYt9zzrw3xU597An/yuHxgwjsJWZNu3sxIehn67OT014mku0ZlYk6wmMMX1Yok2n/tqxfxT3/3gvTzDoZs34LsTiT5RPtPfe5J/OKfPSf9vFnZmIwgnvuZaokJ1a9ByFPGBKkjcUYvos9+3wv7+JeffxIPXDyQet7hxIMfhFLdcizRLstvfW0X/9unH5HuBJSRjfFKC+LjYniOXB9RHqx5rKz9KaL2DMjbdBiG+LFPP4JP/vWu3AUi2nEmOhEORAm8IIR009lDLx3gpz//FL763DXZS0yaW2pnz5SYqxVlT5xl7zjjVVvkr+eXv/wcevc8If08dtZulbBX+J/97gV8/KsXpZ83FJVqnGlsKaP5lOy5TjB/uLw9pPM/f37HdZGc2BeeeBU/9bkn8Jxkc8uBZCEciIrhRez5Y3/1Iv757z8m/byZGLo2Uo0+NbbUDLcEe54dEMmZfuTOHlmbHoxdfOgzF/B7O/LNnfsjR/h8JuShwhmxNNghsmLp+Uu2eanGAon2g5GDcYGbo4wMFJB24cgm5sZxIFMkoScq7cYcshVLVxrEs4km2nFWL1InQW13zYqlJ7+fh7NAUg5YzJ4B8SB+1Yp2IhXplhs5HvoFCm78+5FlQywgUG3PNEFaT5gNqZwgdf0AtqFD1/KdfnZ/KWLP7NyTDWCYXcoE8Vsdu5BszMiJprRkAxrRbvbo56HQ/XNR0uYWOqPrQpkyUCJnxiLSbiPHh+MHhc7ofcnu1+2CzWqj+Nr64yI+t+DEWZwIsc38GGcRqFmtnpRTOBM7MxaVajwYusXseejCNnR0bEPo8VsLFM7Gro9BEZ9bUOWhLJ87jaHJnutEWSoPzJ6zVVsWjaEjOxlLFtFlY+josVbStCrD2PHRl1RvAk7G0HnFCj5nocYf9vwAXhCSPdeMMiZI+Ty3jM8ta9Ps3CtybzoYOthqizerEXJQ4YxYGuwm0bbNXC3nRW4oE9fHxC22dP1gJC8bA8gH8Sw5fVjASTgWdBL497uM7ldabFwv2DJr1U5/2472AWZOSy0oAzWI9wjKfo/3hw5MXcOZltjOQk3TsN22C+1bmLiBtGQrcKIQLiC907ZNpZ1sZM/1hH0eqidILUODaeQnflOpxmL2DMjfm/YLBPHb7WKyMcx/kLXp2caWfD+H3T9Vd78CZNN1gn0W0xJkY0R8wEXklIvaM8CCeLlCOCCfaGfJ6UKJdokdZ5ahoWXoM81/yybZcUb2XCvSM1ptYo6dGSKNk0CxvcKDsVvcnjuW8LqDjm3ANnRpOeUoHggL+dy86kXWuevM3D/Vq7aQPdeLdCeSyjM6lLbnIoWzwj43U22RzIsVaVabuD4cL5C+RtlmtfT9VvO5svt/3joVolympRTCo89b5Mzg7/dFJs4A+X+LH4Toj10peybkoMIZsTRSJ9TIl40JAjC/W3YR6uECQfz+0JXsrCkWxE+S7ld5p3/keMl7k1WAZGPAbdsgffYbkHImzkK0485SEalGTSsexAMFJlTiCVLRIB6IbLpI9+vE9QsWzlJ7zu4g5u25DOlVcvjrRFkTpJapwzZ0AcmT6IyeekFuI8xJ2GSmbBGQFcCkEu1tC/248C4DuzbZKVLmr2iawKLyQOz+uQhhmOrn0xldH5g/7PiB9HdTFJf3uXNew/E5n1tS5YHZiGwRMAhCHIwkC2dxp6xsop3dN2V9bj8IMXb92J7DzESY5wewDB2WSRMqNyJlTZGyMyNzQiUu3GpaMXn0wdgtVNTfl7RnTdOw2bakm1smC0yQjmZ87vy4RX0MTSoPdaSMiTPenrOktNn3VNOKSa8OmMqDZHGW2eWmxITK5oLNarI+9yh+PzQNuQ0rLvd+qypUs+9LGGavUyHKpUwp5SjPnR//sXNoJGnT7NyTzQcMxi7CUK75lJCDCmfE0uATv7nd7F6I9ZXooC7a/So7jhuGURAvs+OMVe1lg/hpwW52IEpqsPcms0PJS2/gTgndr+T014synISpxzn9AtOP6ytWIenVoja9L7mzEAC2O5b0xBlLTheyZ8dL7Tlz3wJnzwo72SiIrydlJeUsQ4dpaJmfvx+ECEOkZ7Sk05/Ys6TTz+xSpltuq2MjDOXPWnZtslPhzF9ZX7GEOg6T+6eiIJ6/Z1JHe33gvxtTRVOkDucD5n2/PD9Ygs8t9+84nLgIJIN4lpSXTcyxa5OeIHVSewbydyKZugbL0NTuRKJmtVqieidSGIYzifZMxZGA97mLNas5foBAMvErO0EKFJtQYedasYmz1OfOlsfjchYlqDyQPdeLxOdWPkHKfMD8Ii6zZ9n4L/W5i6k8FNlxJnvvKHxG8z53rsS82P1zEfj7PzWg1ody9oTzzRb5RVx2DhWdOJP1uYvsLCTkoMIZsTSY47lqm7ndr64fYGOV3VBkK/HFplMOJx78IJRy+ldtAyuWLj9xVrCb3fECOH6QdN1mFivi93jVyi9ULsKEul9rSSnSbn6AVSbVmOEksITCVtsqJO3WL6jnfDBypYP4rbYtbZcsiB85vnSAfTz1U3sW2LewKiDrsQhkz/WklMKZF8I2dJi6LiQbw763som5ovbMnrcl09xSVNqNndEFg/ittiUwcZbeP8sJ4smm6wJ/r1cVyLPPe9U2M5syoseGqT1LqjwMCna/sr0rUs1qhVUe4kS77AQpZ89AfoOQZeiwDMV7SCnRXkuSHSqK7Jk1rIj43Oz+stW2pO3Z9YPET5dtVjuQ3FkIMJ+74MRZwR1nzJ5Fio+rtqk2hmYT4QobXAl5VBfCo9cIsGIZ0HL2Cjucz+0FobRdJnmxAvZsm3pSbBJhq2MjCIGjieyaFTZxJncvYPeqzXZ+s5rnh2kMrWzijGtWozO6NqSFcF9Z4zGf587zzxwvWEIMXXSClApnqqDCGbE02E2kYxvwgzCzG8X1A7TMaMFw0aWJ0o7FSF4Gij1eXmaiWLfcMHEQomvMOpS9eN+CbepKdyKNXXL660gZ3TWuHyRLwDMTSvH3b7NtSwfxQRDicFLcSSgSxEt3v3LXVcSmmT1nF8LT+2feYxeBknL1hN3rx6qlGg0NtqFldmKza2Hf28I7kWQnSEcOLEPDmuDOQqD4hAqzA1l7Zo0+m207v3Dmh8rteUzdr7WE/7zHihJzLPHXEZCNcfwgseey9i3sF5BebdsGbFOXPqOL2vNJnzt7KiCEZURStyoTZuPkjCZ7rhNuckarsWeXs2dAbK/wZtuWtmd+yrpQs5q0yoP8XmF2XUdxw6sMw6nP+dzZ9gxE77dKf3jsULNaHSlL2i1ttsieZgaW4HPL2vPQwbbkugPWCCN9Ri8wcbZqGVgxsyfrwzCEF/A+t9rm0+g1yKbrAlPeCkP5/LAofJ5bZECkbHsuotpCyEGFM2Jp8It2gXw9Z9PQ0WmZ8pX4RW8oBRLtRXecySfl0s4aIKfj0A9g6npUOKPu1xsO5hTKSjPIvYbYonIW4G+25WVjjiYeWHNQ0R1nMmx1bAzGrtTeJn6qbyC5cyEqnAnIQHkn7p/KCmdUCK8j7PNQbc+2qcPMmZjwkiC+qMwEm1CRD+KldxYmcsrFmlukd5zF+1POrAgsh+bun+r2LaR/L53R9YFPkqpKzPFnRn4ndoAzKyYMXSve/VrCzkJN07BVaCdSbM/SSTlWCGdyytkTZyZrVitD5YGkV2uF6p1IJ2PoLAl+l/O5RwVVWwA5m/aDEH3JHWdAdI0Hkucsf67Jyikf8z63gMS8yP1zEWjdQT0ppXAWqzxYerY8OvuebiYTKpLy6MkeUtm8mCu13wxIi3uyPve04Bl9PPXRaZkwDU2omUB9DE2FszrCfxaqpsJnz4w8xZGQi6GLrTsoMkEKyKm2EHJQ4YxYGvzOLSC/6GMbWlQ4K7g/pUiSHZBfmrhIt5xs4YwtkNxcFZGNCWEamnLZmCkVzmqJaqc/DEO4fpjac6bMRJxoX5XfccbbiIyec7Sz0JXfcda2pHci8e9xkR0qTJY2KxHGimpl6bOTPdeLMrtfTUMT2rfHziHZxcbpGS05cRZ3v8rAAoSymluGjoeObaIlkDz3uPtnGd2v1NFeH/jPW1nhbGbfQvZn78bTUm3bKHxGS9tzwX0LW21beq/wIt3sgKDPHYRC0wOLQjvO6kkq7aY6KScwcealPnfRCVJA7t9yOI53FhbYcdaX3Ik026wmGUdPPcEYOn2//SCUnmwTZUr2XEvK2olkxc1qQioPq0XllAuqthSQXt1eUOVBthA+cjx0WgYsQ0/uwafB7pfqY2iuWY0aUGsDf39VtcKE34uZleMGopx4EkMXVFYrMhEO0I4zlQjp4fR6PQ3AtwL4OwC+HcDXA1gH0AewA+DXAHyy2+2e+i3q9XptAD8O4HsAvBXAGMBDAH6h2+3ek/Pa3wjgnwL4GwBuAvAqgD8C8H90u91dkesnyiGRmWiJFc4sQ0enVUSqsdi+BRaIyyfmbFzuj6Wewy82DsNQuIP+WEaqMQiiTqYcZ2JR2PtM3a/1ItlxpiyIn7XnTJkJTqpx7PrwgxCGLvadLxzEF9hZCKSF84ORi5vWWkLPmSwk1ehjrWXCMrI7DhMJAIH3exGYQ0n2XC/YvV7lonInTp77QZgdxHP2DJQn7dYvKAMFQL6jfYFEOwviRXacpfasvvuVbLo+OCXuOOu0xGRjmAxqWbIx/QWa1YruRCqu8iAi1Ri9h3ln+aJM6YyuJU78uahLys36gHkxtKFrOLMiv+Ns1ucW/7ccLFAID0LgcOIKK0QUbVYLghBDx+diaAGpRu6MNnTxXU+i0ARpPZkqniAF0iZxy9BzmtWKSzWGYbhQQ/nX37Eu9Zzie0gX8LltE7aRvZbk+pxFCT63r+67Q8gx63MrmgrnBkRyd5zF+/ZsU8dxwTNadoL0YBjtLFy1ln+OERGiE2d/E8BXAHwIwLchKpg9Ej//PwHwGwDu6fV612Uhe73eNoCvAfgJAO8E8DSAQwB/G8Bne73eT8170V6v93cAPADg+wBYAC4A2ADwPwB4tNfrfUDw+okSSBaVW7HMhMCS7Y5tFk/KSS6AZIH4pmRibqttFXYQ/CCU+veli8pZEJ/dcWgaWuRMKF1sTPrsdSTdiaQ2iGf2LFL0Yd9bmUC+z0kfSgXxC0ivAnJOPz8JJyvtdjz14sJZtp0ypz95vxVLu5E91wunjCDei5otTEPL2bdwwp4LSrvJTJAC0YSKrD2vWgZapi7d/TpN9pDKSq9GsjF5UydsYlfk/rkIJNVYT2ZlY9TuOFu1zNy9wk7SrGZKJ9r7hSdIXdiGnuwcEWWrU2APKWtWG7lScQF7L7YEmtWYPLpl6EqT4DRxVk/cZOJMlfTqrA+YH0NrhdYdDEa8yoP4d2wR1RZATtqNl9qSkXYbxZ9NEkMLxC3qz2jaWVhHEntWVAiPXoPtONNyij6zPrdU3sjxk8YZ2d1OB4VUHgoWzuJrKxxDm2LNp8rt2eOb1cim68KsPLq6ZjVLUOmLFc2LNKuxvJisPe8X2FlIyCFaONMAvAjgfwFwW7fbfXu32/2mbrd7E4B/AGAK4L8C8JOnPPejAN6LqND29m63e77b7b4VwAcBuAD+ea/X+y9OPqnX690B4JMAbAA/C+DObrf7TQDuAPCbiApov9fr9VaE/7WEUlJ9drHFxmbhG0p06IahnCO6P3Rg6hrOtIQGLRO22vI7kfibnYyTkBTOOgI7kQIWxKvtfiVpt3qiWtrNuU56NV9mkH1vZWx6VqpR/Du2X2IQX3TizPUDOF4Q6bPr2cUK78T9U30QT/ZcJ3h7lkn8yhDJxmgw9ZwdZwvY88T1EzuW1Zk/GMrvT9E0rVQ5ZRbEmznnbmnSq1wQTzZdH2aCeEWJuZNndNZ+Li+eNu20TOl9C0xaSbYQfjB0sNWxpIP47bZdWAbK8QOppAl7L1KfOztuseIdZyobT9J/CyXl6oRqaTc2vSC27iCEpetYaxlw/VDKNotOnC2i2gIUb1aTOaOvi6FzpFcB7oymZrUbClexaguQSiRH+7kEmtU68jvOitqzH4Toj13pGLpjG7ANXUpO2fODRAq1iGpLp2VEcUvGe8jul2XZM0A+d50oSx49sWeBvcJmoqwmK48enWNFJkhl7ZmQQ7Rw9jUA7+52u7/Q7Xav8j/odru/jrRg9kO9Xi/5O3u93t0A/i6AAMD3drvdPe55vwPg5+L/Pa3g9uMAOgC+0u12//dut+vGzxsB+IeICnnn4t8TNSAJ4tmYdNZiYz/qfC/ULVdwsTG7oUgH8R27tJ1IrMso2YmUM6Fim2V2v1IQXyfSbjm1MlDMnrOSOOz7x763MjbNF5aLTJwVlmqUKpwVmzhj70OnFY3r5+1PAdL3W7bTSBRmz0EIZTsdCHnYdyOQbAiRfQ3L0GEbeqbTf9KeZRLtRc/nIAijM1rSnoFI3qas7tcZ2ZjMZe/x9IDiIJ6fZqLu1/rgzsjGlHNG58uja1grII+eTJAW2HFWxJ632hb6Y1fqfJqdUBG/F4xO+NyZUo1BwO04U/OZen6QJFgpKVcfgiBMpzqUNavN+oDZRdxod1InbgQdSZzRi/rcm2151RYAUon2mWY1ibOdxdDrKyyGFmhWK0keney5XpSxV9jxxM4M9t0rFkNzqi2SBfQwTO1TFE3TsNm25GJovpm8kDx6rPIgMLUnkrNYBP77QjZdH2Z2nClsKGcxdF4jBCuaF1JWK7ySyMG2pKoaIYdQ4azb7R6ywtUc/jD+dRvALdyffzD+9c+63e5Tpzzvw/Gv39Tr9d524mcfPPEY/nqmAD4R/+/fz7guokQSfXY7HpPOc/pZJd4ptqgckO2Wkx9JB4p1y/HXJbMIdRS/F5sCUo2eH8DUNVg5CflFoQmVeuIqlnZzTthzZudm/F1ci4P44t1yMrIxxbpfk8XGEgnzooVwdm/r2Pk7kdjnmdw/aULlhmKmW07hhIqVSDXmB6DrKxZ0LVrOLUpRez6aeAhC+QlSANjuWFL2HARhUsiS7n51fG7HWbY0HgC0TB2Grm4qnLpf60lZ3a+aBqyY+VPKzOdu28Wb1Ryua1yEftHCWdysJuM7Fz6jWaJdpFktlkePZLdUJdnJnusIH88q33EW+4BZzRaJVGP8WJnEXHGfuzx59KL2zAqInVZ+c8t1OQvVKg+046xWsHu9bEOI7GvYpgYrR+WB3xMOyK07KNue2XPKsGcgei86tglbUKoxsWdlzaf8jjOy6bowUzhT9Nk7ghOkYRhGth/LKcvE0MDsSiIZ+iPxPaJEMUQnzvJY5X4/5n7/rfGvf3Hak7rd7i6Aiycei16vdxbAXVnPBfDl+Ndv7vV6tAWvBiT6wgIyE14s1dgpEsTz+uwyTsLQle6UAxbvlpPprjlOdpwJSDX6IUzW+aDokAjDMJl8ocXG9SJ1+lUF8bOyB1nfRS+I7TkpnBV1+gtMnEl216za8U4kGaef++4XScp1Emm37G52dn2Auu7XKTn9tWRWn11dYs42dZiCi8qLdMsV7WbfT4L4Ime0nLQbP805KDJxxuw5p7EFQNKdqKybnbpfa8ls96uqID5SbrAMLX7N7ClSy9AjeXTZHWfcWSkjCRd1vxZLygGQ2nM2KbiH9Hjqo2MbaBlROJw9FR53G5v5i+GLQvZcT2YL4WonSFcFfG4n3reX+NwF9wpL2fPIgW3qSUwgynaJKg/Hic9t5J7R7smpcMXNLaTaUi+Yvck2hMi+hi0g7ZbuOCuw7qBk1Rb2nMKFM0l1CLZXWFRiflXxuoPpTHML2XRdcLxyYuiWqcPU9cy9wux+YhaQR3f9IGm6lv137I+KDYgQ4iyrcPZ98a+PdLvdQ+7P3xX/+lzGc5+Pf333Kc9zAOzhdNjzVgC8WfA6CYWwA0Ske4sF/FEl3s9can6SwdhNxtmlnIRRsSC+aLccu0bZRLupa2gLvIds8WQkAacoyU7dr7VF9b6FRPZAoPuVT8oBkt2vI86eJYN4y0in3GSQ3YnE7jMbq1Yh6dU1JjMhINWhvvuVs2kqhtcG/rNQ1QHr+iFsQ4dtaNk7C5OijyYtp8zsY2PVkp4IB4oF8dsdWy7Jztnz0dST2l/KCme2oWfvlArS4qNlaAr3LVCivY6UUgj3wrhwFoVyWdJuXhDG9iy3b8EPQhxNPc7nlpsKl21sATifW3IPaVGfu9MyYZnxe5jT8JfYcwmFM5JerQ9uCUk5GZUHL5bq78SyZDJn9GHRGDpWbZFdd9C2DdimLlkIT+WiizSrMZ87s+HvRHOg6mK44wfK9tcS8vB5E9n9ncKvwUs1Zu6sZ99FE5ahFZJHj3xu8e8w87mLNrcU2RMua89hGGLoeFgTUHkoe4IUoBi6TpS34yzKuwLzldX45lNZefST9ix6Znh+gEGBnYWEHAsXznq93n8A4Efi//2ZEz/ejn/dz/gr2M+2TnneQbfbnfeN4f/OrTmPIUqEJYZWbYHOTX820S7aLReG0TLT29dXAMiPpReTgSoQxHtBco2yO5E6LROt+KaclWzzgmjxpJUju7UINJJeTzw/APPBVcq6AYAdS43l7VtghXBAvvv11jMtAJL2PHSwWSCIBwpMqMR2cPv6ykz3fR4zO84EZWPayrtfyabrSFkTZ5ah5XZusmuxTPnFxsw+bl9fkbZnoFjhbLNtYzB2hQtg7J7JzujDifj96njqcYXw/D1xZtLcokp6Nf17aSq8Psx0vyqUdrPiCVIgf6+wlXS/in/fjybRHpTU5xb7t/hBWFyqMX6ObHMLu0aZKdJjJ7VnID9uMXUt9yxfBP6eSedzfSjnfJ4t5GTt6El3FrJmNbkdZ0Vi6P2Cqi2apmFLdidS/B7ftt6SUm1hsQfbiZS9JzyAzkvdKipU04RKPZmdUFHXrGaZcZ4ma/qRxdvxGS214yy2j9vXV6QKgKwZvIhNb7bl5NEnXAw9GLvCzfIjx0cYsj3heVKNbOIszp+VoPJAZ3R9cEppPo3XHehR3mleo1USQxdQVmM5Y3ZGi+67ZzsLtwvYMyGOfKs+R6/Xuw3A78Z/z+91u91/f+IhK/GvWd7SJP6Vl3uUed7J5/LX98MAfhgARqNRxl9FLIOkEm/ky0xEzgQv7ebjzEq+sQ8dH34Q4tb1Fp5+9UjYSQiCEAcjt9iOs7a8bMzU9bHRtmAbuuSEin8iiM95Dw0t6aoLghC6Ll9EyGJ2OoUc/rpQVmcNgPg7li8zwXYWAnJB/GDsYqtto2Xq8jJQBUfSZSdUmONy63oLV/rjnEenDDnZmLxE+3Xdr6omVPgdZ2TTtaEMaTdmp5ap59hz9DM7bm4psj9F1lb2F9m30LYQhtFr37TWyn08C6qYHzEYu0Kv6/kBpl6QdLT6Gecu83/YRFA5zS1kz3WhPHvWUqnGOc0tYRgmi8pX9Wj6kd0L8uDtOfK5xf4th2M32llYaMdZFAvIqDxMvQB3bKwk9izKiE2cxe9hXqI9SoKWJL1KhfDaUEqS3ZttnsrbK2xxzWojyTP69thWZBPtRc5nILoPyKw7mHpRM95W3BQjCq/yYOcVK4LUHwLKaVZjctlE9biKi+Fsz5El4AMm8bYpn2gfjF1YhoatjiVVMGD2WHTirD9yhPNOfAz99KtHOHY8rIvk/KazhfBMqcbr5NFLUG2hwlltmN1xpqqhPEzsGZhfOGPXEk2FF4+hmc+9YuXLI7NCNk2cqaVw4azX620A+EMA5wA8COAHTnnYBEAbQNanyIpkfIaFFcVEnnfyuQndbvcjAD4CAPfccw9lFBSTVOJZEJ+z2DjSZ49lJgQnVFg3+22S3XJHEw9+EBbqrFm1DaxYuvTE2caqhY22hcFY/Hkjx0PbNpL3MG/KZ6bIFgRo6ctd90cyUPXEKSEp53AdcJae3bnJdhauFQji+yMXd221sWIZUk5/v6AMFBB1y12WSOqn3a8rePLlw5xHp7BJnbVkx1l2EA+Ak2lVlZijjvY6whcxVTn9UyYbo2vZMoN+Oi0lu9h4MHahacAtZ1p44bWh8PPY2V7E6WfPORiJFc5OTpxFr93JfR7Tne+0jCQRMO/c5d9DtYl2CuLrCP9ZqNpDyiSS84L4VDY0lQEfTX1stPMTuCe7X0UTjAeLFMI5exZl4vq4ea0FQ9dmdjjlEe1PMXLfQyCWu9Qje1Y13ckXMsie60MpSbkT8ugiO66LyKP3xy7uPrsJQF615evvWBd+PA9LtIsycX20LB0bqxZeuibe+DyasjPahCkg1cikVwF1E9sUR9cT1VOkafOUBtPQMXLmvwaTajR1+T2k/XjdwYplSE1p90cOWqaOVYGk/Em22jaCEDicuNgUaMbF9BIAACAASURBVI7hVVuAaCpcqHDmcDG0LtbwZ+rlyaOTykN9UF0IZ6/BJkiB+TkUj/sudlpGPDkZCikksZwxy3NPXR9YzbcV5nMXaVYjxCnU9tLr9dYA/BGA8wAeB/CfndhtxjiIf70p469LZBlPed5Wr9eb9y3b5n5/MOcxRIm4J5zQTD3nuOuKdW6LdtcMxsWC+EW62QFgW7ZbzvWxYuqFdiJ1uGJYplSjHyayMYCaRDsLEFctg5LsNSJZIm4ZymVjIimo7IkztrNw1TKgacX2LaxYutxOpAW6X4vos+sacPNaKx6HF7M1FvxEuvU5HYdeOYuNJ66fBEoUxNcHxw+Sz0Wl02/H9pw1bZjKTOho23KLjQfjKCBetQzJCVI3kqmx5YP4NNEuZtMsWcgCE9Ez+qT0KjD/3GXvYRLEl2HPFMTXhkQ2SOEZzc5dJhsz737ucvacTIULJuaYbdxWsHBWpBC+ahlomZLNam7Ulbu+Ysr73LagVKMXy6ObKu059e3ofK4PvD2rlIECUh8wK/5jO67ZdJqozx2GYTSZ3bFh6lqhHWdF2JLeQxrZc9G9wm3LyD13XT+IpJQFbH8RJm7q21EcXR/cGZ97+Z8Lf+5aek7jJNeo2paURz8cu1hftbBiyvka+8Mohi6y7oD53KJxNMslFfW527aRe+7OqOQolkdPY2iayagLjmJ7BtJzl8mjzxtu4L+LnZYJPwilJBcBSMspL7KzkBBHunDW6/XaAP4/AN8C4BkAf7vb7V6b8/Cn41/fkfFXvv3EY/nf24gm2rKeNwHwUtY1E+Uwva77NVuLmN1QAPFuOba74Lb1eCeSYGJukSCePU+2W27FMrC5aknvOFsTSMpFPwuUd8uxG/aZFZOC+BrBPoszKyamnpqF0zNOv6HnTj9ahg5Ni2QmpPYtjKO9CSuSCcaDYbH9KQAS+RfhnUjMntsWXD/M7BzkmZWNyZFqDOJ9C1Z+0XwRJm6AMytqlycT8rh++rko3beQyPvm7wqwCyw27o94e5boZh862OpYhXcWAhJBPLc/BShWOLNyJutZo4Ftqp9QWSN7rh3s815bMUuRXmX/f+rjvHRReSqPLqjyMD7hcwsH8bEMVIEzWtM06eaWqetjxdKx2bblfG5HQqoxCGdkoFT4XezedGbFJOnVGsH73MoK4fE9o2VGxXARnzvdKyx2TRM3gOMF2JA8o/0g2i9eNIbeLrBXOLJnS3KCNFJt0ePJ0Gzlm1nZLRXnZxiGmHg+53OTTdcF1wtTn1vBFCmz5ySGzsnnAJFUo6w8en/sYDNpPpWbIC0cQxduVov8CNEz+voYOqOZPJh9v1U2n1IMXT9cP8CqbUg3hMggqvLA/EjblJ8K7xfNcw8Xy3MTYkgVznq93gqAzwL4TgAXAfytbrf7SsZT7o1//c45f985AG+J//c+9ufdbncPwOWs5wL4j+Nf7+92u2oshJDC9YPY4c92QoMghB8HoGvcjjMRUu1XuUo8u6GUtRNp4kbvhWy3XCobwxZP5gdOtqlueoQdPuurFjn8NYIlwtbj8W3RThYZkoM/dhKcjAkVL95ZCEQyZqJJOdcPMHJ8bKxaaJniTn+0s7C40886ckSXjk88P7FnQC7RzopheVKNjh91s9uK9y1MXT/53pDTXx9cP0g+FxVOvx+fu7Zh5BZy2PeCSTXK7ltI7VlugnThIF6ycHarZPdrGsQbScdh3pSPqetoqex+dQOsWFEynxLt9YHtH1u1DGXSbq4fwjYjKWX2/6cxs6hctlntpM8tGcQXkUePnmdL7TiLzmgD69I+96zKQ94eGiueUAnD6J66bJgPFPncdD7XBWZD66uWcpWHZCo8U+UhkmpkRTZZe07OaEF7jpQWgK2C9rzVttAfu8I2w+x5Y9XCxA2Ep9dZIRyA0F4pS9cSn1uFvTl+gDBMYzWaCq8Pqn1uPnmeK9XP+YtFdpxF9iw/cVZ03QG7D4gqMRX1uflmNVPXEWScuyxHwaZIs3IWizChGLqWuF7UGCrbtCn1GrFqi6hUo2UUV1a75QxrVpNUViOpRqUIF856vZ4F4DMA/haASwD+ZrfbvZTztN+Jf/0bvV7v6075+Y/Evz7Y7Xafn/Pcf3TKtbSQ7lT7dM41ECVx3aLyeUsTua6QZMeZdPerpFTjgiOsW5LdchMvmlDZaMtNnDGpRiNHegeI9LNN7v1WM3GWdr+Sw18f2GGdTqgs3+lPl5tqkVRjRverE+8sBCIHV1YGKplQEQyOjyYegnCxCVIAwlOkTDZmU7pw5qPTMqFp+XuOPD/an6JcNobrflUVWBDyuH5Yij1bphZ3s2d9F9MzWrb7lQXxK5YBLwiFpzr7ixTC23I7ka6TahR8Hmvw6djcVPic9zHZt5DsOFPX/bpiGrAVFucIedxYRlFWglj2NSxDS3fizgvig1l7BsR97sMTPrfovrZFdpxFz7OE7dkPQrh+GE2orFrJNYswnPpYE91x5oeR9KqpUB6d97nJnmsDi3/OrJiYKIqFZqXdcqYrYskoTYv3kEom5TZXbSmVh0XteatjIwwhbJusIWQjPtvFm1v85B5nGfl+jslND6hoPOFVWwBKtNcJh1N5UCG/yis3WIaeuVc4WY1QsFlts21L+xr9kbuQagugXh79mFd5MLPzYryfo9IfnnKqLSS9Wh9YUWvFEm8IkcWJp5RZvmuev5gWwos1q51pmcnzRIuA/ZEb7SwssO6AEEeocNbr9QwAnwTwXwJ4BVHR7MW853W73YcB/H78Ov++1+ud5f7O7wbwY/H//sQpT//XAEYAvq3X6/1MXLhjUpEfBfBWAHsAPibybyDUk0oH5nVizzoIgHz3a9FF5UW7X7faluROpEhmYkM2iHeifQuapuV2kLtekDgIgKqJM+b0W5iSg1AbHC/9XIAS9NkFOjdZInlNwulnReUNSX32dGdhOd1yUy/dtwDIyUywID5XZiJZOqvOnlmCkX1vyOmvD44XpPasIDGXFMJjabfsnYWz0m5TLxAugKWFs+h7LPpvYfsWirBqG1ixdOEgnnWvr7VMtG1DePL01CB+nlRjMDuxm7VTbhGYjKzKZeiEPI4X3c9Vdr+elI2ZW8T1ine/9kcOViwd65IysvsjB7apJzuYZJFpVmP2zM5oUXv2gxBj15+VXs2bUImlVwE15ydL+JxZsciea0TarGbFfpRKn1vLPaNZvA0gbm4R851Zs9jGqoWWpQurVSQyUAuqPIgqt7CGkETlQbi5xUsacnMn64MwmSAF1EyDTd3UngE16iBEMWZ8bhXNakyq0YwanPPtOSqEr7UMOanGUdqsJvP9WnRPOCCv8sByd6Lyq6xZbXaFSf6Uj5Uz4bcIUfNpHEOTPdeGaXwmyk5eysByXXn+YqLyYPIDIoLT3aN4Z2G8r0102nqRGJoQxxR83PcA+O749xMAH+/1evMe+z93u90d7v9/CMC7AdwN4Pler/c4gE2kEo3/qtvtfu7kX9Ltdq/0er3vRzRR9iEA/7DX670E4J0A1gEcAviubrc7Fvw3EIpxvLgSn3S/zgvi+Ymz6Cs4EpxQ6Y9c2IaeFMBEnYT9oQvL0JIktixbHRuHEy/pUMsiDMMk0W7qOo6mYs8DgFE8oQIg9+BnTn+aaF9+Ym7qzXa/hmFYaAfNMrl6OEF/7OJdt50p/bUffGkf771zIznQqoLftwCocvpTJ9TUs2VjWLc3EC3xHUlKr7IgXjRY2F8wiC+yE6ll6thoy02cjRwvSRzm2bPDutkV2jPfzQ7UQzbGD0J87cV9fOvbbyr9tS++PoRpaLhrq136a59ktvtVxcQZF1TqWiwhdPr9nC+yse/v0PGxsZp/hg24nYVA9G8ROXcPRm5h2RggmjoTtWfWXcwmVGTsGYCQtFsqdxkVKscSDTQysM58lVNtsjyy18fbbukkyYWyOJq4eP61Id5/drPU1z0N1pkq0xAii+sHQvv2Fgrix24ynQKIB/EHQwfbbbuwvygjj86KeStmFBsIT4Qze7ZNoWJYJO2mwxYoshWljnuFL/fHcLwAb725U/pr3/v8NXzzW7aE4ieVnOZzW0u+plRSlfnc2RMq7PXbtrg8+ozKg2kI+xrLUG0B4kT7LfmPn3oBVgupPHhox80Btqlnvi+s+TRvkmUR6jhxNnF9PHZ5gG96y3bpr/3sq0fYWLUSyb4qmdkrrGBChW8+NUVkQ5k9t0yMHF8o3+IHIY4mHjZWLYRAsvM873meH2AwLj5x1rYjlQPRM5rl6jbbFmxTl/a529xUeJ4ktamrV3lYtfLv0WXywMV9fMObys9N7Q8dvDwY4713bpT6uqfhelFRS4OaCVKAV1bL2yucxtCrSQwtfkaz8xmQW0lU1J4JcUS9vhb3+7cA+LaM/2asp9vtXgPwzQB+EsDzAL4OUeHsSwD+6263+8/mvWi32/19AN8E4FMAPADfiKhg9lEA7+t2uw8IXj9RAu7JiYk5Y+nsz01DRzu+yYt2yw3GUSW+ZerQNPEEI5OBWiSIB8R2IjFN86j7NXLKDif5N0zHC+D4AdbixIZp6Jld/l4sj6dyQiXZcbZiKtvpIMvP/+mz+OH/t3zT3x86+O4P34s/ePhy/oMVwz7rdYVO/5Rz+i3B7yIAKWm3wTjtfpXpzF9W96u4zIQ/M3E2EOyW42VjzJxF5d4JqVuV0qvrNQriv/zMVXzfr96H564elf7aP/47j+AnPvtE6a97Gq4fcFMdaheVsyTkvPs5+56aXLOJSGIuDMN04ow5/QLf4yAIF5JqBOKdSKKFcG5CZX1VXE453bdgJPe7eYn2RKpR12Ar7n6NJs70WkyQen6AD374XvzGfbulv/ZvfW0X3/Phe2vRBcw6U1uWrkzazYmTbYlszDyfm53lnGyMaBDPd7MDEhNnQ7ewwgMQ2fNAcCcSu1+yM3owdhEIPI/fn5L40XMmQ4MgRBCm0quA+jO6Dt9jAPjJex7Hj/32I6W/7vOvHeP7fvU+/PnTr5X+2idhstayk5dyr3FS5SFjKtwLkibVTssUt2euWS2SdhP0uRdWbZFvVmOqLYC4ysPQSVUe8hr+0nUH6idIU5+7+hj6nkeu4IO/ci9eP56W/tr/6DcexL/9wjOlv+5J/Ph+rtSeZ6RX85tPzXhFx1rLhBeEQo3hhyfsGRBrKF90Z6GmadhqW9ITZ2xXuOgEaaLyYJvJ/U5s4kx8mlYWtroh7x5dFteOp/jgr9yLzz58pfTX/pUvP49/8LGvlf66p8GKzzISxNKvETdbJAMic/xM9uemLhdDA9EZPaPaIqHERBNn6hEav+l2u58A8ImiL9LtdocAuvF/ss99FMD3Fn1tojzcWHM9DUCzE0q2oUHXNXSkuuUcbLYtaJoWLzZWLwMFzHbL3bzWynwsc8Bapo7NdrpLKe/1+SAeiGUmchwtNpIOKHL6OalG9ppmxfK5g7GDaxKymcviYOQgDMU7H1XCy8YAiqQauY4ZS2BRObN7mSA+7X6NOtrL2p8iq88+jac6NiX3LQynJxaVZ+1bCKL3MNqHpibRzu6XdZJqZAmRa8cO3nFrua997diBhmonaBmuF6Btm9A01dKr6RkdJY5OeSzn9HcknP7jqQc/CLG5aqMl4fQfTtxoZ+EChbPtji1VCAeiRPtmW1xO+ZiXjTGzJ+vZn9um2mmwiRvgpg7bcVZ9ED92fTh+gP1h+Um5a8cOHD/A2PUTCeuqYJ2pK5aB147UvBdsGbqdTExkfxf5HWcy8ugbbfkgXsTnzWK7bSX+Vt7fc7JwFobA0dRLku7zSHYWtgwYugZdyyg+BrNFDUBN48nU9aFpUaKwDvYMRGe0jFT9smCvWQef273O51YzoWLoGgw9lnbL2InkBcXk0ZNEO9srLOxzR88rvuNMrgA2cX204vMZkNwrfDPncwtM+ZRRCE9j6Op9blY06Y/y8xnL5tqxcwPZ8+yOs6zmU7afCQA6bEJl6uVOEPETpP1R9Ges0TMLZs9F94QDsZyyqD17ftzwrkmpPAynHlYtI74n5kg1BmmMk7caYRGYjGxd5NGPJh7CEJXkxV6viT0DLCeqQdMU7zjjB0SEVB7kCmeDsYt33bbGNauJ+twu3rS5KvRYojjVRpbEGwpHsBLPSzUCkFqEyrrZAUjp2B6MnIW6X2W65VjyvzUzoZJ/sByfKJzldamzxIxdhtPfqs8i1IkbYDj1EIblJhXYd1TVvhIZmEPOPhdVQTwQ6bOLyEyw5J2MPfM7zlqm+GJjliAv6vQnO5EkJlRapoGOHTnwMhMqovbs+GkHcd5uhqKctOc6JOaYPYkWW5fJ8dRT5mDL4vphtNhYkbQbu3dHhZzsZgs2LRPtWxBPtM/as7jTv6gMFBDdC4SDeK65JdqJJLpvwYOuAauWkRvE88uhVdkzEPkbkVSjVgvpVfbeiqoILBP2HVUhdSpLKd2vJybORPYttEwdhq5J+9wtSdmY/ZGzWFKuI+5zn7RnQGwnEnsP1maa1bIb/tj+qejP1DS3tEw9LoRXb89AdE0yO3eWBXvNOpzRSaI9/q6ISpbKvUaYnM35PjffrGYIS6/2Ry50DVizzbj5VFx6tWXqWC0oBSa/4yyYsWeZPaRMtcXKsaFUelWlPPrs96YeMXT0mZd9RodhiOHUU3YeyuCcsGfVE6RmznQSL9WYJtrz3yd+gjRtVsv/tyzafMqeK7yHNLZnILpW8T3hPhdD50g1JkoZkfyqqviWTcPW5Yxm93BRn26ZDKcevCAU3oGtEifxucUnqaVfw/Nnd5zl5LltQ8eazWJo8TOa5cSAcvaEE+JQ4YxYGqxjxtKzDzeP69wEIidBNChjNxQA8c2xnKWJrFtOpKOd37ewLuH08/sWAMTLobM6DiOZCVtlEF9TffYgjDrby+R4wgpn1Tv97FBm3y+VhTPbiALLeYVwgMkMFpFqjOxifcWM7FliZ6Ft6ElnXhGinUji3a8rVlRI2JDolouCeK77NU+qMb53qnLIExmo1fp0v7JrOhKQs102xzUJ4sMwnHX6Fe5bsOP9KUD2HlKLk4ECxIL4wUw3u3wQv0iifbttSclAsQ7WzVVbyp47thlPheZJNaZ+jsppMNZdXJcdZ2lSrsJEew2aW9jO3xVTYRAf+9y5e4W5aVNNYyoPMjvOrGQKRibRvr3gBCkg6HNz0qsyU+EnVR5sQ58r1ch8cZNLtDtzHrsIvD17QSgkOamaqesn/m+ZpD539facyKOvqlN5cLx0iix3r7AXFIqhWSFc1zUpeXQWQxddd7BqGWiZ4s1q01iC+MyKBU2TVHmwOXvOkmr0y4ihT/jcdWpuKdmmp14ALwjrYc/ebG5DaQwdN6vNW18SPTaciaEBMR/q5M5CQK5ZbRGVhy2pPaTpFJzUHlK+EJ47cZY2tyidOPOCmvncrFmtyuaW6t8HloNWu1c4anBN5NFzv4s62q10gjSPMAxxyFYScXvC81h0ZyEhDhXOiKXhnJAOnNv96qWHGxB1y40cuSAegJTT3x8tdkNJg/j8w342iI+uVUQKipeNAbIDpyAI4Qfs/VbZ/erDMrRkuWU9nIQ4MVey039Uo6Tc9YvKVeizh9A0wNA1mLnTj2HiSLTtyC5FdpP0Ry7OtEyYhpyzczBMJVuLsiUh7TaNHWUA2Fy1hLtfR46Ptp3uLMyUavTDZEl5nkxrUWpZCPeqSbT7QYiR49fCnpmT3TJ1qXNNBtdLHXk2MZHl9LM9aG2JxcYDrvt1RcLpZwXsovsWgHQnkkjn49QLsMK6X9vi3a8jx0uCICunWMEHTir3j0VBfFScq0M3O5vEOJ6UL9+SJNprMqFiM3tWdD1sMjTpxJ6TmOOlGgH5qfCkWU3wjPaDEP2xu5A9y6k8xBNn/E4kgSlSfn8KEO0vm78nLn4PTZ2TxlSTaF8xjTSZn5FsLYuJ62Ps+qV3laeF8OrtmfljqhPt7HO3cxon3YBrbrHldpxtcDG06ORcpNpSPIaOdiLZEs0tAVbMSOHhTMvEQMBXD2Kfrs3tOMt+D6MYmsm0qiycnanRjrO0uaXcM/qoVudz7HNb0b1WxTU5XMOKZeiZe+JdTnGEfX9HAjbdH83uCQfEdpwle8IXkmqU23HGrm9dovl05Hhoc+czkLXjbFZOWYXKQxCEcLwg+d7UyZ6raD49qtEZzfxh9SoP+bKhieJI/Fjb1IXOaCZ1v7lqS+0sZDkpmjhTDxXOiKXBblpG0s2e34kNRE6/cLfcyE06t0SD+CAIcbDgvgWZIP7kvgVATNddSjbmlH0LyrpfTYN7jToE8dE1HJWcaK9TUu7kjjM1sjFBsnPL1HMWlXNSjckiVAEn4TDenwIgcXZEJDiXsQR1uyMTxPtJN9/6qsxOpHTijEk1zvv3OX6QFB9VdctNkyA+3nFWI3suuxBeq6SclwbYqpx+Xq6NTTbOO1/Y9BsAqcXGM92vTJ9d4N50sITuV3Y/EClq80H8xqqFqRcIvedDTjZGJnDKk2ldBP6MrpU9V9D9Wqcgnk2PyCgjyMK61FmRe/5e4etVHkTO56kXFUxYA1hLsKjPdugsQ6pRJDF3WrOa0MQZU3ngOtrz7NkS2LWyCJN4n6pKCXZZEjnlkqXdmE9QB+lVx5v1uVXtIWXfrdyJs5N7haV2Fka2JSNpFU2cFS+EA3LNakzlAUibYvIYuWwHaSrVmLknnJusV9Xccv1e4eq/y+x+WXaivV4T4emZuGLqSfPFMuHXkuQVfVj+DEi/vyI+VLKzkEu0C02cManGRXzuto3+2BVqkmXnGgBplYc1UalGP93NnCfTWhRWxIjk0evic1dTCAfSBrm6+NyWoaOlSKoxCMJkF306IJItGyq7h5RvPo3WJYi9t/0lqLYQYlDhjFgarBKvafGYdEZnDYCZxJzIDcUPQhxNvSQwXrF0oUr84cRFEGKhbrkVy8CqZQgF8fzBKrPj7DrZmIyDP+0g1hR3v0adNSoTBbJMK9JzZkkWFQ62LE4ZMhOcbIxt5nRunqrPLtAtN56VXg3C+bsRZ543chYeSd9s24mzkceM0y84oeL6ARwvmEm0Z3Ucen6YvN+WokQ7C5jZ96ZOEyql2zPbh1SDwIc/E1uKpN14uTY22Zgl1WhfJ9Uot+Ms6ZYrad8CCxhEbDqy57RwBojvIV0TLpzNTpypkGgKwzApAqqUppEhmTirYMdZ3WzaMlM5NBU7WZlcWzL9OOds4TvfASbtJiG9usr73AKF8GXsT2mLqzywwsqKKdusxhLtXLPaXKnGWXsG1JyfqVRjdmKmTBKbLnkP6XHN7BlQPXGWFsOyirg+pzgCRIl21w+FkriDkVNoT/iiqi0AsN2xhOzZ8yNJP/6MFlp3cJr0aua6gzRuyZJpXYTrJs4UvIYs06QQXpXPXYMkO3cmqmpWY/du2+T36M33FwvtOBtdr/Iglmh3sWLpiZpQEbY6NsJQTFGJSa+yaz2eekL+atSsJijVeDIHqUS1JfU1VCpJyMDOx7IbW/jXrMcZHcKKVR6UNJOfMrCQq1AguYeU2TNTVBIdEFmGagshBhXOiKXBa66bGYvqT95Q2oKFs8MTQXxL0NlhUyWLdsttC+o58xNnVryHSTQpB3A7zgw9d2eFqauVapzGXX8qp9pkqWpCpY4yE2qlGtNuzGjiLCMAPdXpF+uu2eQmzgBxffaFJ84kdyLxTn+RQngyFZCx+9Hkul9L2VlYA3ueVjVBWqfpFK5wpsrp5zvgEn32uU5/kHxf030L4on2zVU73bcg8G/ZHzmwTT2RhSzCdjIVLian3OIK4YB4c0t6Pke2Oq+j3ZspVKoJ4l0/RBCy7ld1y9BlSCfOKuh+rZFNs2YSGfkkWaZxcc7KOVuub1Yz5HzuZELFECuEL2GCdNU2sGLpcnuFF2xWy2pYYUkTk5PpUdFtPolloCyFe5dkoanwU3YiKTqj+QmoeYVwfpoZKOBz81KNohNnS1B52Grb0s2ngPhOJPZ9WeOkGvPiFubnRNNpy/9MpycKZ3VItLMpuLKnwo8m9Wk+5Xf+qiuccRNneXuFOalG5mOK2nPbNmJZ6HjiTOBc2l9wBymQNsaI5cWCJCaQW2HicTF03Ewy59/nBenKCMvQFJ3PaX5PpZKEDIlUY6V7has/o9n5GRWbVDSfxoVwfoJ0XqNVkMZ/gLiy2mnNaiL/lmXsLCTEoMIZsTScuNoPxNriuRNnTNrNEErK9TkZKCCWdhPRch4t54ay1RHTc06C+MRJsKWkGvkdZ3OlGrmJM9U7zlYsQ+lUmywsqVxVor0OsjHJovJENkadVCMQF8JzpBpNzp4BsUR7f6b7lclMiNi0i60lyMYcTvK73sIwxDROZgHxjjOBQCEN4md3Is3bWeLwQXxG5/sisO9JxzaV7XSQpbKdhZO0m13FNIgMvEOuStqND+KTos+c71i0+yN6zIqlQ9dEJ0id5N+QFsLFEu3bbXvBnYXR/UBsJ1IqvSozoXLMBfFJx2GeVKOe7jhb9veMD+Lrs6i8GnvmX7MWUlBxMwk715adLAzDMJF3Ykm5fIWCVB5ddoIUgPC9KW1WW7S5RUxOmW9WW7EMtExduHCmacCqlXa0ZzUTsMfkSUYtQiS9qistzskQhiG3h7TcYnid7DmZOGupk2p0rvO55yeIgVQGqpM0t8irPDh+/j5izw8wGC9j4ky++RSIdyLJxNCsucWc33wKxO+3zgqVmqKJs9lYrU5n9I3crMbfz2UkS2Xgp9rMnDwNH2+vFbTnlinefHowdBaWdWP3A1E5Zdaslu4hLajyMG+y3iuv+ZQ1lNfBnqdJY0u553MQhLWSX013nCmKobmVCul3cU4+x2PNLXJyytf73GJF/WWoPBBiUOGMEOKpVw7x7770bOZjHM/npN0y9nOdsuNMZAnqyUp8y9SFihgHw+UsTdxq20IyE+wmx5wE0UWoQydOagtI/TCjWQAAIABJREFUNc4mQfMD7McuD/DhLz+few0nYRJ1dZJqrKz7tY5BfMGJs6nno3fP45kFIMdLp8jyJE94fXa2yHck1F3jYWM1ssuW4MRZEIRLkWpMdiLl2DTrfmUJ0I1VC0dTD0FOsmEU2zN7P9jS97ndcn4qj2dl3D+B6D36ic8+jkNJRzl1+muYaK9INgaoXmYiccg5aTdZfuO+l3DfC9fmv8YpZ8bcJDE3Pa5pWpRol9hZqGkaVwgXk5nYXFBiIgniBbtfW9y+BUBsQmXkiMvG8M0tzK6zEu2f+MqLuP/ifu418KS+hpF7zygL2nEWwS8qB+QnVB58aR8f/8qLc3/uByHCMPoeGroGTZtfxD1NqlHEntMJUk7aTUKqcVGb3hScUEnswOQmVIQK4T7algFdT5NtQlKNAo1kf/3CNfz6vRdzr+EkU056Ne81yiAq+Ee/r2wnUg1UHpxYSltmjxDP0cTFT3z2cYyd+c9z/SDxE60MqTE+gQdwEyo5Nh0EIQ45lQeWaM+bcE92Fi7BngcCO5EmJ3zuTWGVh9jn5s7orIYVXikjzx8ejFz07nlcWg3gOqnGWpzR1cijs8J7Xc5nAIm0W5F7zK98+XlcuDSY+3Ne5cHOKfq4nFQ/+/6K5sX4QjggvuNs4WbyROVB0OdmzWoSKg8jx09j6Jxdrl4QcOsO8v3hX/yz5/DElcPca+A5qShVB9WWSbLuoFy74s+bujSUM5UHLwgz14ucxpefeQ2ffmBv7s9n9oTn7hW+vrllmHH2M65TVjN14QlSgCbOyoAKZ4QQn3/0ZfzcnzyTkzxPu9RNXc/oxD6p/Wpi5Pi5iWiW5GeJdtFK/P6yJs7aYouNeQ1kgDn9+c8bTj2YeppwzJJqZH9ucg5Z1hLkex65gp/9o6ekO94ncWe+yp0OsiROf8n7FoY1Ssqxz2HFMmDqmrTT//QrR/j4Vy7i3uezE+0siDeN+ROkfAIPEO+WC8MoiOc7a4D8IJ7tLFzGjjMgfyfSye7XjXak656XRDopGyMip8VkJuwMqVsAuHB5gE989SK+9kKxRPuKFd036mHP1STa+der2qZnul8l9o7w/MIXn8Wn789y+tm+BbHuV2b7gHi33OAUexYpAvaXJAMFiBbOrp84E5ZqPGHP887dyJ6jfQsijSc//6fP4jMPXsq9Bp5pMt2u12bHGfvuun5Y6i4TxwuSRFXV9gykO39lJIh5PvPQZfzbLzyT8fenfrSmabB0PfO7CPBBvNi+haKyMazBbOGJs46gz+2l/hAgJ6fM7BlALKmaXXw0BVUePv3AJfzfX8xuNjyN65vVqk3M8Z932Ym5uk2oWIYm3OB1kgcuHuATX72IRy/1c14jf88tn/QHUpWSvDP62PEQhDgl0Z5t08yeF51Q2W5bCMP8s/Y6nzu257z4dXjC52YNK1nqN2xCJc8fvveF1/Hxr1yUT7R7PnQtbaCr2p4BfkKlbJ87+lxFEsGqYQ0SqbSb/D3mX//x0/jsI5fn/nxGqvH/Z+9Nn27ZzvqwX8/7nc45d9CIkJB0pSuMGRPCJDAakCiXM6diJ06lbEJiFxiIQMqfkEpwIEWqIHY5ARcV+ODY/pA4iZEgMjYyEIYUODGSEJqQ0XzPe8477Z7zoXutXr36edaw397d25X9fKG4evfZvffup9cz/AaLzKB4vgDdQjuJAmd5dJ1x5sJuv7wt7884O3NXaxC2H4B7zd22LW6KalBtsQBWyqod8tlwlgMdyOiv/9JH8L/9sz+xXrsaag99OGC1tcCnw/15COAW4RPoI1mqxi/+5qfw3/8jnmBQVNN85s4WVaofcJdHf0Ipqzl5Fhb39iw8hlscF2fHcIrcYSAxGbRb/RbEA8UNLTdp4mPHJl5s4mdo4p2QNZo+u28TL+SqTPrspaKfK5ksFoZK2/oX7cLbaXiPdYt+YRoNLI9+vTog9KtAOe2qzy7z2fBZVBaZyeOM9Vuw5PNdWaOom1E+A/Ymfk4ZKPXf40L3WxhkJsyvm3icOchpuRb94vf2LdpH+uyW91gqBhmodRikwPos0kIZbG+ScKdnTF415nyW6NdIyhPxfnutvF8BP2PjqfSqI/r1nvl8kkY4SSJnD5VJPjvKr55nY48zDiBUNeN8BuxntK8smzpgTA8M/QosO5hTm9JDGMyVVTP2HfFlhZeNcQAmnxmjmtss1ajKxjjJQOmyMY4Dxsc3BbI4lBKIu8YzZ24qD7nCpAa667WdzwD6oZyyOAsDloUrGWehAlYz3Gfbqt6JyTzIox8G40xFki8u1XhoMlBKPvv+tgJEYHo2lVU7qrlZ8Gkz3IuA0kNbzmjBwnzgCVabSwZKnPG2mntgkA75XDWtFbEveg7dV9g0i5CqGtaau/vf/M/opmenCHns9e/ltWvuumlXf66J98/iENkOUo1VL3Fqel2pnNHyXmSlgAepfsADrHbrDz4FhMfZ/Rikfh5nY59wAFZW+G3Rza2GHtrC2mtU8KnZV1g8h3fJZ6CrhQ4HrDaAT20EhDlDrQcO4Ywu5Bm9G7glrxrrjBvonhni7LX5CkfhwAp3tTuIwkCe6VkSOdUaL92U9/YsPIZbHBdnx3CKYXFGJ3DTtKiasbSbq1TjqUTL2eUigPEm3qlAuO18V87uuYl/5jTFlYMnkmg0pSfSaeLon1KPrtGEZqH8akwMFVn0+w7ae/SrjSK/VKgHyFpF/6EYG8dhgDAMdtJnLyz5LN5DILxMTaU69AcG9KsNLUflM+DexM+FlrMh2ikGKWBHy+mehbZBWKnJTOyriQf6wu9ABu1roV9Vf4clmTFUSPaIkI3Z4RlTVI1TE5/EgUSqcwOlQpFqBLrBnKuxsciPMOxAHS5F/+MZjMoBAW5xk1MWz5uLTYwgsBuVV3WDvGoG/xQPzwobY1v4KOY7nM9ALxsTH4ZRuXo+LnlGq+91CLIxwuNs4+E7Mn59Y/QfGlhkg8ygs69wGqOoGuv9Is44ddDu1sR3DNL7eBYCHUPFDaxWI4kCOaR4eJLiyZ393pswzgxnooogdgGS5TsswgFV5aEftK+9OFM+w+JSjdKHdP18Fs/zNAoRBLsN5QDz64q6kWezk1RjrIHVLM9bXXrVdak/lwyUGLTbam4drPbIUdqNU3ngcqhSvFxN3zdwD7BaX2sEQXAwg3ZxRi8vvTr8fqvLo6sqDzuAT8V9YB60D6xwm1y3ClQF3AftTxTpVdd8lp6F9wWr9X6ivmA1/x7aUaqxbkdSt3XTsvWTzGffHroa5nvpodTcyvm4pBKT+vxY+4wePH+D3Wtu6+JMkeuOzEBoIe0samBXsJpgkIrXdQQRN3n0++bzMdziuDg7hlPYiv6BAeXBOIv9pN2ekEblbkO5Z86S+zfxjoN2iqGyi2yMqciWCOIwkP4WxkF7tXuRILScgfWbePX+W1qfXRQkh8A4U03EN0nkPSiU6FdjEz8swuPQkM/VOPfPHZt4ygS1uyZbE9/LxsyFlrMM2rc6mv3UTZ5CLA6dpRoVmYlOn92hifdFPfdyGUEQIImD1fMZUPXZ1/M4Wxstp3oh7NLEA11Ou6Dlkii0sh93lWpUGWeAW9FfNy0u78p75zPQDdjcpN2GxVkYBniwSaxG5QLYM/U4c0CzW/5W1Ay7NvFC2u2Q0OzAiouzA/geiqpGEg3SKd6D9v7vuYGEDkBLIv55Xmh/6zNov9jEciGVOZquP74tpBTyfUJ4Itm8KlTpVaCvuR2eAzf54FkImMFqg1Sjm+fvtmyM/kqm16lgtbVzelxzryXVuH4+5z2YJAh2k3ZzkZEVgz/AUarRUx6dYpDargmYT7XF1ROJkmoE7Kzw6aDdXufEyvPTReXBFzi5LRvJvE2iYPV8BpSae3G7A0XabWVwiyq75goIoV5vYpAO7xEMbCkj0GqYUbmC1S7vCqKHNn+3ota97yI8CAI8c+qoxKSc0Q9OXHtobRFuk2rsAcUufyvzeYceGuiWhgdTc68kpzzO53W/h0qxDNmkbrMkPZzBp72vMMArjuj5fNZLNdrqwUkP7TjfE2C1Y+w/jouzYziFOBz4Jn5shBiHoZGSDkyNjW1GqJd3JU7TaLQw2Fa19UH0+LacxTBx8ESy67MHwfBdPDhJrBRgoCtix+hXF7nLUHqouAzafVEhuSYzsTa6Ri1SF9dn3x5OE98xQnpEyg7Gxi6MMzH4AwY0O5VrAuUu/vYkiRAEwK0n+tVV2u3xTOhXV08kVdMccNdnv9VlY2xSjc3QxNuQqbvms8q0cTFPXiLEPXi1NIP0UD3Oksh7OFPVDZrW/DlyZVBgZ0vpUo3uxsYPT7Wi33KPdt4l9x/KAR5yyuWAfgW6hZsV/VroaHaz9FKlfIeyiWf+dtcmXpdqPKR8BpY9ow8pn4Euh0ZSjb6Dudp8RhcaYMUo7VaNz+hBHt2em4+0fHapf7om/v6LcDEIsC21t2UjFR4At3wGxtKrQCfVaAOrJVHgJLt2X3n05ECkGkf5vJpU4+HkM+AO2lRDPNuN8qsK09vkKyyXuKH/IhwYelnXQbuQYrsvK1yc8TaGylR6tXudnaHSfY7T/nUmL9eOodBK2eokMrPjpbTbDvLoWX8GmDwUlwzpibS0ysP2cM5oFUziyupQw9W+JIk6n9vYxjirGk2qMcKt5XzeljW2ZSPzWQz0bfOAuRbh4t9w9SGVeRCFOM9ihx5agNU0qUZT36KB1bh8va9qiwCrrW1fAozvwSXP6LFU44H00HGo2H7sINVomCkPzwzhXR2wsqGVwh4Hunu4ae093pO7Ui6WAfda43ImsNox7HFcnB3DKWxNfKkgawCB3LQsfbSi38o4U2SggK6oblt7Ifv4pphlcfashz77Jo4kw81VZuJGa+Jjw/BcpQwDLoP2XYuEemRUvja6Rj0Ilx60Xx1UE9/M0sTbaOmDdCBf9It7QjQGQRDgLI2tUo2XjN+C3ah8Hr+FTeLmiaSjXx9JjzM3tJyUdrNJNWrft5lBKoAM/kW/QP11nkjrN/ECTXXtgMaaMw6zie+kV00SbabXm9FyA7hFPM9N0m6qVONZajc2ruoGV3k1Qcstlc9Atwx38SrblrX0TwF6TyQLIEZ8/tP+jA6CoGPiGgBCulQjj34V57PvIrxv4uPIKu+6VIw9kRZcnB1QPgPD0Cy7h2yM6XW6ckMS80CrqmkQBoPfwiCPbmOoFBqD1A39ejkTWE0M9mw5LZjUIh6eJLgpams+3BQVTtOxVKPpOxR/46LAIFUePHJSSLZmisrD2jm9FoO0bVv5fofAIC11sNqu+WzxFVbPDNsSN+0BGac9wt62CBe+f9KH1FHa7fK2xCYZ2LO7xrMSrGYHnwIEWM3hjD5NI4TKMgygJalrDfDn7Cu8i8pDrILVDmHQ3n2Gxe0ODsgTSa2H75XP1sXZeJFj8i0c1dwOjLOnmpQyIFQebDV397p55NETaz6XfT+js8JtPqRDDz30rN2/x5/RqnQ14ABW20F6FYBUYjo0sNqS8qtXB+QTroLDfLz+1CiqxjhTHnzClTOaub+KupWLXsBDWY2Yc7sA4+fwLDyGWxwXZ8dwCtEsOzfxIW9Uzkk12ijGl7fjTfzAUDE/sF+6nYfCKhkq1kH7gKwBVJkJO1pOlY1JDTRw8d3GDrIe3TXtjmjfxJGTp8MSMULWrOW3cACMM7Ug30U2Jndu4rv7y2RsPHitjNFytqHcU4l+1fXZ7ejXNA7lsOA+8exZajU2Fksq8bwRzyCbJ9JNXiEMhs9lK/pHMhOWpVa+az5Xw4DxUAbt4vduW1gRlnPGSKpxbb8FTTYG8Cv6xTPJls/de6joV4PMhKdU49P++fhIO6OXYpAC7oyznDij3f1TFGk3kw+N8vy0DdrvzzjrhvlNC6+F6z5iu9Li7Co/nCZe9fy9j1G56XVFJQZ//T0WmmUG9aEc4NrED3mZJaFbEz9Tzf3sqaOcclXL8xnwAavVY5UHo5eryjhzk2oE/Pz2VJn3gdV2OPm85FBuWw7gkcNZhKtqJ/sBq7ksznSpxizu5JfdGWdC5aF/Nlly+qWZPEhP0gibJLSrPAgfIeEr7JrPhGoLQJ+74tyOHb5vQMnnHcAtag9wSDX38ouzwwG3qJ6/u4FP7dKdaj7HDv1fqkq7OXic6aotQOe9Ze2hJePs/oP2Z05Tb/Ap0NXcLj00MNQrTlKNE7AaJ4++q/SqqvJwGB5n6vN7SanGQ8rnQs6hAmcQth6DhYmFsBArFiYG8Kmez4AbK/yhZw9d1g2ebqujx9lCcVycHcMpbIh2VQYKsHmcjaUaXdGvTzXZGCHNYmtMhcfZfUMyzhyk3VRkzSNHmYnrvJIPV6CXauQeys34O7RpLUuZCe9BeyORNcABoF/7+y8Kg0X12eumxV1ZIwoDbzbIPkItyO+DlnOVjTEVobpUI9Cj5azSq2P0qyx2HGQmnj1N7+1ZCHSNg102Zlz0b5Ku+bf7LXRDOXGdthyqFJkJk9cKsDv6dSzVGKy+CAe6Z4xgQizpc3adV/J91y76Jfp1JDPh/tuKe8XcxDcIetZJEtqa+Ha0CHfxWxD5oEs1ujbxc4Fbnm4r4znVNC2Kupl6Irl6nGlnNAtu0aRXAT5fd/YgVdGvlqHCUrEth3xecjAnnh1RGKyfzwo7SQxNfQc0NjllfXhurLmraT4DDoyzO92zMEJZt8b6p6obPLmbi3HWvbdtGS4kxUW4g9UqbRHO+8RJsFrYyWFFBllHQDmjPfJR5nMcKUCb9fMZ6GvuFTwLDyGfgfHy2WWYNXm9izx63UgWmclXWPcsDILACdzy5Lbs5WNFLev2bOp66HmGcs86eCKpcmiAks/WHroeqbaYcmh4RivgU8OSer6ae918FqzWLq+aRa/nOq9lbeC7gJw7dHl0F9sPNVzAp3k1ll4Fhvtucj3VFNzicj4DmPgK2wBYc6o8OIFPtXwG3FQervXFmYfEvM1eRKo8eEuvquCWw1FtGWru5aQaRzX3QeXzblKNw1yMAavVtXwP8X/5eY4OPu3OABcfUl0e3ZbPIo+OHmfLxHFxdgynkIh2C+NMoD5NFGZdqtHZ2PhOl42xDxjrpsWTu3IWtJx4mFk9zqpmUiB0r7MM2jW0nFGqUVtUppZBu81onnwPQa9X0K9rF/3iczx7lq7inyIOprWL/qJWZWP2JdU4yEGafn9dqhHoctoFWROFgcz/wajcwiC9GRcW94lnTlO85JDPwLTod1mEj6VXefRr27YoFZkJE9sUUNGvvk384AVje2YsFXlZy7xaUn71elvJ9117MKc38YDfNdnOZ6AfyglPzNhubKx7nOVVw/49oKJfh7PW5dkkmvg5cloM2k1n9MDq8PNE0pt4wMYKaEfns/hvVOycz4INm4RWT4elYlsN+bzoGb0dzujVGaSaDBRgB4ToIdGvrK9wj7BVam5eNrQZnc+u6NepZ6F9ICE9C+fIZ1cf0qomF2emnBZgqFE+h3Z5PDEMSS3+JgPjzGdxNjybUou081KxVWvuFRZnz56lqzNIAV0efReVB7Nqi3wPB19hHXwKCHCLg2ehJgOlXhsXL93OY3cAdP5qzgyVvifovM0DJ7sDVbVFsnyIhdjgWSjO6MiYa5KhspPKwyDVuHY+i+sXZ/Siy/BtqdTc634Por8Si2QX2w81XHvoTDkvAFo2tPvbduRxdp5Fdkb47ZhBCviB1ebI6UenKZ7clUYwjbgeXx9SAVY7z8Y+4ZzcaaU8o8X/tao8eD7H1WdTx1A/APBp2Qw99JJSjXkl1X/WVmJS6+HdGWdmcMug8uDCCp/6hANmRmDTtHi6LQm7AwuYXPbQx8XZEnFcnB3DKSTjjG3ix0WorYmPwkDqkIsHyq2FoaLLxrgU/U/vSjTtPA+UTRLhNI0c0K/1ZCgH2Blnt7psTN+YU42T+G6Fhq69ifcv+u9USrqlCFkqxPU/d5YuO2Tv3+s5sThbu0ioGqR9U5k5aiCr4abPPqDUxX1GFf2kVGMa49ZBevXhSSIZWUI6zdbEX84kAwW4eSLJol9jkdoW6LfaItzUONVNi7YdGv3UUpDvin69K2sJODiEJh7ohv/PrTBov8qrIZ9XHrQXRNF/59HQCSScMZ+raT4blz6aVCNg9lAR6NcHJzpazlb0z4eWE4MAU07r/inAsAg3IY5FfXKeuXkiUVKNPPp1RzR7MT2j10bA5mWDZ04TBME6Uo3Pnqbew5C5o6yIfPaUobWd0TrrJDb451TNGM3uIo/etq08o0UMNTd/j4l8noOh4rw4K2mw2hODh8oNlc8Gnzj5fSuIdlO+invQp2a+U55Nh6LyMKq5V1iEP3eWIvdkg+wj1Hq4A4TMzzhTWScmX+FKy33ATR6dy2fbZ7m8LedjnJ2l1nzWwS1BEDj7kOqMcIBm+Yi8Uu0OzCoPu4Fb7opBHj2Nw9WlV0Xv+twKg/brUc29NlhtGIJL24/C/bd1yueR3QEPPtWBk0BXc98W5ucexTjLHHyFL28LnCTRaE61azx7mqBtzfMtCqzWeZzZe2hgYOsEQdApMTksK2yM7V0ZZ3dljTQKEYZBB3Ctm9XPpryqhx56YfDpRRY79Xn7jhH4NPbvoQG7D+mwnBty2lQvUvLoJqWsq22Ftp0ySLel+R4TQJQ5CCLHsMdxcXYMp7Brv44L+cQi1agi5U4TQWF1GLSfUkU/f/C9NCMlHXDUc66aEbLmgQP6tagaFHUzko1JDY3TIO3l5okkiwSPol9FCQl2oO9gb+4Q1/T8ebYoUk681/PnWXcdB8A4E/fHJvZH+9jyGdCNyvmiX1+aA12h62uC6uNZOGcT77IIB6ZFv52hUktTY8A8PNflLq2ehULarfZEPStLfRurbYkQrFaRV0vntHjftQft4ndIomAnmQmRMyamjepb5uK3N16E2+WUdc9CoFs2WxlnNwWyOMTJHE28kFM25LTInRG45SRF3bTGZ5b47KeqtFvM52k18qvh2abA/WSggB79ekCMs00SOcl7zhk3PcN3k/r7D80dxaiJ95deBYZhE3e26+duahgoFVU7Op+lPLqhib8talRNqzFU7M+mOWWgTtIIJ0nkxFAZyaOf2uXRZT6n40W4TapRZZE6ndE71NyqPPraZ/So5l5QHv1aqbmbdn1/5U66XKg82M+1yest4FNgDFgRv7/JV3iU02ls/X2eaHYHrs+mzuNsJpWHs1Qu17kYwGrjZbjVE4kBq1G9sf4d2vzHdvchHWShTc+XpULcf7LmXjCnb/J66KEPhHE2Unnw6OvdwKeU3cH0cwvgpD5or5rWeL9xKg9WBulNOd9MzKXmlnWqks+ndrDaNXNGG72Z9e+bWVQPjDPPukzxR7YpSSwV27JZrYc+38S9dPFhAHzuI9WY1+acJs8Mk8eZcr+7yKM/YRbhgA2sNp9n4THscVycHcMpRJHAbfCHQYHYxJulGtUCIQwDnKVmtNy2rJFXjYaW6x+OhiLhsTRBnXHQ7uRxNny+iyxGGLg18TrjDDA3ToI5YBrgAcPv5lP0i4JiE3fomtji6bBEDEV/ituiXsxrTKDynj8/DJmJsVH57uhXEyKnqBop6WZc+mi5D/T67A5NvMpOCYIAWRw6eRbOhax55rRDUbuYgo8Q7U4yE7r0qmn5OP4OhUxPw9zfd4V5qMqFisw/BMbZMJRbQaoxrw4qn4Ee/bqDzIQ4a+umZX9TdfAn7kWjtBspM8H/PgINrp/RtmHESzcdg3QWz0IHhgrntwCYJR6vNdkYoJN2M9U5g9+CmQ02DOU8ZWOqGmHQPTdsg4KlQiwxLrJ4canG8yzuEZqHswiPoxDxDh4QVsZZNTwzgK4WdGE/Am7y6KR/igNDZU4ZKECAW+yDdl+PM+lZmI3BLewivD+LY+WM5pZa3XO4+3ufnFbZsIP06vr5DHRn9Bry6PKMPgBEu6y54x2kGi1yym3bjlDqUmaQ+P0LuTT3k0efeBY65LP0LJzN4yxx8jhL+75TRMdQcfMVFmH6DivtO7T6hO8IbsmrepBHPwBPJL3mXiqnmx6YNNTc6+dz2Hv+7iSP7tRDK+Apo2qLOFv8wGpPbgsEAXCxGe55l2fT49titiG7WMCZam5xBmbaGV1UjbHPuckrnCSR9O8C0M+hOGa98n1LlST6uxjAp/5gNdWzEFifFb4ta1xsYqRxuHgPfd4zztbP54FMkO2Qz23bDnMxRh2C8hXmnucqcBJw7KHvppKLUuXBRBC5OXqcLRnHxdkxnMJmmlhqTXxiMDbWF2cAcGop+slNfOzexM82aD+zM87ysh4VCGEY4IFFZkL6p6RE0W/QZx818Q5ouV3Rr+I9DgFZAwxouaUQ7Sr6tbuOtaWgWmVx5l+0uKDlxk28GLRTTbyQPBkXCS4eZ7qvke2z1E2Ly7tyFv8UAHi2bx7Mg/apVKML40xfnJlYPrJx0gftzGJj56Jf9Vs4AH32ST4vPGg/mHwmZCZ8WHDqc92ElpsYlbNeAWOpRpdBO3dG25a7j2+L2bTZxTDANGgn89lBTvkmrxAGGDHj7FKNfh5n/oyzBidJJCVsgANgnPWI3LOFGWfXvb/NJolWZ5Dq/mP3OqMtsjGJIhvDsqU0qcYsDhGFgWUoRzFI7QyVucFqj04TJ6lGlZ3yoB8kuoDVxtKrDlKNDv4W6m/tA1ZTPc7E77r2UE5c//PnGa7zajFZquu8lO8LrH9GFwpj+yTdQR69dmOQprKn439/XqrRfE1P70o8VNgpLvksFuhzepw9uSuNfqnbsh7ls/o6U3SDXPV8dpBqDNV8tnsW7nJGS7CaBeC6ROg191KDdgGkPBTGmVqfnewCVrMwwuV7xHrNTdyLDQ0+Bcxyyk/uSjzYJKMFc+bgK/zSzXyeheLfMTPOBhC2CMGSM+X0tbYIB8xMb9XLVdbDLONs13yuR+BT8b5rxkjlYUm7g20349g0PuPvAAAgAElEQVQFvD13jH3Che2HP/gU4JVbCk3lIQ55S6JCB5+mdmU1uod2IIjczgtWO4Y5jouzYziFzQhVysY4+Od0Q/8xutwm6/OEkIEa6LiGop9o/u8Tz5wmDjITzahAAIBHlkH7TTFlnKWGQZj0xHFo4tt2oPvv2sR372H2dFgixP333NKLM+G3cIBNfMfq8EVBiqGcuehX7y+ALjJVrXgRLjJdTzT0KyDYc/w1Pb0r0bZzDuWEJ5JZn12wOuTrnKQaq4kfEmAZhDhK6YnBsD/jrFZkY/7/m895VaOoGzw6TRDtwAaZO1TZNRcmtR75aHHGF/IDsIW/F3XkO+DexJ+l0eh1Lg3V49tSLrDvGy6Ms8FvYco4M0lBXff+KSozzijV2Ax1jqvHmb8M1Fh61fQeS4W4pvPNsouzq7zC+SaxniFLhC6juMs12YzKKdkYtonXpBqDQKg82Jv4B4RsjLmJ79GvMzLOXDyRVLBaHIW4yOKdVB44pnel/aadnLJZBkpcm2uoMrI2lupSsS1rBEFXc5W1WTpsztBr7tV9hZXzc7d8NvuQTu0OTAwVanHmX3MLNqyJFXl5O79qi7gWLvJqzCAFPMBqKVFzG/qWgaFi8TirdmSFjxgqh6Py8NzC0m7SJ/yAemg1nwFfxtkAXuSUb0rFUmEAQxL5rHiiinAFq0166NjuN3V5O+Pi7MzHV3jKCred0eoiHLCwwhWWj93jbNd8HkuvAocBVtskoRPreM64znuPMwdJ/n2HyKEk6tj6QbAbgxQwnNE6QSTmfYV1qUYXxhk957Yzzh7fzOdZeAx7HBdnx3AKmxGqoEOrMhMm/xSdcWYzNqZloBwYZ6t4nNFFv8kIdWjiHT2RNJaPya9IPRC8GGeyiXfzdFgiBrRc93suVSQMHmeHI+2mepyZJNqosDFIu/eYevRQjDMd+Q50zMlt2RhRpZe3Y48zoEfmGwrZufPZyROpb3zVgfnDkwS3RW3Mp5ueASHChCCWaPZw/H1z//6uxsYq+tXm6bBEDGj2ZY2NbxTZvc0B6LOPPc52R792r7MzzsIwQMRI74ocHxuVC7Sc+YzWmWMuTJvHM6JfN0mE09TsiaT6gokQjYrtjNbRryamd1E18ny253N3TVXTeskPd/k8buIPIafX8jgTRuXrL8LHg+2OeekpG2PxW5hINUYBK9OpIt9F2MFqvWyM6p/ioPLw+LbAJglxks7TxLvU3LmCAhfx8DSRrDkqxGcnwS0MQyXopb3E37KehTvW3LnybBJo5bXzWUqvbuyDnzlDILMPRtpNAXxmO0g1OjNIJZrdVC9OfYXPLfLoZd3gOq8YlQf+HpMyUDMP2m1yypN8tqi2NE2L22LMUDExvXV5dFEPc4zKXRgqVd2galrN42xtlYd1pBonPfQBnNGJwggH/J4x6n3ALV86efRxDeiyxAWUQbshpy9J1RY3xtlsPbRknJlUHsYgbECpuQ3PAa7m5maLhSJJbauHxVnrzTirKLDa+jmdxSv5Cm+6mtt3ATl3qIoAQRB4yym79NCFNuvqlNV4YJuaz0kUIo3DnewOAPPz8qXb+fL5GPY4Ls6O4RQ2xpmgQ6dKkcD6pzTtiJ0CdIP2G0ZXFqAprE5N/E2BNA5xOlMT/+xZiqu8smqh60X/AxvjjPJPMSAOdb+F1CC7Nka/7uK3cDhoOXH9UmZioaJfyFk8f5GNrmOtGHuc7aLPbka/1v0AN1UYpADIIoFGv3bXdMv8+03T4umWRsvZ8hmYj5IuGSqmQTu1CHeRditqUnqVenbo0qtp/2ybHy2nFP0HsQjvrv/BSYIkChZnkJ5lh1H0Cw+iINjVb2H4WxMrXEXAxYycspQwGvktdPfxraGJ1z0LATc27NxF/zOnZh9SKdXoiX69LWqc6ujX0OyJlCjnM8AvuncdtG+rmjAqX/mM7j1el5aNud72Uo0O8qD7Dt3z18XrTw0V7MR5qAyeDgpYzeBZmIRjlYfTLLbmMzCcdcDQxJv9FubzIAWEx9luYDUXlQe1NxjALbScsgC2AJ2EDpdrqkfGbioP3fAnNSCal4puER7KM2A5efQSURhIMMZSTDcuVAR5Jwe7G4OU80+RKiJazU1Ku1Xj5wsAnKZmtsFToocG7M8m6Vk4lyeS06C9HgFbgO66r7YVCywRvYYKVjMtH8V8QgWfti3Yf38XVrg41w8SrHaxrMrDlWSQ9vm8Nvi0aqeMMx+Qg4PKg/rMEPeZ2bN+ClazMVSm+Wzuocu6wdNtNVsPfZJG2CShk90BpfJgO6PVHhqwSFLXjZRetdXDdzvkM6BJNcb8MnTJUMFqS83EACGPHjsta/cdombLVCUmj2tS7wNWTpkAq3HS3h37caqsZlqE32fOPdf5fAx7HBdnx3AKV7RcGg9oD+4wKatBh1iEjWIsKawq+tVBx1Y08Spb5D7hQksXh5gaj05TowwUJRsTe0k18pJR6uHh53HWF/2xOmhfG1nTySs8OFm4iRdF/9mhMM5apYm3S5bqMaDZ+YIfGGs5q6/TrwXAaKhko6VfbSu0LchBuy2fgT0wzmzoVw2tPxT99OvKukFRNaTHGcXaq5rx921lqAiZEI98FpKt2WgRvvZQbljOLzlov+r9Uy42wth47XymZGN2ZZyZEHDDOZgyv78R/WphqDw8GTe5gg3LofKqusGTu3JWbfZnLT6k6nBahMhnmw/puY5+jU2Nk+Jx5igbA/gzVCayMQzraKnYrsQ4636fxHtJtY/QpZd8nzEjvwUfqUZjE6+rPMRGvwWTyoMJaNA18fMuwp9uKzZ3OrZ9Sw7azQxSE1iNAreMn5+uHmf38RU+hEG7Kr0KLAdWu952z9tdZNT2Eap88SYJjRJtVNilV3XwqXu9CADnWYSybtn77ZJZnNnYc4/nVm2RPqR+PbRNTpmTXgWY5aOsc/qZhdWH9P4+4YcEVhO97GL53P8+F5sEWXwAZ3TdyMVH5jCc1sONoTJVbTGxH2lpNwOg/JYCq5nzWZzrc8mjA90y3JbP4tpEyJrbckafaWC1rs7h+gn1+xYzi/l9hYfz2QxwXSKapnvmb5JweXn0bafykB2gyoOvr/Aonw1zblfVgaJuRuBTwO5D+uSuRBaHozxxUaB56XbeHvoY5jguzo5hjaZp/QftUUBqOYu/1Zv4U8viTCyqHlJ+C8aif0plv0880/9bJp8zldUh4uFJbFy2icNORdeYhm2SoeIiG3PvJn4oRA7BEymLQ5xn3e+w1KD9Oi871G1fzK7NUFElIFzyQA+BqLHLxoyNdo1+C6pUo2XQPmg5jw97WxNPDfPuE4NchG8+m9FydBPPo9PEsFtnqNiW4V5Ddg39ehj53L1/Fi9b9A9D076JX3soVymyMTs08blD0a8+M4D+jDYwSFWpxsFvwVz0q8AWQCn6mfvsab9An/OMfmTxIVWXtSJOkghpFFr9FnT0q9HLtW4l4MDucaagHWsfVrgivRrzQJslQ57Rm6WNyktcbPomfu181oBNvk28injlJB71MzpmpFfF9UylGs3y6E/uSsRhIE3NAbcm/vFtMW/NfWY+ayk0O9A9B3bxOAM4gNB4ENKBAxkP0uq+Nfch+ZA2yOLOMw5YkKHSAxWGofbKLNKqGeUz4NcHWMGn1biOjg3gqV3ALRSDFOjBapZ8BjA523eNZ07t4FNKteWRReWBkl51k2rUB+3mPno31ZZhebJ6Pvfvf5p2staLSa9uh98ni8333BKR31O1ZQxu4c9oF19hMp9TN08k3e4gs6g8yFnajIP2R6epk8dZptQg4jlkA5TvKtUo52ezy6PX8kwS77UmG1q8t5BqXCqfy7pBXjUHk8+q3QEgbD92BZ+aF+GCiJEYfIXV3Bdxllrk0W8pBqkdOHR5W0xmacfYXxwXZ8ewhmuBAChFaMijQspmin49zyLjUO7pXYkggNTZB9wYZ9d5OXrNfWMYINKHfdu2JEPl0UmKJ3claToOmD3OSKnG/rsVyAcTMlVt1PxkY6ZSjWsP5fKqRqagX5f0W+jQ7P4F9j6iIIp+rybe1T9Fl2okioRKy30A0tCXy+nLu+kiHOiLfkMBJiQzH2zmGcxtkghJFBhRl9uyGcm6AcPCj1u4DU388LooDBAEFtmYyaB9RtkYzdsp7SUvOE+HJUJ9xpxnyaIyUABwLgftKxf9ClJyWDbNr88+kmpkin5KenWThAgD8/P2coeiXwxTLmbK5+7fMjcnlFF5EAS9nLIZ3EJ7nJkAQrrfgoOcsse9qC71E8ugYIno6p/umi6yGNdFtcjzpW1b3BT1yLNwzefaFP3qt5x3qbnzavweNl/hVFN5OLNIu132MlCqWoNLE98Zxs+Xz7LmZs5oKp8BuyfSTV4hCMZSjSbPkrIZS+8kcYjcZRHuM2gnwC2HwFDZrFBz3+RVzwg/DMbZSB499meFi3zlnu/FZJHD+wrrQ0JgWJxxZ98TBnRmW+pfbyvEYTBZZO0a4j6yndEcWI1jqNwQ4FOzT/gYfJraVB528BXWvZ0OJZ8BLO6JpC42fYEk+4iymqo8+NReKqDFReUhDAOEgQV8qnkWAnyetG0rz2g1NnGEomrYWZPooWedi23MEoFbAqx2nsYIgx1UHgzqSlXTSsBBYgGS7exDWg1gtcQCcF0i1OX8suDTPp83h5HP+vnpC4gd2x24LcM4uwOAlmo8sxFE7qagM5eZ4/W2mjWfj2GO4+LsGNZwkY3RzYqTKETD6IWXVTN9oDg08Q82CUJFAzqNQgSBvYnXD977xIVFrkSiP4iiv2mBa0bfVvi7uUs1tv3nV6UxzZR07t/iYis/i5AC4guWpUIg7M/75uhqwaL/PIt2apj3Eeog7D5NPDdg1BFwA/qVaOIpqUYLWm5gnPk38QAm8g33ia55NDNUMlaqkWvip/kcBEHniUQ9E8V36OBvAezGOKOaeIAezCwVqmzeeRYtJ9W4HRabnTzo+kO5VCn4gX1JNQ73MSfVOPjtDX8bBEEv7WZBv55OZaC6a6K/XyGZOecZbZP8VFmOalgZKkU1WoQDvZer0ePMTXp1xFDxOqOJxdmKZ3RZt2haSHZ223becPuObdnJpp31sjHAuijggUE8sEj3kc/qe6QGX+FKYT+KsA1Nn9yVE3aKi6TV9baSw/E5wjZAlHXq5Izu5NG5Bep13nmQqovBWDLraYDQ+PkZWNHswI6Ms/hwwGrbXt7ZtpiZOwb/FH8gydxRN91z7V4MFYuvcKEtwo2yoU2DOAxG967IE85DZbA70HPaLJt3nXf5PJfdgegNrGA14nwG7Iwzqoc2Mev175v627Ztd5JHV5dU4j3WZpzlI7BavGgPDRzQ4oxinPn4kKpzMQOLVD0zEsaHdPAVdldtuSlq1E07rbktgHIJVptzLmapJaiaOwwDuw8pAVaLmeVz0zPHXPK5u6bdz2hVSrl7jxV7aM3uYCnp1avt8Ly1edMvEbrc6b2kGg0EER08xdVnukIBYF+cUZ6Fch5guEev8mrWfD6GOY6Ls2NYI3dAT1KmiQBfsFJ+C3dlzVKmqaFcEARWVMFNXuN8RjS7kAjkdGpzZignBhBPGHTNTd6h+tTXmaUaxz5xSWzyOFPR7D5yQVPG2fqLs65oEYuTxaQat6VE1ojrWDPUgnyXaxoZoZJSMEwTb2KoeEg1cpKLmyQyDjxvigonSTQpSO4T55vYqDudK3JoIh5ZPJHE8GIq7UYP2+R3KKVXzWg5kZu7MUgPBy0nZfMWRr+qUo2HUvSryNQ0Dv2e1SO0HHdGjxFwnFTjgNybgltumaHctqyRV83EbyGTbAH6HhO/w7ys8MTYnFBSjYCdoXKb1zglZWOYxknxcg2CwNmH1I9xpqBfLVJTS8SoiXdgFswVVwqDVDKwVwS36J6/G08PiFE+G+SUozCQqgOxyVeYkGo8zSLjUtMoG2NUeZgXrGa7j/Q6VcTDkwRF3eCOeR7e5NWIbQbYPZFGNbfR48xcX3EhPHwFQPAwfIVrbBSpxsU9zg5AqlGvce9Tc9tUW2QPbfEVntgd9PcyX3PTKg+bJDI+K+fO56iXfzWd0dteWUSNwYeUZoXfSrCaI4OUAPt2/52uicT+3Sefh1pDyCkfQj4rYLXNctJu1+qg3aIsskSUCiNkp3xWrt8o7aacuxzAWfc3BLp7JYkCCarWg83n2KxAozKF5grbfZT38t368t3kQ9o0LW7LeiQVDRi8mSc+4f3z0wHc4iu/qtfc6zLOVPBpjLxqFrke6VnY5/OaQDVAkTpWWKReDNIdwKeJgXGmSjuLOM8iNp8BodpC2x1w84CialD0kpnHWCaOi7NjWMNFNqbQGguTzAS1OBNJzw3mKBkowG66frXdVxPP+C0YhnKA2RPpLBuj+kyD7apppcQEYEayjZA1XjITU/Qrx2pbKkTREkchTpKIRVfOHTd5LZFy3XUcQNEf64uz3RDtVHGhD89NsqF6wQIoizNP9OvGsgi/mhnNDnSDdpvMhJ7PD3bwOAO6nDbKxkj2gKXor3ZYnGnPpkHa7RAYZxHON+aFx5xxPRq0H0ITPz4TbXmghztazi4zoQ/wRJiMjU0MUtM1Xe+DcbbpJAI5qRp5z03klM3oV1o2xiCP10zRxvs4owfp1QNAvwqEfY9+BZZZnMkFbKZIu63IUNGBJ5lnE++Wz8QinLnnVe8PEU4MUmYox11T27adVOOMZ/SFxc9WHRypYWOodAzSaT4DNLO+rJsRq968ONsdzZ4l6nvwrLalIl9JqlEwnQ5BqnHqWbg7K5xbOk8XObyvcEGotkjGGXtGd78bKdVoYpzN3EMDsEqK5WUjnzUixECR80SSYDXCs9Aojy6l3fi/Ham23Evl4RBUW8YMlcXAp0WFLA6RxqE3kGQfMbI72EXlQfkdWfnVqh5LuzGscEqqETAzVKRnIecrzFzTlcL8mytsoEdKehXofNa48/murNG2RA/N5NBUetVcD+f3ALdsNI+zVcFqypzu3AJYnjN0qcaqaVn1jSViOD93A6uNam7mdfnEJ9xgSURJNVqU1Z5SjDMLWG0fi/BjmOO4ODuGNZy0nDXGmclvg0TLZQItxw/myMVZHBnRItd5OZFXuk+cW2Qmcq1QFvHIMmjvZGNo9CvZOGl+NamBMnwfNHsYKMsTw3ssFXk1FC02Xe05ozMqTxCFHXNgTWm3tm01jzP/wYIN0S4KU8GAFMUoiX5txgUrMKA+OY8zkQc6Q8XGOJsb/QoIf0V+YK4Op0VEYYCLTeywOBu/Lg5pT6QBLTcgzQG6ia+bVhaJfki58YBRvMdBFP09Wm4x2Zht72+TRP09t3ITX43PRBsgRI8RWo7JH/3M4Aa/YpGqszpNzbGJQapfnxqq3MdccZ5FnUQg8zzcljXiMJh8PhPjrOqNsCkGKZc/usZ9yizNxTWJ8GEaqv6LpmfGUpErS0mxPFliMHe9HYZBEnF9CAwVhRW+KyOclUfXEK2psYkfL32ArpYtDOjky7tiks9hGCCNeHTxXVmjIYZd94mhluCkGodlrRoPbaxw0rOQV8qotL7FxB4Z+wr71WVq72B6ZiwVwtPlJIkQBstKNV4ciPSq7G9jsQjfQdqt/ze6+o0fnrv4CnOqLYCBcXZX4DyLJ+eeDTi0j5r7zFLrdXlAy6PbfYWHazX5Cussn9SwNFfP5Pv6hFdNy4J6loi8avo+NlzW40zx4dnEZpbjElEq9XAchYjDYHbGWVm3RM1Nz3O663AftPOeheZ5gForzRU2iUDVF0yNhycJnjAMUg58GjMAtEoDHtjq4fEZ7XYvCsnWQ/IVFteugluWmIupC1gXJYJ9R6Gdn75KMk6qLXU7UgUzeVxXDX1Gm563l4Symo1xRkkUH2O/cVycHcMa4oFk8hMr6wZBgJFsDABWz5lDy7HGxtzizFD0V3WDbdlIecU5wrWJnxT9p/5NvGlZUdXNyLMiNaBfxYEQBGDNzKkQKCHBgjO9x1KhIpeWNTYeFrCZp1/J3CFYnJnOOPNE1whyI5XTZaWjXw2Msz6fSb8FQz5vknCyYLZJr15vyz0szuz67GzRb1iEi39bjZTxRNJZeyakrPh+guB+/impYUi4VIz12ZfzOBP+NmEo5H4Pp4kHdpF2G/KZK7B1Y2N2caYtcUW4oF8f6ejX/jPZiv65pRoBM0OFRr8mPJqdkIEC+kEY44nSscLdmqxtOfx+PovsfCQbs34+qzKYYsm4pFRj53G2PuNM/M67NvHiuW6rudVnRhzyvsJV3Y6klAH7oP3JbYlHp+nkv2cJf0bvZSgnhkFcza2dayJsYLWbvCbzGeCXFbpUow2s5n9Gj2uNg/A4K2tkcSR9LpeUajzLYsXzc00G6dSz0PeabDW3rvJg8hXWl7jAPXpoy7NJMP/mjAsHH1L9jE7jEKdp5K/ywEm7acsKIatrYpztks/AFKxGzUWWim05eDYv20MPM44sMfvqLRF6PewLVitqJZ8NcsojT6TQzJaaSrvxv49V5YG5pn0M2m0SgeIM0cOk8kAtwoEeIETUOPrzMwoDhMzSXFyTrLkdc1pItop8zuRy7gBUHuLQ6nM5Z4zAagdgYTLYXQyA8l3Ap0HAg+6mnoU0g7Rt217am1JtqUjf3bJucFvUrPQq6xO+B8/CY5jjuDg7hjXEQ+TBJmEP46Iv5IcliyhC3aQaxZDFNJjjpRo5Led+eD1j0S8lAj2beKtUYzFdnJkQM6U2CEkifmgirunBJvEr+ifo12B1Y2PVNLqTmeCZQnOGani/WbnoH0zEe0r6Dh4QedXgQe/9R71uKELtQ1m9mACAkyRCEJiHcqZ8pgoLYJDMnDM6iUD+92RlJgxFv7dUY0MvKqmhySif64b9rrjXZRpabs2cFvdeGoU4zxLclfUicg/dIlzk8/oeZzp7ZGMYTlMxzmeTtJte9PPSq1OpRnsTzzHOuOflDdMc3ydsnkhbAs0OdNd+lVfk/Xdd0NfJD+XGixPADDzZVrX8/XY9o4XU1CHkcxaHi6JfpeH9Jt5pqD13FBoQoqsZfM7n4RnPS7tpTbxh8FsQNbdp0F43La7yasIIB8wDxn0swi+kr7BN5WH8+Wxyypz0KsBINTYa48zoWTg+o11DZ7eb5F2XCnWZd7HQoL1pWtwUXa3XeeP4MXHnDiqfAT9Wa1Gba24dPCXOX5Zx5rkIp2SggK4eXJpxZvNEUn2E1HABq53qCzfm3K0mPY4BrKY8j339kABM5JRXPaOVmsEmmTlnqJKfa4NPASF3qtXcXuDT2pjPTdOBp8ZnNA204qUaeTsKvuY2y07e5BU2STh5r/uETcZ3F/DpAFZzlGpspt+hDdwifj/XnJ5KrwrVlvXOJlIefYmaW5EIPARwS1E1iMNA+sP69vXimfxgk5jtDrS5K6eqBgxzcBFnWYympXOTy+ck6hbAbD4Xw+9wjGXiuDg7hjXEwfPgJDaaJo60nEPBUGGWPpzMBFEktG3b+S2cEkV/zA8kpGH8jFKNgHmAKAdHut9Cj8S/vONp6VwTz7J8NDS7+O/cNT04iXfQcrYzFJaMUdGfxcaFx5zRLWy6+y/zRI/PHVMZKP+ipagaPDiJ2dfpg4LYcH/pzQGADp2c8r/P5V0xYacA3WdpWh7BdUUwM+8b51lk9jhTEJpqPDpNWKNy6bcwkXabAf1aDfncGr6r6ecYDxgPwdg4L2ukcYgwDIbmy2CeO1eoKOpDWJzpBbk3+rU3Bw4MBbY+KIg5xplA12v3/Fka4dZiVK6f0ZmliZeSmel8Z/S5jRVuQL8CwFPiWXDb/1unxBlNMsKFf8rIh9Q0aB+ex65ntJBsnQzlDkJ6NbIuPOaMm4JCv673Peg+gZskYiXaqCiUZ7zJFHxsVC4G7fT5oi/ChTw6ldNX2xJtO/UgBbqa2yobk853Rm+SsJMIZBmkAnGtMc6Exxmn8lBUOE11sJpJqlFjDxiWWnmPZj/PYk95dA2sdmg1t2XhMVeIfL7YdL7Ppj5vidDZDL4I+6puUDetuebWpKZiQ/9HLcLFGcrVT5e3fA9tWkruw+PsLOV76KpuUDUteUY/PElwyQzab/MKp2kkB6ciuHNX1jmhDlbjVR68e2jOV3hVhsrQ1wuPM1fw3X1CXcBuEvM9t0SoPuGAf1+fW3rokljkxCHtQ1pqzxcRZ4YZxyXDOMtsDJU9Sa8CPEiK8gkHumt/cleS0qVDDz1lhVPLCt0nHOjOT5OvsPj9XBfZubKkAhRfxIPwCQ+t7Pw5QwU9HkrNPbU78JdSfnASGwgieg9N5zO1xAVgZAQKNTI9n7v6h/8s13uwOziGOY6Ls2NYQxwqD08sm3jNqLz770wTr6HlTMbG13mFumkNaDlzEz+nVCPQNXNsgaBpmovYJCHSKPSUjTFJNbaabAz/t+KaHp4kKDzRcurn4Ib+S0ZeNnIYa9PJn+09qxpF3ciBbFf0H0IT38sF7ECTL6pG5hNZ9Msmfmy0y0kkUOg1QUunwsQgBUwyE+WsaHZAyGHwzMVOn92fcRYGUxR8HNKeSFwTb5JqFN+f66A8Z5r4tQftQxNvXnjMGVdbXTZm3eHkpOj3lXarOyau6XXFBC0XmJe4IdXEm9GvE89ClyY+jUcyr/cNm1RjXjUTYAswyClTOT3UEtMz2tUnzgQ8yctBosO1iVf9AcW/r773GqEicm2y1nOG2jzuAiSZOwb2iBi0+11T7lRzt3TNzSBgJ/4pBsYZh34FzDKyUr5nxjM6CAKjZNXg8aHJoztJNery6CaVh7E8OsceBzpwSxaHyJLQUx5dl2qkn9FLhtoH2Dw65gpdTmxtcAu1CAfc5WBFjSXuSYrhoAPijL7C9dSzMIs7n6Zdau7FfYVNPTSTz4Cl5iZUWwATQGgMVjPVw+Jc63pov3wGDguspudz1bSL+AeOF2frg9U64IkKVvPr68c9tIl1otWAxHetAxlyVI0AACAASURBVFVFGD3O7kokUYATYtYE8ACsfSzCLwy1BDBlUot4eJKgaQdFBzWMHmcGn7gRuMXiK+zbQ8t8lj6U/DN6qVD7+iUZZ9KfOo2ty9olQq+Hffv68ZzbUeUhZBikmtWJCJOyGtdDA/2ziSWIHKUal47j4uwY1lBlY1jtV+2BkhoKRL0BBQb0K/VAkZt4kqESscgliYjYw6DdV6oxCAI8PE1Y9Ot1XpHsFID/DnWjcoAemkjG2SbxZpxl2uLsEPwWRNF/sTEvPOYK3bdj7aJfL8hthTIVuSozQQ7adMaZYShXTT0LgX7IwshMXN6WclCthm0JuI+i/zzrCiXOq6gbtFNFf2odyukLgZSR6pCyMfG4iTctzqTMhOO9qC/1B3T9ukblA4PUvPCYM27yShaamzhCUTWrGrYXGgvbt+gXzD1ObqbTXJ96nPnIxtj8FsJgWrzbkIiqBO5cMUjQ0bmZM028ZIUTLFIpG0Oc0S0hkSzQxumEocJ5nNU7yMaM89nm6bBEqMs8m2TmnCGbx83h+C2onr++iFyJft3wTbwOWJFnhibt1jQtaoIVbvIh5dCv3WfhvSNUw/g542KTeIPVzrMYURhYVB5ojzNOfjWZKDC0JFtD1KlZHPkxzioKrLZePrdtO2GoLCm9eq6c0WvnM0CpPLgyFYZ85l43DNuE6gDPOKM8C4UHHdebXjKqLZuk6+somf+6aXFb1PvxOLP10BxDhe2haRn3lAF86vLoqSH31Zo7r/zl0QewmvCtW/OMHvqZiwXP6LHKw2GA1aYeZ34MFcGqp33CiUUO48+l34sijPl8W+LhSTrpMW1LjH14Flrl0UsGrHbCs8I5L7aU8ZUSz0ldjp4Dkm0VeXvXM1pnkJrmnEuF+oyxecvPGd3MsmP47jKDmjuKWvMJ9+zrxzU3D1bTe2jKIoda4gIwggmf9HUqpfJgejbtA6x2DHMcF2fHsIa6iecK7JyQgQI4mUE/Y2PjJj42NPF7MCoX/x7vnzIfWm5AkBNNVtNO0OwAg5araolM8inYc80LxuTpsFSoyKWlpBoHr7zu/jMhrpcIWZArbLAgAO4cJe6qukHTwolxpqNfOZkJinFmWjBzfgtiQMMVsjf5/E38oM8+/R44NDsw5DPVRHMoXVaqsf9eYyfZmDF6eXe03GEU/aoMFLBgE68swoF1i36qifeRspGMM0bisW5atK0uG+PuzwV0DWxe0QvmJ3clHpwkE5kkG9PmptjHIlzcR/R7cn4LJk8kronncoiSjUlig9+Cgl52ZpwRz6a1B+3qYCGLI6RRuEg+3+QV4jDoc6C/51Zt4seev76+ayP0K1NrlNqgQDTpes1NSUYBbuhX+ow2+QrP73EGOILVEgKsxtTcddPirpwyzoxSjU2DRHm+mXycRZ2aGnKe/izNSKLO9MxYIsSZqA7alxrKARgP2g9AelUsTr3zWWOcGaUatZqbGhJzKg9db0oDZ8QZrcdQ/0xfd8N4e943hOQnt3QGpuBTwK7yoKu2ACapxvFw0+QRqas8uILNpLRbf9+YfMuXCrWvX5KhotpRrL0IBxhpNy+Ps66OTGMarFZozwygl3ZzuBdFnGcRWz91PfQ0L23AIQqkfd8wze/EtXCqLQBdc8u5C+UrbAD7juXR6Xq4adoRY9C9h+akV9ddhANdX79kD32j2R0A6/qQlhPPQr++3sXjTGepDspq4/fgPQv5WZNd5YGbie3njD4GH8fF2TGsoW7iu/+fGrS3Ix8g+UCZwdj4CaPlDAiZCZtU4/x6zhzqMjeh5U4SieTV44bwbpKDEAqhVOtNPC/TpDbxfoyzqVE5VbAsGXk1DD3PN/EylHTplSeMjdeVatQP5SAIvBoRPZ/pJn48PA+CAEkU0AyVpp0U/IBZZuLyrqT9UwxN/CCZOb/HGTD8zmqYmvhHpwnKuiU9Yqh8BgxSjRo6UXzvlCSFeMZ4o+V0xplhMb9UqEsMW/M1Z6hMJ3Fu+Zi+zx261LE3+rVsesYZ/TpqGWYbKFFSjQBd9F/e0vlsa15Uycy5QjaPW/qs5Zr4RwapRq454aRaqO8wM5yfY8bZbvkMwHtQP3fksokfluGLGJX3+Sz8ALprWTef1UV4lvg9Y9zQr7Sv8LSJHzNZRJgWzJx/CmCWduMWzPeNM8MA0QRW42pubiFglGqsxnKXpiG4ONeyyM/LJy/HYLVs5UW4XJypnkgLLs4uZM3N93lLhGAKT6Qa52ScMR5nFJCCkmoEeHn0bdmgqBpatSXm2XM682+uMEkEDstaIp9PU5ZByi0ETFKNURhIcIOJPbJ1mIFQISRbxXscgsdZXjajfAaWk0dXB+1rAtWAnj2iMlQ8l/N51as8MPMAkbcjhkpI34vib2Ni0H5T1OSC+fKuwKNT2icc4PvC6221F2CL+LepKKqG8QkXKg98za0vw2OLT7iuxETVwy4zTSp46dU1VVsG3zXx/FuCFa565flKF+8jdCCZvzx6jSgMcJrx/uIsWE2b0VLsR8A85x5UHqY5ncWh0e4AmNdX+BjmOC7OjmEN1TQR4GQmGKlGx6L/NOGNjc2beL7Y2ReFtZMINDfxHC2dGsoVVYOyblnZGFbjXkOzc38rpBmymDdKJT+L7rcQr+txpptGn2cxirrZe0NNSjWu2cQTBSIn0Ua+XstnqsAuiaI/Zop+PfdFcMbGRdXgtqiNjLMlm3gpEcgMHAB6EW5EyxVTNDtgkGrUWAHmJn4wKgd2YJxpxsarepxV9SifgWXQrxTjbFVEu46WMzCpqegYZ1FfYNMIdUCXMaFlY3ipRnFG0+AW0oM0Njcv1/n8TbzNW4szKjfl821BLwTEdzRh+WhDUKBDtFP53MmhDUblvoszlaGSHgjjbPAh5Rcec8aVMjTNDoBxRi3CAfdnjHpGb0taGqysWrIG1Gu0islnkSe3TD5378/V3EwTv68zepOwfrYmcMsDpubm/FPEd0gqZTSMNCbDUNkkEbLEl3FGSDWu6FmoAwHPsuUW4eL9uvc/DMaZYCTazjU9inpcs7moPJh8hSmpRkAM2v09C7lr0pl/c4VYiFIDXpNUo/Cfoa71lmGvcyoPleaJY1Z50GpujzNaz2dgZYaKUv8stTgrqgZ51eBcnNFxiLppV/0edNamt69w1dXcPFiNrgFJ6dVm6ocGdPlcMwvm3X3C9+NZKP5tKnZinPXPsVNtIZBGAcpmWhNRcpdcPXyffAYOT3oV6HrGKAxwmvLe8nOGapuRGeY2S4WuZObtQ1oNqi3cTJGVR9d+f1Hz6b7CUkrTVHMTZ61NqlFIZh5jmTguzo5hDdWoHOCLfrWQH2Qmxodb3bRo2mkTH4YBzpgHvtlvwWBUvifGmUk2xsQ4e3jq2cQbWGS62XvKUIbFNQlJAb/F2bjYSXuPM1d997lDRxYvNWg/NNkYiWSLx0WCr3+KzGcHo3JAyEy4SzWeZZGxQODyGaCfMZx0w31jkGo0NfE0mh3g0XJnKSUbY5bHG4zKeU+5iVSjs7RbJ9kqfHdSw6BgqdgqCPuh+dqvb2HbttrizG8Ito+Y6LN7Lucl+pUp+mUTr8lM0Gh2Wqrx1CDtdnlX4iGBlOsYQPxS/2YPTXzWs6t9pRofGvJZ/Fs6+pUbhMl8DsdNFo1872oigX51b+KnTJvOR+0QmvjBt3ApT6SLA5KNKappPgN+6FcARhZiUTdjz62QrgGppTkw1JukPHrv80cuww1N/E1eIYkCEl1+n7gwSjV2zDtqcPCIrbm76z9N9XymGaQAAVYzyqN3YLXUMx+3lQ5WoxnqS4UOtrnofWv33QPoXnmme26JEL+h+M3DMGAl2qhwq7nHg1+jrzBXczMqD4Kl5Vtz762HNtbcdrDaUyanT0mPMxqwUmgA3pQBHgDDWSLe3wfcMrI7kOoGK9fcCiMc2H8PrfvNr+1D2radVF96D5UHccbbVB6m8ug8UHXiidSfT9xczKTyYDqj9+UrzJ7RFV1zi+cRxSK9ySucJJHsV0WwvsKStadLNRIqTNXu+QwM9W0QBHIutlZsyxpxGEi24pKs8EPJZ2BqF+TrQyp68G6BbmCcEZZEurLa0G/7Mc4usnjCOhWfhbcvmT+fj2GO4+LsGNYY0K9mfXbK44zVfiXQcqdMc2xCy5korPss+q8t+uzU4IBjnEl5Gw1ZE4UBwoDWuK980K+VYlTuMYzVkfmmxmKJ0NE+Q7G2Z8aZdh+trc8uB9s7Ghu75jMwLuTTKGTuRUaq0ZLPJr8FqnCRkpl7KvqpAe8gVeSrz05L0Fn9FvpGvpOQMfstPJBFv6vMxFR6tXvv9RDt3RJDR7/uN7fuyhpNSzTxq0pBTYt+f/RryL5OH/wB3b1G5TPPOOMH7ZxnIWCWtlVRi3NG1zzSC9hcYTmqkUQhztKIzecwAE4SZtBe0XWO3sRT0qvivjtJu0G7axNPgXQ6Vtua+TxmnJkWHnOG6pXn6z+0j5ii2T2b+N5L4SQVS0Ba3mm8COfYjzSaPesRytwZfdLXjHpwrFZgQLMLabK54tzAdOrymW5luZqbk141Mb2ruh1Jr5qAJ91ZGyJL/uWWRx88CwdwS9uClKeeM3SvPJPHxxJBnYmcRBsV+aTmJgCO2vDc5Ctc1FOfcEBINRKqLbfmHlp9fzVEzs0v7carPOi+YGqYau7u2cOB1Zh8Jhln0+9P/F4PfMFqSn3bvQcPcF0q1pBHn/TQnkPtuYNiJ2XeUo1qze1WRycG8GkQYLIksnkiUT20zGfms1wxvel9wiYRqJ9rIsz5TKu2cMz6Uv6mak7T4MCd85n0FQ4OwO5g+G7PNzHLzp8zRp6FK+czIJZayiLcsw8QEram3nui8iAIIhOVB0aqMRVqKNN//ymTz4BZqnofDNJjmOO4ODuGNVSjcoDXZyelGjkJI9bYmEbLpVE4GVoBA9OGWmJdb2nEyn3jPItR1jR9flt2BRD1+R6dpLjOq0nRfMPIQAFi2EYhlGiZCZPfgj/jrJkUCNx7LBE6+0d8X5Q31ZyhF/2ZB7trH0EV5KZhlh5SNsbgtyAH7bqxMcF+1If+Irh8fnLHo9lN7J/9STXyzaOJcfZQeiJN0XJcMRMz+VzVbbco759VnaccM2jXGGfuaLlGesgB6+czIJrPXgZKFJX7ZpASMlDA2kW/7rfAn2tUjNGvjk08IxtDLX0Am8dZQRqVD5+F12efu4kHzIN2jnEGdDlFM846KUB9IcCdu5T0jk02JksirzN6GGqPB+3repzVCIJheLOUVOO14pWXRB3gaPV8pmRjPMAtaRQal/pTBhTtK0whsYHujOlUHmjPQm4RbvQV3oNnIdBLBBoYZxnRGwB8PnMqDxzgr/tv7ZjhFwfyv+uR92oNPowzIdlKqTysFTrC3sRSnDMmZ3Ts5xU3d9Dy6P5gNatqSzR4bhl9hTUpWBFcnlzeU6pxH56FACPVSJxrIiQrnAOrkR5ndN8yBZ/y+Sy+G6ny4CyPPl4YmBbzS4X6jJGgwYUXZ5nneTh3DADucT77AItHNTfxOgp8mjDg06JukYThpL7ketO6aXG1rch8TqIOEENdU17VKKpGSqXOFUIxinr2UOeaiE1f8z5hzmhqES4ABXoOUpLUXD2s5/N9fIU7C5N1wS1qP2PqfeYM1Z9aPOPW9wm/R81dD/lcNS1/7sb2uWtBPF8AC+PsriQZ4d1n4ed7V8fF2eJxXJwdwxriYShQZ5zMxJjCKjbxOhJbSBhRRT8t1Sg28RSKVcryEAffTbEfCquJli4KZepaxWBRl5ngTFAB3uOgbJoRpXdAy9FF/6b3v/FFv2YkQ2WtxZkmG7OQzITuldfRpg+hiR/LTPga3J6mEeIwMMpMTDzOGIYKJxuzLZvJM2CQaqSMjflB4b5lY6j7yOa3AJgYZ9PXpFHILiv0Z6JVn90g40WFkGwVYZKaWirUa4p7cMS+pRrFfXShFf3rskhpTyTn31agXxk2LDUoiEMGlMEwVDjvsKZp8eSuxKOTaT6Lz0JdU9u2uNmDxxlglivRzzU1Hp6mngzSnuWjy8aQjDOabSqQwZs47M9ov+f4SApqdYZKdx+K+ud8kyzmcSae40EQeMsuzR0Tz0JPVmveS/2Zmn9OOlD//XX/TDV4cIuhiTdI2eyriRcqDw3BvtHPNTUenSR4ui0nr+NqCdPwvPNm9gOr+ag8CMlW/Yxem50CTFUe9i2/ep1XyOJQfser5/M9VR4k42xjWJwRADRO2q1iau7zHTzOMgNwaF9gtQsnX2Fe2k0ftDdNi1vGVziJ6L6l0NkDRunVGmEwyFW7Mg0n0quHtjgzSGbOGVO7g3UH7WKmMvU482WcRXzNTfmEs357/CIcmHoiPTXYHQC8R/K+7A6A/owmzgXqXFPjkYEVzvmEA9Rssa+5NflVUw8tvgdflYdMy2kK4LpU6P2MyUpmzrjOq6GHPgSfcO1MNJ1rVAglEgmk5eTRiTk3RxBJCJnRNA5ZlQcTWI21JNqWR6nGheO4ODuGNaRsTGI2NtYp0sBUZoIa4Ik4S2PcEBIgHfqVfjCYaOlX22p2ZA1gYahUfBP/8JRGy5mKGW7YVtXt6KGcSvQrIxvTI3uqpp1oQ3ORT2Qm1h20iyI7i8dN/BIyE0EAnPbfRbekWrFAIGTXfKTdxO/ny1BJY27pw0k1dt/XrXZdlwbZmGGJQTTxezIqN+cz38SbPJFu2Caek2qcSu9wfysKKH+ZCU569TCaeGAYkO4zOPTrWjndNG0vdzpmkALuA5oB/Ur7rghARaqd0SbGGSfVeKs18ddFhaal8xng0XJSMnNvUo2cD+n4XFPj4UlMMki7oRwFbLFINeoeZ4ysGzCgb72NynVpt9UX4eMmfjGPM+U+Wv2M1pCp3n4LknHGv04/Mzhf4YIYEoo4y+JJPgNdjcrJxphqjX0twsVvq9cSwPRcU+PBSYK2nS56OJUHIZXMLStosBp9RnvnM8MgbQg/l6Ui16QaJVhtz2f0lXYfbTwlL+cOymLAx+tYl0enPgsFQON9hTmpRkYeXdTcJo8zA1hNLLrmCidfYYO0m95D35Z8D80B0Kqm0XzCbYvwSNZlQrXDFtuy1lQeeIDrUtGBMrrrOEkihMGC4FOFQQqsN2iXPXCk57Pb79q2rWSocBKP0uNM8yHlpPrJmRgD0jYxSLvPQi/zOKb1HHHe+1/qYWKQAgZWeGEGq02XFZRUI7c46/7biXfNPQaSAPzzZanIteX8Eh5n0ie8f45nMp/XBJS3EwYp4A5Wm6g8MHPulKgBdRapac7NgVs61RYTWI2ruesj42zhOC7OjmGNXGviWb+FePpA0QdF3FAO4JESHfqVR7N310gX/fuSjQEYTyTDUE4g8nV0jamY4aj9U2nM7j05PWch1cj9jR510xWGOpq9e++1PM7GS4zzhZr467zCeRpLGb0s7pgaaw0zJPqVkHZzCZG/pkF7WTeIwmAkcxqbin6miQemRb9knBnQr1w+A/MP2gfdab6Jpxgq51mMKAwm+VzWDYqqYWRj+CZeXz5yBb34ncVgyUeqkcznlRkq6jVdZPHePc50BunaRX9JMEJ2YaikUWRdhOtnNHe2UH4LAm09yWfDUE58FjKft3ts4pkFLHWuqfHohGaccbUEK9Uon9EquIWTjRma8dSDFU428TGNaF4qtmUzGnhebBbyONOYTibv2yVi4nHmKRuTV7U0KudeJwZ3IhIGCDHU3LSvMOe3QJ3PAIxSNvuuuWlWuCGfT7mau/vM4uwXEfY1D1nnaOAGE/BEqDz45fMg2eryHkuEeMYMYLXunth3Tk/zeW3G2ZQ9YkKB6yHOv87/j8vnsVyzeD9a2o1hqKQRyrqd1I1P7kpEYUACSaXMllGqke5pdw0p1Uh5nFXTc02ErYc+paTdOKlGbfkYhgHb46jgU8Ad0KQDSUwA1yWibduRPHoQBIsM2uUC9lAYZ0Q9bDrX9Bi8r0N2SSWWq/qgnQKrFXU7AlmJEHmiyyk/sTHOmD7gak+ehQAvEZiXw3dFxaNTjnFWT85nQPF+nMijE2BfRrFJPLezJEIW+ag8UGA1+pmxVOQ642yzf7BaXnXzL1EPhGGANKZnSUtFWY2XWqZzjYpcgE9NNTc753bzOAMMPqR31U5SjfuquY/Bx3FxdgxrFA6yMVMKK7eJp2WggK6J34XC2l0TRUvfj2zMhQktV/GLsweMtJtsTohBexKFJDqtrNsx+tXEOKs61Js4XF0WZzmFfhXvsdKgPdeWGIsxzjTfjkMp+qcyE36MsyyO2IEE1ZhzMhO+aDlx/1OIdiPjbE+yMVIi0FOqMQgCPCRkJkyLcM7zpNTQ7ACvz94VykOB58NQGRX8jMnykqHLTJxlMa63y3oW+g615w5OBsrnmooeRcw18dQzQ+Sz7qOmn+Uihuct3cSb0XJEE5+v0MQ7oF9Z2RjmfAZ4qQ6dccaxU7pr6qQavRlnmg/pqp5IVT2SsTlLY9yVtdMwateom3bC8O2G2ocjG+MrB1vUjRzKca/TzdAHthSj8kDmNC2Pbq65BbiFPqP3JQMFgJTx1c81NTg5ZTNYjWP5jGsiE5BskGp0z2dVslW9FmA9lYeprzDvTTVnTGtud3bXPoLy/PWqudVBu0FOWe+LuaXPLmC1B5upRydgZsNe5xU2STipTe8bUqrRWHNP3/Ni0y0euR6aVm2hwWoFIY+eMD1OBwgJByUAZ4+zRsvndRfhw1JyWYaK7pU3gNXW+R7IHtog0abH0EOHLLudYnrHrOLI+CwXccaB1Sw1d8YAYoc8mZdBCvBgNQoQooax5jZINepnonhOjuTRGanGXHnGZIkfKzwM3FhtS4UOHOIYTXPGlZzFDL9pFofOgIJ9RFk3I6Cir8qDsDvgJB7rppMcJaUatTk3Zaci4iyd5knbttKSiAqjT/i23Iuy2jH4OC7OjmGNvKqdjMpHyBpp4Gn3/hBxnkUk+vXylke/ygKMuKar7X49zrgiwYSsAab67GaPMxPLZ+q3QA/aG4l+BYDcQWZiSzTxktW2VhOvycacG1DIc4ZKSQcOQGZCaKfH46LfGf0qF5Bh79dG3F/VVAomNckMEp6F59ITaSrVeLGJJ4wWQNWlpmUmgqDzZps7zjd0sWlFy50kE9mYoTmh81mX0gLo7zBlm/gx+tVrcZaMkXLAevk8mEav08QPizM/FPHcweUz4PaMaXoWVRp1RT/JCCcGBQkj7VZpfqXqNYWBH4MU4Jv4G8Ow677RNfGErJsD+pWSjeEZZxYvV3XQzrDBJlKNrkM5RtrN9Xmwj9CXGIMk1/6W0uK5rS5gV2ec9U24vB7DsomKvBykVwF6mKd7Itl8hTkfUtKo/Jb3OMsMS8DrPUs10jk9Xtaq8UjKo4/lV021BDUIq5sWbTtdhAPzyaNTIB3fM37u0K/J5E01Z+heeYLdpYM8lopB2m2c075SjVLlgWGFT8BqjK+wzpYSccb0ppcG1ZbMsJy/zqu9DNk3SYgoDBipxjHLUY0wDPBgk+DJ7TSfARp8mjIeZ5RPXBIFVulVwMfjjJZHXz2ftTN6canGlcFqchG+I1htlM9MrTGw2uxLlooBn3Kzpsv+/n/I+ApncUQybWTNvae5GJXPdrAar/LALcIBTJh7lHIHByQbqTxEfioPmyQaARB8pB73ERO7gx40uM+zkrLNWNuH9L4qD4PdAf06atkuwWoeymqUnPJdWaOoG9YnPOuVC/TftG070ODR42zZOC7OjmGNAc3OD/P0QftwuHk8UIgmPq9qvHRTGGWgumtimvi9ol+ZxRkr1dh9hs8+2Y7+u/B185Fq1It+M/q1luhXwK3op5p4zs9lqdClqU7TCAExyJ079AJu9aKfQLP4SDXqaDlOZmKKfnW7F0VwaLnPPdkahnIhgoCm14thCoWavW9cMF481qL/NMHn9HzOzfns2jjxnkjNOJ+dZSY0o/Jw3Sa+6hFckyZ+31KNjFH5WjITHIMUcGziRT4nHZqdkpGlBgXifps0oIwMVBAEHSNQy2dxnrGDOYZxti8Gqfg3KXaKSz7nVYPHN9pgrqjoRTiDfhXPyVRr4k1+C5ueAeyTz8B4Cbi234L+jJELjz0iYKkF7NpNvO5BJM61ORlnhXZmyEUO4yusDvBEUECFJ7cl7sraII/OL/O4Ydd9Q9bc5BndsIwzrua+zmucpXQtQeUQ5XHF1cNSDs1T5YGSXl2boSJ+Y7GYNHlTzRm6V94midC264F8SoI94vOMcZJ2q6Z1NOcrbGOF6yCwzz25MzDCzQzSfSzCTRKBgzw6vwyf5rPZ7oCUamym3swccCUvNdUWZ8bZGBi2ej4Tz5hFGWepvjhbCax2z5rbJZ/JQbsJOOnBIP2crLl5VjiVz1eyVtoD+DRLyB6aAmGr8eg0wZdv8sl3yDHObPLo+lyMtjsY+oAsiXYGn4r30wkCS4a+nD/fxKiadq+eoEPNPdx/q/uQVveVR+8kbDlFKWruJoGTBPi0+9/dFmefteQz58O+LceSmcdYJo6Ls2NYQ6DZTYWFboY+oF9pA08K0X6WdbI+6tDvF37j07gra7zjLa8gr80mM7EvE1TA4HHGFAjPnqX4hq98hJ//9U+OvsPrvEIcBmSjwEo1Nu2Yku6Afs2YIR8V4vpOFEQu56GxVOjLPNF8UTr5c4aOol57ccb6LbgWCCOPM9qngWKccRJGuimrCAr9+okv3eADf/B5Np+DoMsDcii3Jxkoca10Ez+VNlHjnV/9CvzOpx7jdz71eLhOQxPPyeOVdTuVjYmZQXu1I+NMK7BNng5LBLWcv2AWHnPG1cGiX4ffXzx3fZp4lRWuF/3UuRuHNOOQkg0VoaNKm6bF//hrn8DrnjvFG152Rr6mY7XSi3Bgf0bl27KZ3Nu2fH7biy8HAPytf/Lx0X+/yWu6ibfI443klKOOfdJoTZYqTcU1+lQI8Ob+gwAAIABJREFUyVZ1+L++bMwYOGRaeMwVumchIO65dWVj1HwOgsBL2m3CONNe17btZNgm3o9Dv9IeKtMmXtz73/3iy8hr456XddPitqDz5L4hBq6sVCOzCH/982d4/fNn+Nlf+8Qo77qhHP0aSh5PDkEJxpn+/FTl0HzOaF1RQX0PavC/ROTaGX0mVQSWBasdgrRbqPl+chJtVIwZZ7SMLCW/aPYVJmSgiEH7//3px/itTz7G29/ycvLabODTuf3NRJwzYLVt7+8YEooUAPD2t7wcv/LhL+DjX7yW/02A1aj+gJPHKypaHt0JrOb4HN+WDU6IRfhag3ZKBvN8kyzSQ59ng084d64tFYNP+HCPcRJtVLgySAFKHp1WhND7P/Hvp1E4Ah7lVY2f//VP4etf8xDPnTHgFqbWGMBqe5BqzCLjIpw7o9/x1S/HtmzwC7/5afnfGkJ+W0TMKKVQalZcPTwwL8OecbZbPgPCR+3wwGr7lFPWe2jAT7p4H1Fo9bD4nVwl24tKWGDQz4FSyXkRMTN3NUk1UnnyP/yTjyOJAnznm54nr0329do1XfX18D4W4cfg47g4O4Y18nLwTwHowkJHwHFNpVmqsXsI3/ZFwk1e4ac/+DF8+xufw1stDxRqsHCT71eqkfY445v4IAjwX7z7RXz2yXZUJNz2Cz4K/WqSatTR7OK/T69JL/rd0a+qXIaJ1bZEUENPzstmzrjejv1tfLWT5w5anz1yHhSqHmdG2RgNoc4VoWXdkFKNZ1o+A8B/+4GPIo1C/ODbXmCvj1sC7gvNDvD3ka3o/0vf/lV4/jzFX/+lD8tlmPi8tGwMjVCihiacx5mQQ8sMSGEq8nLqv7jmoJ3K57MF8vlGAyqsLb1KG5XzrA49pH9KErHPJooxId6PknajgC1Ax/K9LYbc/Af/7LP4g88+xY9+z5tJdF33WcxN/L48zoDpGU1JFanx1a96gH/j61+Nn/vQJ/GFqwHVzqJfY5s8HgFu0Vi7Y/Srj2wMgX5l5CCXCt3jdQBP7G8ZTi1gOUDIUkExQnx8mvK6kR6kwLRmGxbh0/uL8xWm8vM0i6TiAQB88SrHz37oE/hzX/cqfM2rH5LXxkk1mnyG7hviGcEh2jmpxjgK8Z7veTM+/Lkr/K+//yfyv98UtGch0J+J2ndYEfmcMkAy9Rnjwwo3qjysDW7pf/Ms7qStlvc4E3mwHlhtks8ecrDi98/6e4JmkE4BaJTnlpANpVUeuu9Jlcb9b97/ETx3luL73vp68tpMff0+wWosK9wAPgWAH/juF5DFIX7yAx+V/03U3KekPDqj8tBM6xzToF3NZz/GGdVDr8UgnT5jOJ/LOaPL5+E9D1LlwQNAp+YzJyNbEOeuyGf9b6u6GdX/apxmEW6VfP7F3/w0/sXlHd737rew6itcrSHybS9zsd7jTP9sFMtRjW9/4/N46wvP42c++DFZQ9z1v8EZIaUscsgFlM96FlbDNfl6nOm1BgdwXSp0eXSOpThnULXe+ioPY5/AAWzjwzgzSTXSjEb1f1OvRf9bEWdpPOqhP/GlG/yd3/4M/uK3vA6veeaUvLZhHqDV3ARo8Bj7j+Pi7BjWkP4phgfRdJHDHG6EZJQIUfSKov/nPvQJfPmmwHvf/SJ7beLA0IdNedWgrNu9FP1CIpBC1+Qa+kOPb3/heXzHC8+NioRONoYuKpz9Fhhka9nLdqkeZ06MMxP6daUiQcpsqdJuC8lMnI/8U2hWx1JBHeCbJCQl2qgY67NzUo00+pWSjeGNysceZ//8T57if/m9P8H3vfWr8LKLjL0+zmRW/x3mDNbYuKoRhQG7FDjLYvzg217Ab3z8JXzoY18GYPMsZGQmGorhxzXx3TMmjjrPKT+ZCTcW4RJBmUZzv8OcIe4j0XTGUee3cUj5bPIR0kMuwiM/fXZxftBLXLohV5+3Zd3gJ9//EbzllRf417/u1ez1cRIeQk5qX1KNwPSMti3CAeA93/NmFHWDn/ngHwHohhp51ZCDdg4gxMnGANMmS5VD82Gc6UjT7v1oj5alIi/r0dDTxM6fK+QCVmOorM0404eyPoOFid/ChEFKodkFeMpDqjGNUVQDM/OnP/gx5FWDH/2eN7PXJj0htftMnHtLLsK76+DBagDw5772VXjLKy/wkx/4qPyc3CIcoL1FxSJNZ5AC1OJsGMqlHuAWVbJVvRbqPZaKvGoQBOOFYXdG75kVPqm5/UBCc0cxQz4D3ffISrtV48Gf+PvpItwwlNPy5EMf+xI+9LEv4wfe9gJ7znb1bUAuMfblcQb0vsKELLctn192keH7vuP1+Ae//1n8P//iibxOgK4lOG/Rqm4mAF6uHu4AsX4MUlWyVf33gSkreKmgPJsXAZ/qdgcMIGSpoOZQnFoDFbKH7mtuSka2VP5GhACY6n06J9UIjC1MBJj8297wHL7jhefY6+PBp91/OzXk165xniWoCYnAYcnIz8Xe++4X8eWbAj/7a58AoPbQPlKNglmvgIlizuNM8RVmAKpU5NqSSlzPmouzvBoDh7jeZ86gFrA+wLB9hD6HCsMAaeznQzr2OLOfu6yvsGHOrasbCTD5D7ztjey1cWpvA9P6KNW4ZBwXZ8ewhpCNkQ8iorAQDx0RURggCAj0a8OjX9UH/uVtgb/5jz+Od371K/BNr32GvTaO8r9P9GsQBDhPeZkJU9EPAO9917RI4Jr4JJpq3FOsvZQZ4I3Q7LJY/ZcV/TpFLi02aFeHciszzihpN5+iX/yNlI1xWIR378f5c9FSjfqw6yfe/xE82MT4z76TLxDEZ+Gb+H2iX2k0uwn9CgD/4be8Fl/x6ESyzq4NsjGc9FJJNPEZYzqsyqH5eSJNi/6098RaIyi/qfMsRlm3e11iUSjqjUeBPXfcG/1aqvlMn4cF0cRLyRMCbGFaFIt8/ru/8xl88su3eO+7XmRllQBewkOcn3uRamR8SCWT2gBuef3zZ/j3/9XX4Bd+81P445duFc9CHv3KSjWGU4aK/n2rcmiZh/wXVWtk8fpN/Eh6VXoi7S+fKcP7tRlnlNQxJ9FGRd7LlXH5TLFUB9nQ3Qbtn3l8i1/8zU/j3/um1+ANLztnr417Npkkiu8blOyziO6M5mvuMAzwvne/iE99+RZ/57f/GICQXjWA1SbPRAPjrNIR9gPozGfhQ8mocay2pULUDCqzoZPr3V9uFVWDompGi/C15ZRLghHixSDt0exBELAystR7UNJuZhmoIU/atsWP/9JH8OqHG/zFb3mt8fpYabec9vacI84Ymf0toYygx3/6XW/Aw5MEP/H+jwCwDdoZqca6ncjXcvWwuCafRbgq2SpCzEUOSR79PEsWAqsNw92MYVAsFQVxfvooT0iPs0QFlNN5Sku76ew0N7Daz33oE/jSdYH3fe+LRq9vtofejiUz5wzxnNDnYjbGGQB8w1c+wrv+1Cvwt/7xx/H4pjDO77g5lMgpVU4365+fFAsuiQJE/UzTdYFLg9VW9jgr65Ey1LmBnT9XUDOO1Wtu6oz2YoULxhldc0tLhJGvcA+E0D3Ommm9KOKsZ/i2bSvB5H/5O74KL7/YsNfGLfOEVOO+5JSPQcdxcXYMawjZGKB7EOmHTN20aAjpCEpqjELhiBCI7pu8wt/41Y/jOq/w3nfzyFeAb6gow/g5o0PL0dJupiYeAL7xtc+MioSbwrA4I8yKKY8rbiCvyqH5MM5yotgZ3mPdon+Clttj0d8tQqpJgQCsKzORRMGocPYp+qW0WxwiY6Ua20kRQi3O2rZljcpPkghh0OXib3/yJfzKh7+Av/rdb8RDxgB1+Cy8tNvyizP7IjyLI/zIO9+E3/vME/zS//t5axMP0EU/zTijZSbENaXMco0KXUYN6KS+1stnGv0K7NkTiVjArikzQQ3CJKvDJZ/r4XsckGn04FfNaSl5ohX9RdWyHmcCLbcta/zUL/8hvum1j/COr6a9U4bPQi8MrvMKSUR7e943uPuIkiqi4off8SYEQYCf+pU/lP4SnH8KYFhWxMQZbZB282OcHR76ddv7rolYVKpRlVNe2W+BkjrmJNqoKCayMdzwfKo6wAOtzGC1n/rlPwQA/Mg732S8NtZvgfC9mCvSuKtf6UH7lEmtx9vf8nL8K697Bv/dr/whtmVtBOFQnkgV9X0zZ7n6jJHSbl6LM6LmXhGspn+3Z4w31VxB1U8mOcElgl+ETyXaqMgVYCnrK0zWgFMGlA3NDnTf4fv/+efxe398iR9555vsNWwSMdJu+1N5uMhiXG85z0JzPj88SfBX/8wb8cGPfBG/9cmXjEyaOOy8RWl5vPEzOmWWbKIPkABVn3xWzuggCFYdtG+JZd55FuGmqCbeq3OGvoBd37NwKuvns5zXGWfAFJA85KkqpywG7T5gte73cQWTd5+Fl2rc50ysew9O5cGc0+9994u4Lir8jV/9IwWsZgKfTkH5aTT1/G3bKcNPrZ0zYsbGBTUPSNdmnGlAAxM7f664Jmq9bEXwKeX5Cwgf0nlVHih5dP1epOpzEWdZjKbtnn0CTP5XvssGJmcIIlJt48g4WzKOi7NjWCMv63HR7yADBXS0dBe2lAhxSH7iSzf42//0E/g3v/7VeMsrHxivTRZgFdPE70vazcBQMaHZRfzYu4YiwdTEJ4Q5tPhO1e8wCjv0DDeUy3Yt+pXPIr7r1aTdqhppNDaN3rfMxG1Ro201NLsHc28fwclAAa767J38ThwGbGFBGpVHwWTILpE1BIItCAKcpV2e/PgvfQTPn2f4S9/+Vdbr44v+PS7ONt19pDfXAoVki3/nG78Cb3zZGX7i/R/B0zth2MoX/ZQPjY5O4pCyqhxa6lj0S8nWiT77ekU/xzgD9i0zwS3O1hrKEehXj+W8GGDvLu2mnS/NVDJKxHkW46ao8D/9xqfwuadbo8+CiCwOUTft5H3EItz2+l1Coi61+4iSKqLiVQ9P8B9/6+vw93/3M/i9P74EYG7iWY8zVU6ZYfhtywZhL4eWxj4eZzT6dVWPM22wsKhU4wHJxnTSbuMBi89yXpw7SS8jy/ktjBikIQfKMKFfu+/s9z/zBH/vdz+D/+hbX4dXPzoxXhsn2S6e2fuQagTEoH18H1V1g6ppR4hrKoKgY519/mmOn//1T5rBalE4QRBTy0dORnFXsJoq2apeC9CBGdYIalB4wXhTzRW0f8q6DBVqEc5JtFFR1EMdycuju8l1VwbVljOF9fET7/8I3vD8Gf7db3qN9fqyOCT7gO6M3pNUowGsZstnoPMXftlFhh//hx/uVFvSiGTSpEzfWtbNhHHmIo/uKuvNMW2yFQftA/h0zFBpW+B2j/2sDnoMgqCXUz5EjzN38KlN2i0IxgwobtBemaQasxjXee0MJgd6JRKOQbq3mVj3nNgVrPbmV1zg3/6Gr8Df/qefxMe/dA3AbHcwkZivCOlVJvfzalBt8WKcESoP6Yo9dN10wOXxInwZqcYoDMbzQY8l1dxBAUMBv76+6BlrPPiU6qGZeU5lV1b71Y9+Eb/y4S/gr/wZO5h8sIfRemhCbeMY+4/j4uwY1hgV/UkkjTvV/x2YNuZxFE4GSqZNvHig/OQHPoqqbvEeg8+CiIxB+8gmfp+D9h0ZKgDw4iuHIuEzj+/MsjH6IITwW+j+ll+cCRNUwFE2hvATG/xc1jkcc2IpeZ7RzL+5gmIuDuiPdYqlomom0oi+aDkpGxNHuCumr8mrqXSESTaUkmoEOt/C//PDX8D/9YmX8MPveAGnhE+QHhmrz77Poj9GReizu+ZzHIX4sXe9iD/8wjX+59/5DMKAHs5zzNCKaeKpocydck2uXj6ctxP3HkvE4OmiFP0ManHOoO6jLKEliJcIKemyK/pVMs4iRUaWlmpUczo2SLtxTfxpGuHypsRPf/Bj+M43PY9veyPvs2D7LDd7zmfxHmpQy1oufuBtL+AkifBf/R8fBmBu4nUEufRboKTdtO9b5LMcJnlIr2ZUPq/ocaYv84bfYf9SjTpDZU3GWXdG64N29wFNd0YPKg8TxpnI53g6lOPOaErlQfgK/9f/8MM4SSL8oMFnYfgc9HJ+qJX26Ymk5/OUQcHFt77hOXzXm1+Gn/lHf4SXbgq2FklNUo3EEHS6CB9qZx959Jw4owUjZrUzmmCpc95UcwW1gF1bqjEnzkQf1kxeKvnMLPWLHhioBuUrTJ3lItIoRBwG+Lu/+xl89PPX+NF3vZllj6tBPZvyqkZRN3tbhHP3EQUIoeIkjfDDb38Bv/XJx/jlP/g8TtlFOMcKbwmPM/r8zJVlHiehPv0cNNMm8VCJmDs4qUZgCZWH8bmwqsoDaXdA185UDL5dkXzddC7WLcNUYJj0RPLwFT5LY/zJ5Z0zmBwQ/QwFPq33IqUMmHyFRZ9nr7nf8z1vRtO2+MkPfBQAGF9hDvDXjqTRu7/lzujhGZN52BUcmq8wCT5lQINzxk1eT0CPmzhazbOQm0F3Z609n6seWGzqoanFmagHKVBGqC3NRYh7+r/83/8Az59n+Mvf8VXW6+OeTftWVjsGHcfF2TGsITzOgE5+bfJAIRDzAK39WxFIWRGiif/0S7f489/8lXjdc2fWa7NRWPdZJOgoamEGbPNEEvGfv/PNqJsWX7zKyQIB6Irs6SBEfIdE0c+hX+PQk3E2RctJ9M4BoV/PN7RO/lxxdYBNPIVM9Vnm5dXAWDtJ6QKbk43h0ew8Wu5TX77Fa545wV/45tdarw2gpd0oycw5w1T068NpLr73a16JP/0VD/Dpl25xxjBppK8U8T3q3yEnAaFK2aRxiNwFzS69nahB+3r5DIyfMQLosNcmnvQ4oxGaSwSJfvUcygHdvXDCyKhRgBUxlJ2cL9V0oCTivPcleXxb4n3vftF6bQD/bLrKK/bcu2+wUo3MApmKZ89SfP93vgGffukWgF8TLxgrMYU21r7vrbYIv6/0akF4OiwRbdtOELlRGOA0jfbOUNkk4ejeFl5xa3wPAM8Kd13OC48zoBsQuzBIozBASPkKO0g1furLt/hP3vp6PHeeWa+Ny+eh5t6TJ1I6Bav55DMAvO9dL+LytsTVlvduoqUap3WOTXo1UzyRnBhnhLTbIcij6wCgfcujXxMLWA4FvlSUFa/y4FI3CDS7eB3tK0ypDhDASQP4NAgCWXP/qVc9wJ/906+yXht3TVIuLd2fx9l1PpUIdPEJF/Hnv/m1+MpnT/CpL9/y0qsMQKhj1hNLLVIevcZJqjBUfMCnk5qbVpJYIgYLBgqstt8zWl/ArskKp+phL5UHlXEW0/MAzidc/G/69Zjk0b94lTuDyYHueVlUzSS3rrfl/sDkbA8tzkP7XOwrnz3FX/jm1+JTX+5rboPKA+XNrM8gU6bf3pa17JVSD+bjocmjU+DTiwUW4VdUD+24pNpHcPLFrst51Y+wA5VT4FP3GrBszNKrQDfn/qG3u4HJuZnj1XFxtkocF2fHsEZRm9Fy3PA8iQJCwmiKlBUhkj+LQ/zwO8w+CyI6TeNpQ3VT7JfCSjGdBsNYt6L/tc+d4j/417plAi8bM11WSDS7bmxMHOAjvwXR6DkUhoKFpBbYnKfDUpFXU7SPaOL3NSCTwyDlcPMxfN9HUAV55ln0pxLNHpEyatR7xOGUQUrpPqshcvo973zzpKjlgpLwkJKZ+y76t1OGigv6FQDCMMD73v2W0b+nx+ArRbF8iKEJsdRSzdMzR5TXMJSbNharF/3K8/KMab7mDGoBmyXuEnlzB1WQxz1yXEexkq/vGcBj2RgHqUaOcWYs+rvv7Xu/5pX4utc8sl4boDybCHDLPtHsgAn96pbT3/+dr8czvYyGn1Tj1IeSH7QPYJusH8q5nGfbop58Dk7GZoko6xZtOx0Unu150H5F5fOKZzTn+cuxu6kolEF9Rki7FcygICbAU0apxr6ueXSa4Pu/6w1O18YNCiXIaI+MMx2sRnn2mOJrX/MQf/ZrXwnAVHNPpRrFd6oCCoZ6mPcVlvehwxl9V9ZSslW9FmA9j7O8mgKH9u1xRi1gB7WMNX2F6cWZyxmdKwtIfnHG+dxOmRXif6NCPAvf970vktKFVFBLfeljs9lPPosBvujVRWwVdp4t0jjEe97ZLRNY1RZWqnEKEKI8f7v+qJXPPVcfUqqHBtZVeVCZUiIEgOB6TyxSAXrUfx8f/6G5o1QG5fJ6+u/E5YyWsx5LzU3J73f/2xRQToHJgeH3cQWTA8pSn5B227/H2XgBK3p5Vy/jH3r7CzJnzHYHbtKr4n9TQwWrudodiNcdksqDzGflmjZJKL3l9xWUV96aDFIOTLKJpwppVKgS/kL5g+uhVV9MySAlwKdcPou68zXPnMj5ry0GqeopWE2XzDzG/uP4bR/DGkLaDaBl1LiHFoXcLJmlD9AZ/m6SEN/31tfjFQ82Ttcm5Ob0AuxKmiYu53GWE4NgW/zQ21/AWRrhlQ/pz5uEPOKQkpnQB+0qIteLcUag5ThPh6WCQvucZ70+u+NAyjcoDeG1GWdUQc4Ns6hQ85kt+gkzdMo/x4RmB4BXPNjgxVdc4N/6xq+wXpeITc8WUOOG+B3mDJOxsYvEhIjvetPz+LY3PMc+v1ipxqadSq/GZqNywL3oN0k1ru23QKNfF/Y4Y3xHlgiqIAc80HJUE08wVIQPpoiYaeKppbmIVz7YIA4D/Ni73JCv4nMA0yb+pthfEy8WAvdlqFxsEvy1t78JYQC8/GLKxhl8pVykVxn0azXOZ8DNR5RC5g9DwuVzelvRA5KLBQbtVBMPuC0s5g62iXeUg63qBk0L5Yyeyqhx8osmX+GEqLlfdpEhDIC/9rYX/j/23jzYluwq8/tyOMMd3lSluUozUgkhEAhJNBiBAA3YbdxuAtTQdIMBMYUN0W0NdtvhvnHDfzQBSGDZYLUQqKExBjWNHS3bjSgJgSSQNdISUqOqUqlKqtJQg967793p5Ow/Mnfmzr3X2jvz5N7nYfusCMVTvXfz3rznnJ177bW+9ftwcWCBnF3Pid+JswuNv6IcY9czAPyXL78DsyjAEwx7tO5Bo7+nQRCQ0yMyPmncxFnZIlvlexl6vY9YZXpz/sLSr8cZSXm42RNnxDTYGMqDPHHGYdRqHzX9DK0WiE2oRgB4/MUFvunpt+Clz36s9b5EUIJYymvOZYhcT8U1jhGrAcDf+frb8JwnXGDX85ybCh/ocabmqYvZUFSjEOmoU+E3z4d0RU2ceZ5QWWU1Bk1DNcY331e4P6U+XGzTz7npojbpEx6ahVZUPP7SErvzCD/7ncPE5IAJ7bYJVKO6njtriCHxuItL/Pi3Ph2LOMSlHT0nYVGNDHqV+to+qnGar3DtcfY3Zz0HQbCRqXC1FrNk9rVNBGV3ADR77cD9GYAyFW6f9Obys6zQ/fZEiH3qNa8YIyY32B148gnfBh/b+b5tWEPGxixnEa6fK4oSA6pRN9nmUY3LWYQ/ec1L2QSYC2PS77HQzpugDk/6H3dxife87qVkggDUxXMe1ahv4CyqcRaO8ziTFBjtvfxNaJwRqEag3kB8JIS0UfnNPsRT6tfhyuYkL3pFOaD+XS5Iy47CHlBFIgphJMcbXvV8VBXNeuZiSah9fI+kX2AmnVZZicfsD/+ZQRDgrT/yQvZgPWMKadTBaR5F2vdRcbBDDbY5o/KbaWxMNee598FVFGWFs7Qgk/5HT/wdNExhLLQPRK8CYuKMLuZlhKKVnX4kmuYivvcFt+Hbnv1YVuhBRYed1BXtQxW0Y6NFBGqoRn1fs8WP/QdPwyu/5vF4HJGXBEFATnpThda2iK6s6URSsXYm0IX1UCUjW9ufITfm57bfzG1wTQzKm8plUF55XTGrwCX4mZjggvdbGFYoVPNpqoHOmaHXaG+qQByQ0yePvbDAe1//Hbjt8o71vkQsuPWc5NiZRYM8ldaJ/WWMex9hMFAjxC1f9bh9vO/134nH7NMLZE4IVrgpH8oPTV4HYVPQGDJZQeW34rW+WYW5JCtwebf/Ou0vYqyyshYHeHivKa+8Mf5DPiIl8uExYrXa4yxsrxMYNXlNylOmItbxFf6NH3kR5iMK1eKejs7653rKa85ldIX2DEC3tyaZjiA2RRQG+P2f+mZwvy53bs2LSke7Efmwuq/No3GoRmpC5WaiVwHV48wvqpGrxQwVkvgIav/kEG1UdBNnESs+rcku3AQU5XFGr+dXf+sz8H0vuJ3MP7ngBHTHq8zbehbfl8Kjj1nPAPCal9+BH/qmp7Z4VDlmTB6dlcQZhxGSrfKi/dwPRa8C9O9yM9GrFN4ZqAV/XsVqSYHLO3ojXNCLuM+yr+Dy4eUswiPHifX6buKsIzFxlIc5URNV9+jcQG151uMv4P3/1Xfg9iu71vsSwWGhKdrGNvzHduJsG8aoqqo/oUIUajlc28yAdqNQjQDwpMs7g/ESIiiUzWmSIwzQcoxdx/4ixknaRwSuc4gHgMddWLLXUFgH8ZDWJlQIrCM1cTYkSRBoERo1dfPUNZTfAuDPCLXFlUibUxTWSuOblfSnRGF7zBRcmsvqV/q6lMHGaOpXpkgo4uJyxjaFuaAKhdT74DJaRCCBahy7nvcWMa7s0UW5zkyWaJyp6tdYX88qDnYxdOKMaepTPpSbCqqJwb0PrqJF+P6/ADOxGOi71sPGMMW8NNcbszFTUDKp5eIoHNU0A8Aiguuk38/+DDBT4XmBOAxGFXyDIDAecmIC70QdHrmJbVnFyjXXqFgRBUauMb+JSJimJOVN5TIor7wxRW3XwXn+rjNB2l43wOMMqBXt6vOcQpLJcfuV3VFF9jCsm8WaZ+HKj3hJBIX87PbDcUfZJ1xass+AmKA8UKhGoF5v1HoGGl/hseuZLbTerMKcrrAX77E6KeQqaFTj3wTKw4Scu+h7nAH6OSwjGjlGX2FighQAruzNR69DClUtGim+J1Q0/Crhq2eLSzszdmLWmOeE+oS2jU9NAAAgAElEQVSK5kGq4GAXsU7EoCLJmJybIUlsIlZ50Zxf5YkzelLIVXTiU1UUcPNyburcyiHayOtJsZoubtEb4fT5r87P6c/8PA5HNc0ACVUt7dG+fcIXcYgoDLQGLLWH2CIMAzyJEfPMWsS8isfTzy2dH5qOUxbn+kUjZLDh0fOiRF5WWpNK1EVUP7lNBCdW21tEflGNKx3VuLiJ4hZefDrsWS3bHdTX6dNzlC9iFAYICF9hqkYnx5imGcBPw1K0jW34j23jbBvGyBu/BpEA0OpX5hAfBTzajUn61wnqIScO8b5GWClEIDU2PTUodAR7iDepX+ORqEZGWTP0elt84sEjPHRjNeoaCk3FeVO5ClYtt0bS/+kv38ADV88m3xM1DTbW2FhFNapF7fpnqIX2oPZvkRJEk1H5unEzsTHUxJnT9RwzCiXSb2GY+nXoepava+/Hkfr14RsrfPyBo1HXJMTE2e48QhD4mzjjGrBUcdoWR2cpPnz/1cn3lLJquWGK3P7EGT0NSz0z4raJq+zRJY9qXCe6ibPNJv37y1gTVFDNpqlBCQrGYWM6HOw4tJu+H3JYqrGRFyXec9fDo4oBpokz36hGVUW9zlR4WVZ4z10Pa2KvscERARYEcpGKbj3zvsKcYIXzFXatAF4QRvAniT/PQoBGfnKK6ylBFc9zpllBCU+m4NG5nNtFof3D91/FtdN01DXUPV1oxWp+JlTEM1tuhi9H0DLkWOecQQWFL+YQbVTI02R8oZ0QtxDi05xZ+1OCOs8cexarGfHoDvfobk/s1mlVVTQenRCqajl3HA6cIGUoD448zh64eoa//tKNUddQzfn2fVh5mjhb6ROkwHCMmhwPrXHOoILDFw+dCpcbZy0lQM25iWaY+Lyphfa81AkFU4KqB5xnBcrKH4WpRQQSJCaX61m8TtpzsdTRq6KGoeGUJVrDYmDOzfmptlNt5bQ1vcoKvO+eRwb5G3fX0MKhjaAaOTz6iD1anDPG/M5UcPhiil5ERZtzG+vcdF4/CylfYR69uk5wQkAKmbkN/7FtnG3DGKmi6KQO8VzxnG768Ebl6wY5oZLk3vzNADrp93OI15uPImGgxtL1kfRusxdK4aGoRjVBEFgqF0n/z/zOx/BT//Kjo5ME9Z46tZznxpmmrhnHZ79+nuFVb/4A/tm//evJ90QhXUb5LeSlNJJOX0cp4NrCr5QgCq8ut42zuokhfzZ8o1d5VKPrpJ9Xv1Kvd1nVeMHufhT1K6EUpoL1WyCm2taJX33PZ/D9b/4AvnB0PvgaauJMHL58FdqN2JiRh/jX/cEn8ENv/eBkpWGX9E87xC/iiMWoUet5zjRxTajGdYJS5hdlhfOs0IopLmN/oSMCVyP9U4YEVWzLCFQHq37N9UO8rcGiIlv1nzFtTX/gs1/Bj77tw/j9jzww+BquUHjhphzix6tf/+CjD+JH3/Zh/Pm9X5l0P+x6jiOkRdl7npuul9FuHDZmyFS4ybNw3aiVvLTfgq/YX8RI8rK3dyYexGokqpEhZVDCFXkdjMGjy8hWERyWamxUVYV/8NYP4rX/6uOjriN9hT37kApBhUwemUfDMWoivnh0ju978wfwP/3JZybfE7V/jpk4k8kFVFG7LKumeE6sZ2V/bpvmI6eyTEGdZ8REoW9Uo75HOxarETm3eEaqlJx5FBDruU+SWcTTxWouxKc//0efxqv++Qdw/Wx4w4s6z4jJTl/rWTTYp1IeqqrCz/zOR/HTv/PRyfeU5jS+eKggVpALojBgRau1Z6EubKn/bTiqcZ2g6gHi/fU5FV43bPqvw1ifcFuIKR8Sj87lw5RYTaK2APY9llvPY8QxpvijT34Z//A3PoQ7//1Dg6+h7A4AYH8580ZhApo9mhCTA+P26F9/33340bd9GJ/64jgBgBrcnjj0GaOSCxYjBkRqsZrf9TyLAoSBXqfznXNvg45t42wbxiA78bl6iKeL59QDJW868S4nwaiH3IlnbAyFmVjHqNwWsyjUpnxE0j8EMyFwEQtJLbeu+rX+GTqWap24dpbi3z1whHf99cODr6EKC94P8UmOWRRo6JDlbJi3lIi3vPde3FjluHY6XdVHJeSj/BYUz0Lqutqjh8ZMyGtaNNFcNsIXcYiq6ie7G0M1em6ciTVL4Xf06QH9wK8258dPnNnFDevEtbMMaVHiTe+6Z/A1FA4WqAvtvjATnIp6LDbmY5+/hjv//UNI8xLnE9EUGSOEGJ70i8JOI46I9Uk12qicx4aa0G5jg5r+6Q7xnlGNJAbK9cQZhWrUn5+c+lWeghs6caYiW7t7cYN2u9YU49707nsGrwsOB3tzPM7GHeJXWYFfedfdAOpJ0ilhOsQDdr8r8e9mj7Oy9zUiYgrtlptRjesEORW+yr2u5z2i0O4j5zaiGrWJM73JtsoLzKK6qDoGj04Jw+ZM4W9srLISSV7i3Z9+GB/93PApaZNYzdeapopBQRCMpjy86d33IM1LXJu4ngG6KDumOS/j0amiNoWBqv97PKpxnaDOMzcD1Zg1wgKXhXYK1diSbwaIfVWx2lBPpC5Xtwtc14mjsxTHqxxvfu+9g6+hJu4XcYR5HHortHMN2KEYNRHv/uuH8bHPHzlaz3Rhm6IXUUGv52F2B+Lni6iqqsEpu6Q86PmPyIW9CsoXMYlqHItSNkUQBM2UD9GsIGpiAHQSU67j0W2fRdMZuv750wSU4nP9hj++2yquEpEo9QARFxaxtwnSsqxwmhaEmHy4eBuoxeRv/rP62aX6a46NLOfO0MMEsa1YTdS5Y50O0TXOdMsDnfLgVnwaBAF5Dth6nN2c2DbOtmGMVCnQmA/xVCPHPzaGesidpn5HWKnDIzfKPSWoKR+uMGP2OOsU7YONyonDC+XpMDbKsmoRl7/0zrsGT2zUCvsNoxoZ5OdihKHsI8cJfvP99wPoPJamhNlvYUCSQPgtUCgoyj9F/Pz2XpiEZUqYCu2+koQWEahhJtwm/ZxZMWUm26JR5caZojCr/RaGrWf5uu5nuEE1iufgH3zsQdz7yMmga7imJOVl4ypO2QnS4esZqJ9b6vdcN8Trr2EmCBwaFakqbiGT/mGNWYBe+1OCKiyI99cn2o30OHOMXgXoPEcIhNSvAxhUo7SexX2awrSegemFdvGZ/tL1FX7n//7coGsSZuJMrOepOBYujhNdJLUYWAwR8bsf/Dy+eL1Guk199nCev0OnwmX0KkAjrTj165w8xPvIublDvMcJ0iUhVmMU11PChGrUPWtonPJSmk4BhjbO9Jy7K/xNWzvyZ/oX/uiuwWsxyXWx2h7R8HAZJwndgB2zR3/2kRP8q48+CMBNg4/yCB36rAYUPDpR1ObEM9wEKcD7hK8TlCD2ZJUjCIBdjz7hAENt8YB2kye92+aj+noT59skU3PuoeJTej+kni/rhJjseduf34eHj4fhSOvJR30voKbzXQXXgK3z1GGN8LKs8Et/XOfcq6x0glOmxJ5jJlRUuwNqj+YaZz3xaUFPP04JyhPS9xkaqPdoUnzqQ6ym5dz0xC7ATJxJ4lNgyMQZv56B6WI1sf7ueugY7/j4Fwddw3m81h5nfrzGTD7hwHCx2q+/97O4fl4/G6bn3PTznKIXUaG+jvSACFd3ZZq4DifCuXvaepzdnNg2zrZhDKoot8r6Rpq8x1mITEv6K21SampQ2Jhj3/4pRNKvJtgughrtN/ktUGq5MOjev8ETZ0yBkdokxobYeJ//5Mu466Fj/JuBScIq0zFbm0A1Up+jMZiJX33PZ5AWJZ5320Un95kSCSKHaCOv7yX9+nW1Aq7UEnnqsyj+v0u1nEj65TXtG9XY8tml96csK6REs3ZKUAcnTnHYNtmk9SqS9535yPXMJNgu1jNQvz9f9bh9LOIQb7zz7kHXcM8Y6vDlKkyehWleDmriv/+eR/EX934Fz3/y5d73XDeyokQQ1AgS9Z6GquVmUYedoZ5NJvUr5c+lTrJMCYp93zUw/aIafU+QAs0hnsxz7Grj+p6oiTPzc5zzU+2m2ibu0Um3R//an9476DPOoar3FzGyohrtTzQk0rxEmpeainrMIf4kyfGr7/lMu54nN8KZfHjoPYkij1yY0zxIW8qD7kOqYWPKyhOqUcfG+PY4A/riIy++whSqsRQTKnZx4CorsZzX73WLNx9Meej/HlFYI3pcFeWe/+TL+OB9V/G+ex61XlNVFemJdMEz5eE4ybG/1PeFMRNnb7zzbsyjEM963L6TAiLtcTbcV7g3oTKnGmf8et6Ir3AcISuq3qTDSVJgfx5rODtXQU2QJrn79Txv85xuDXE+caKpJdc3KLHaUA9S+bruZ+jPl3XiNMnxNU+6iLyoBuNI6+kfPf+hpvNdhdlXeNjr8I5PfBGf/vJxt0en09a0LB6Vg6IXkddL63kWhYjDgKS2qM8MivKQlx7W898gVGPiWHwK1M0LTSBU6qSMeZtz98/bPbHabGjjrI9sbe+lbcxPW9MnST2p/twnXsQb77x7Eg52fzHb/Bl6IFEBaMTkf36fh5xbFatFGr2Iiq7OXf8OO2M8zjhfYdd17lgX0FG0jW34j23jbBvGULExC6IIxrJfQ/qB4rIoBzDYGM+HeFr96m/iTH4dxf+nkgROzS4mpoZOSq0ILCL3M8aGmDb7/m+8HV/dJAlDvieF2doEqpFtnA1IEB68dob/5YOfw6teeDue+8SLOPN0iOcQbVQkOTFxJl1XlBWqivZPAfoHUB+oRlGoSZSkfx6FzjFrcqhePN0h3oP6lfBbYDETUtKvFqeHrmeuqb9whI05Sws85ZZd/Pi3Ph3/5ye+hE9+4br1mlVOY/N8GhubDvGAfTKgqir84js/jSddWuInXvJ0AN3zbN0QjXB1qnXoMyZRPA+5qXAK6yb+Tf1a38bGLTLT8x6tNc4cG5UD9NQm9Rp26lcdpzzW44xrUomD3/RCe/39D77nubh6muI33nef9RrxWVWLJCIP86Fo5yZI28LRgGfj295/H75ymuKf/sfPbb6nG/Sq3jgbJm4R7327RxMNdLF/6IU5wm+P8GeaGtQ0LJcruYo216Pw6A7zAirHTVuBkLKmY114kigCr+GUBx2jBrhBu4lm46u/9em47fIOfvGd9qkzDge7CVQjhRMbil361Bev4//4xJfwY9/6NDz11l1nlAd1/xyDakx6vsL6hEo3RcaILeScmyngTQl6Kjzzuj/P4xALBRHYFqc9+wq3gj9F3DInxIE0qnHYehbIVvV+XPgKnyU5vvqJF/GqFz0Z/+uHPo8Hrp5Zr0kYj1evOTeDalzEw4gKWVHijXfejec84QL+3gufDAA4m7imM8InHKBpDVQkytmF8iM25YA98aknn3BxnyJaVKPvnHulohr95NzklI82QaqfcbKiQllJ6zkadvZL2gY6I3CdXBeryQmve+Ud+PzVM7x9gL9w512uCMqbs89U/20qWGpLK962vw6/+p7PIMlL/Hd/+6sBTF/PbT6svA5D7ylRzi5UrsEPiASk+NR9zt0/1xcMMnMb/mPbONuGMdrDk1Jol5MLFS0jYlOoxkWsFxhPkxx78w2jGhlFypSgRs05Hj41faIWCsdMqLAeZxMTBBnT9bpXPhufv3qG3//wgCSBMI1exBHmUei10E4lmkMP8b/yrnsQBAF+7ruehd25GxwGV9gemvT3Js7IQ3xzMNcK7To2qMPMuU/6VT67T/8UoEGKreTGWecd5SpIo3KhNla9EAiEhFpYGD5BShcYXapfd+cRfuLbnoFLO7MWq2IKDpt3YelR/SqePcqk09Ai2Ds/9RA+/uB1/KOXPRtXdue977luUI1woEFTDV3PM/kQTyf9FAaq/re+GjMv9WmpKdGy76kJ0g14nMkF4iQrna5ngEE1EujVdprMsEe3fguWNckh6tqp4Inq19M0x3IW4gVPuYJXfs3j8evv+yyunpq9RbpDPINT9rBHd+rX/npeEM1aKq6dpnjLez+Llz/38fjGp17BziyavEdznr/UXkte306cCTy6XmDkPM5qVKNeUHLtcUZ5Qvr2FW4RgYS4xaWiPQ5DlBV60zc506hcEE3zVd5HU43Zo+mce3qhXTSDr+zO8Y9e9iz81Reu448++WXjNRx6lRINugwOPzSU8vBL77wLF5cxfvLbnukw59YLYaPw6JQnkrQfqmQXEaSvMCOcnBIUUvSEQOC6DnXSSbyWLvfouJ0Ioab2FPEpUQSnxGqD1zNRC3AhPgWa92ce4ee+81kIgwC//C476YG7J7+UhwxxSPmE1+vZ1sB/+0cewOe+cobXvfKO9tnjYkKFQqkNFaupE2u1N5qOdtNrYs16pqw3fKznDdodAMD+nMCjM7WkKTELOVQjN3EmrWdtgnToxBm9H7ryODtpapYvveOxeOFTr+BN774H5xZRJjdxJoQnZxP9t6ngRI9DJ84evHaG3/3g5/GqF96Or3nSJQDQphTHhsknHIAVCauR1ShqS14iCocJIVIPqEbVW5NDZm7Df2wbZ9swhtoUo5J+TgFHYmMKX0blBPt1Ax5nFKrR5SHeiGpkMBNyqKiVeTzsEJ5khaZi6X6GG2zM3jzGd9zxuDZJMB2KW9No0hMp8lpopw6PQ7Axn3n4GH/4sQfxw3/rqXjipZ2aI59O93rhFORj+OwmY2OTUTlAq1/9NM76Sb/vkXT18MglylOCQjWK11tF2IrEq+dxRqhf87KymgkLZCv9zHBziN9fxLi4nOFnXvpM/Oldj+BD91013xMz/bNHHL5cRYcr6f/cIdiloqzwhj++C8947B6+9wW3kaihdYJthA9ez4U+cUag3dj1TCixXU6FU6q/bvLPrydSXvYRgX4mznTFYZbreQ51iC/KGtO6vt+CqrDVnxnrhDw99JpX3IHTNG+NvPl7ohW5Pj2R2kM8s55tB+Y3v/denKQ5XvuKOwDU9zp1QoXz/B2KdmvzSEmslpdVjzpgUr9qYrXSh/q135xP8gJpUW4E1eh74oxWqYtmha5oN6FXgel4dBeF9lNp3/u733AbnvnYPfzSH99lzBtWjMJeCBJ97tFUzr0YgHb78P1X8Z67HsFPv/SZuLQza/wVpxcPOdRxRCDa1KiqivQVlp9NXCOc8hXOmbU/JSixmm+7A4DKud3bHVCoRpaSQxXalXOAWsDkgvIHFD9jqmdhVdXTBnuLGE+4tMSPfMvT8L/95Rdw90PHxutYPLpnygPlE76c1QIFU8NhlRV407vvwQuechnf+ZzHtfv89EI7vSeO8RWWc25KSGLCo8v7gR9Uo55r+LY7EN9b8wlnaklTgkI1pkWp788DxaeAveFj8xV2sUfvLWo61Ou/+zl4+DjBb3/gfss90TWKPSJXchVcA3aoh+//8K57gAD4ue96FpazEGGwCTy6Raym1blpagt1Tp+FjK+wB0siVUwO+F3P26Bj2zjbhjHEA0XHTOhJP5UkyEV2gE4mpoY6Jl9VFU5SGvfhKihEoM9Ce0YkWlSSoKnZFRXrItb9Mqjg1K9DiwCmkFnbQRDgda+8Aw8fJ/itv7jfeD8AjcH07Ym0rvr1DX98N3ZmEX7mpc8EUP++ZQWcT1QBcXz2oYX2VMLGUCbCJhNUgFa/OkW7MRMqPovsgH54NH3m1g2qWcEVQubE1yaaWq7+cwifXUa2dvdTN9unIh1OpWLXj3zz0/C4Cwv84js/bWwSG9WvHhvhy1moPTuHJP3/+19+Afc8fILXvPwOxFEoHeKnTqgw63mgp0uqeAhQ1yWEAk4U5eiCvLv1HAS12lguFJ5u4hBPiFu4wtGUoPbdjJg4o6bB1GeM+NNWmOMO8UMbb7aQ1/OzH38Bf/cbbsNv/cX9+PL1lfWe1GLhBeJ9cBXdIZ6bIOVfh4durPAv/vx+/KdffxvueMKF5vtEk4tyql+CiAUhUiGv1zzOxH4oqdSZSW/SV5jBUk2JhdKcFxNNm0A1nirreR6FTn2YqAZ3h3azq41VL94xOGWKVkE9X8aGXOyKoxCvfcUduPeRU/zhxx5kr+GaklEYYHfuT6x2vMpoyoMF7VZVFX7xj+7CYy8s8J99y9MA1Ot5alGuqqqmUE5THuwYKHU968U8q1itJ7TyKVbr79E+G+FA/Xnse5y5b5yRlIeSQa8aCu0yTnlSI3ygeNUUSV4LScUe/dPf/kzszWO8wUJ64M71Pj3Ojg1naMAsJPntD9yPh24keP13PwdBELRN+6lrOjGKT4c0RZWcm6BDUJSHuJ042wyqsY9e3cDE2SLGaVr0zpO+UI1qwzUvKq1ZMSeEZO0kddytZ2B9sVrXeJs+FS7W84uffgu+/dmPxf/8Z/fihoK+7N1TXpA42K4+yV+7brB2BwMoD595+Bj/WhKTB0HQiFumn6EBvWZF1ZKoUPfoxSzURDpc7ZoeEPGDR5efMRwycxv+Y9s424YxVI8zKunnim2zKNCUVTmDpZoSasPgLC1QVX5NUBdxhFkU0IV2D6jG/mg/PXE2Z9SvciFrsFE5k/RTbOmxoRZZvukZt1qTBJPflG8jVOrwaCuGfOLBI/zbT34Zr37JM3Dr/qK5T3eFdl4tN0wJqU6cUZ6FaqGAMjb2YVROYbZqfI9fVKPWOPN4iCc9zgapX/v3xOHf1OAmbVo0Tbl+0l+WnfoVAHbmEX72u56FD99/DX969yP8PWW0afSFRYwTB5OZVNQqar0BKz5znKggzUv88rvuxvNuu4j/8HlPACCb209vhLPreZCyWVG/UqhGovBHFeXayQqHqEZA36MFbm1/AzhldULF5f4MMKhGQtEchQGCwLKeo+GN8Po67pnhoBEuvTf/+GXPRllVeNOf3MNe0+3R/XtyhVfi7lP+GSJs6xkA/sc/uQdFWeEfv+zZ7d/tLaaj3Tq/InrizIZf1TzOKHELlwMyRuXOKQ9x1MdArToxlK/YIxvhhVPCAyDnORTlYbxYbTgenUE1xoGT9Qx0r+F3P+8J+NrbLuFX3nUPu0ZMGExBT3AdYpKGKgYtZpEx5/6zux/Bh+6/ip/9zq/CbvPs2lvEOM8K60S+Kbj8DBiGdmMb4bL4lCmek77CPsVqCuXBp90BUL8/xwSq0eWESuvlSqIaVbEaQXnI9Zx7qE84h16dilJWmyC37M3xEy95Ro0Sf+CIvS7JaVS1T/Ep14BdWPbD41WGX/vTe/GSZz0Gf+sZtwKg94B1om5qUY3wEdQWlfKgTqiQlAddrNYSRzz4hKuUBwqZ6TJaC5O0v6Zd/8w4DLTmc26Y8KPFaurE2cCcm7A7AKZPnKki7de98g4cnWV463s/y15To+f1Z4wQq/mgPPATZ/bprjfe2ReTi+8zGY/O5MNDmnkAMXEWR0jzstcA5iwVKPFUXlTOUY1qrnG8bZzdtNg2zrZhjDS3J/1ctz+Owl7CD/Aj8lNi2SSyotC6iZF0QFdpJTmNQ5sSnQJO91uYhXqSoG7eqhnwYjYw6ecK7Q6SfhkbI+K1r6iThN98/330/Riakvs+UY0r+vC4sCjT3njn3bi8O8OrX/L09u9cFdqzouInziyH+LJBg4kEYB6FCIKBE6QE/98H2q1t5qmoxpvkt+B24kwk8pKCOKcPTkZsjKKWs2MmSga9qhcJx4bgqMuNzb/3wifjKbfsGhWwXGFhbxGjqmoBhOs4TegGrG1C5e0feQAPXjvHa19xRzvd4A7VWJEJ+XIWNSg/O2ai77fAYSb6PyMIAsSKV0CrfHee9Pf3na7Q7tfjDNAnzih80pSofQIJXylFBRoEgSY8WSnNpsVs+HoGdD9VX4f4J9+yix988VPw9g8/gAeunpHXJFmBINCR3a6KXVR0h0f9dQgDfj0/eO0Mv/ehB/ADL34ynnLrbu9eJwtbOGzM0EN8oR/i1esENkadII7DzfgK1+tZPsTXgiefe7TIw457ObcHNTuZ59S5varspjCKK6WYNYTy0CJbWbGaO8oDgJb08IWjc7yd8Rc259yxl6LcKutP0sixVKaW1XjjnXfj9is7+IEXPaV3nwAmNfkyw544hPKQZMoZmljPnM/RpnyFW/KETHnwbHcANCIpzxNnVDMsYwqtHaZVnpjpv3/zqM7L7Hj0gl7PsV70HxtqIxwAfvwlT8cte3O84U7e68w4cbZh9GrX3KHXz9v+/H4cnWV4/Suf07tPwBUenROfDmuc9X2FCTx6UWriGVGzSQmxmktBeRyFiBWMrLA7UHMGl6GSmKqq8rJHz2N9302LiqAw8et5dOOMeTZRE+rrhCpWe95tl/C3v/aJeOv778M1xl94ldPPGFe1JirsqEb6Z37qi9fxf/1VX0wu7nUyHp3xCB2Kauz87IWvsBDeSXsG0QgHGlS/cv5LGazjlFCb+ltU482LbeNsG8bQ1XLUIZ72OJuFgY4w8mFUrjzkjplRYtdB8dkpHNqUoH1o+EK77nGmGJUPnjgzqV8nJgipnvR/7e2X8HW3X8JH7r/G3I9Z/eoj6c+LEudZQW5M9dg0n5R85P5r+J6vexIuLLvpll1HmAnWE2mAWq5dz83rGASBdh3bOGv9FqgJFZfqV/0Qf5rk2F96RjUuYwUD5X6CNArrgq4sKOgUzRw2po+9ANZTy3HqVwCTmuFnzWu2KyX98zjE93/j7fjkF26wn0nONJrC4LoKzivPVtT+yP1X8aRLS3z7sx/b/t1uc+8ukn7uEG+6JxFp0Vd0LgllPlcoiBV/rrzdy/3y2U/THDuzSDvougzOh9QHqnFos0IttOsTZ8MmSLkCIzXRuk6cpQV2lWbUD774KcjLCv+OUbSv8hLLWM9/vKpfGa+8IAiMRe2PP3AdeVn1iuwAsDePcDbZ44zOh4diY1Q8+oJo6nPPDM5X2DceXRRofKLdojDA3jzSUI0+1jOg5Nyl7p9Sf63eNFeLWUPQbCZvJxdiNSFC2Zt33/8lz3oMbru8g498zpxzc3u0n0Z41mRCYToAACAASURBVH5/NUzrOckLfOLB6/i+b7y9JyIROcnZhAKiCaW2IBBtamiN8Da/pSgPTOFXnjgTmEGXOTdFediEWE3LufnP3LpBTfnk7bnFTnmoEaphu6+J5/EQtBt1dnDjWaiv5/1FjP/k+U/CR+/nvYVNjbNVVjrxO1bjhPHK64rT9Nr88P1X8bzbLuJrb7/U/p3ISU4niur4xpndRxHQPc4o2gtFkmhRjb3PontUY31P/T16ExOkamMzKyqUlVvxKVC/Vmqek5d6XYTKh1XvztbuwLpH00JaVx5nXM59lhb46y/dYO6Jxjt3Zx9/qEa1GW5Dr360yTN+8MV6zj1dTM6I1YaeoVsxSsBeRzXCAYNYzTm1JVRy7u3E2c2KbeNsG8bQsTHi8E+hI/QNJVf9Fjx5nMn3Kg50/vnssz5mwof6lUR1GLAxhPq1P3EWWRP+qqoMEyoujcr7788te3NcP6c3+tY/hfREmvnBQKW8b4dpuisrSpwkOW7dn/fv04Fariwr5CVdCKMQbWokhDJH3ZBTplBAJf0mNe660R3iu5/DcfJdhkAEivH8DlXkfk2nxCFew8bEetNcLSy0fPYBST/1e8wJdf3Y4BRotzSff25Ni4KEGlTDw1Vwh3jK60+O6+cZbtmf95oCcRRiOQvdNMKJhHywWi5TJs4ILxiueK4+z32gV+t76h/ijzegZm8bsMpUuI8JFQ3VWFakuKEutOuNM7VJsi6qceFgPQO0SvzWPfN65rB5NwPVCJj3aPE7PEZSvgIC1ejrED9O/WpCNRobsxrloWz3ElehKvNPNjBxBugNmyR3j17tFOR9QQGH6dEoD1n/GTPEE6kT6RDvKfF8GRunSY5F3Pf2DIIAt+7bc27SV9gBXom+z6YBS+bcfH4rfodbtfU8HY+uNr569zRErKY2wolJGy6P5nyFa1KEe1SjyHmrqmIx9S5jI77Csb6eTWdoQPc466FXo4FT4Rx6NQpRVpiED6XEp0B9hj5NC/Z5scppPLqrSS4qOLFatw7oe71xnuHWvf56dnWfKUNtEfURm+dzmvdzHeo5QKHdunqO7Fnok/LQn1Dxvp6XfZGUD7sDoM6jSTweg141idVaaovlOc6JWyiB6zpBCRVuseTcCSMcuqC8Dy7jJK1zCXX9tM9Fbo8+E3t0vy7mEo+u3hOVO1ORNOJTsadSTUDOUmEW677CNarRvfi0T3nYNs5uVmwbZ9swRjdxFvX+VFGNUagbVMaEKoTDUk2JNgFrHiptY8a7ukZXv7pmOdOoRjrpF14KsjcQlfTbplNMDQMXHmcnzeF4V/n+l3ZmODqnR9KT3HyIP/aU8AN0A3YZR8gKGtdxo0lyLu30VfB7rVpuAjam5AvbQ7AxKfHeqtdl7ZpnlFWlfgB1uaYptc8mPM5aRGDzc7uitocJlVw/OKnqV8rvSDUD7pJ+ezGWw0DJ97BOtOpXJYETn/+jM6Ywl5uTfh/41fpwok8u2lCNR+eZtp4BUfjx5HE2EO1WJ/38ehY/gyoUcI0z15NgtdnyhtXsSgO2KCttOs9FzEIC1ZjTEyqq35GqYu2KckPVr/Qh3gVOWfWfu9h8/k2FdqqJsTOLEAb+UI1BoOcSgGggc+u5zjPUNe1iep3zIBp6iNfx6Loynyv8xYSvcI0NdZ1zR8jLqhV9HG/A40x8/2M153btccZQHihSBtXUUhFtQzyROmQr44k0Oeemn7eXdmb8/myYgvOFajwx0EKMjfAzOud2UWjnPH/rewqtE6RqIzwMA8yVZxM3cUb6CuceqC3CE7J5z8+zAqVnn3BA/xxxCOIpIV7DlMhzdJ9wqtCuik9HTJwZcm4XYjUu56b26LKskOb0FJxvygPdCDfvh1TOLXKJyYV2C+VhSI1kYfE4UxHqQPd5kz877WfR4QQpUK8hdeJs0zl3e4b2ID7VUY36czEMdRx9Z3cwTnyaMPUASuA6NqqqqlGN6nrebc7Qppyb2Z8BT41wpgHb7mvMfnh0nmF3Hmnrzg0enZ7CpgY9qNDEp0Q9QJ0yFTELdV9h7kw/JRZKzmDKlbbhN7aNs20YQ2wWdvUrra5Oi34jh/vaKaHe0/GG2K+UWs49y5k+xAek30IzESQ1NlTV25BDfMIU5eqf4Ub9ujePWq8gEZd3Zu0BWA0jNsaTx5nJ8N40Ai4OLZd36UP8lEK7qVFFIdrUaFnOatI/aIJUmGz7nVBRp39aZCbR8HAZ6oSKqXA0JdSpk64RzvktKOrXuL+egSETZ3RRm1LXj43uEN///pd37BMq1D0JwYM3VCPpcWbGxlw/z9rfRw5XajlugtR0TyKSrNCS/nNS/UphJvpoNyHQcI5q1Pjs2UamU4BOmefDPwVgUI3sxFl/2jRRnjFxFCIMhk+c7aiNM0Jdv06cJgWJYlnOQsN6pguFQRDUDQ9Pe/TePNZyCXG/pgnSeRxq9+tiPXOev7bmvIgkr/M7UQQQU0jnaX/fpXKAjfkKKwWJTVEeLmg+pO4nzqipk6yoyObjjECfn6+BR2/X85xqnLnxRKLy2Es7s1bopd2T4r8ohy88ukA10jm3eT0D9RlCDhc+pKYcd2du9joGus9Rj/KgTIVzlAcSG+qF2tJ/Nm2qKLe/iJHkHSLQy8QZ8RqKZ6QqbqHy4XN24sxeaKfFp3ojb2xwmC5x5qT26MTQnPdNeeDWM8Dvh9fPM+0MHQQB9uZuxC3UFPbOCHGLnHOrtJeirBGFlK9wFAYKQcjPxBkpVttATQzonh9tLcmH+FSbOKPxeKrw5Fx5xswHik9XeX8qSf7+wLTGWZKXyMtKX882sRoz1erTV5jzLASED6lhPTPi08l2B8wUNjXoQYVmd8D4CrNiNQLV6HpARM1/OPHENvzHtnG2DWPoHmf6JsOOsDZ/J0/lpIwSe0poSb84xHsvtM+Uxpl7NXscEgen0vx6G9VycTgIMQHQhxdVMb9OmA7xx0lOTnGZ1a8znGeFpvqYGib8kEktd52dOJt+iG8P4SQ2xm5s3E2c9T8T6gQpQBiVhwIzYW/iTol2iqq5jxaZuamkP1GSfh989lI/xLPYGGU9y4dxVSnMhU39OmVNc4f4buJMnyKtcbCMWs4nZoLzOLMcmG+cZ+3EjRx7czeFdmrfGIp2ozzOVllfsJIyClv1UMl9FqeGWlg4TYqNqV9PW/Wrp0N8rE+E5CaUXtEXtgD9fW0RR/Y9mp04m16Uq6oKpyndYK4nVBijcoNw6IKnQvtJwjdgFzO+qH39rFazqwftvUWMs7SwoppM0aLdVFTj0EN8zmBjlD2aasyqny/AF6qxf0+b8lugfEidi9UInFbOCA9U/zJqX1sMEDSZUORUc25snBCNcEBQHtbBo3tazysT5SHU9jURR5aJs0moxpzfE4egGhMi51aLYB0Oki7Kyp/FjEG1Twl1PW/M7kDB+PpAuwkaTk6iGjlfYV6spnqqc8E19dsJFwc5typWu2igPNjQq4B7ykNZVjhN6VzPJD4tywrXGcqDE3GLweMMsPuQJjnlK0ygV8mcu/9Z9OZxFke9c6Gp4eEqNjdx1n8NuUal+Fp1PQMyqnGoxxmda8xdrmdFOLM7jxCHwWix2rxBKXohMTF2B4BZ3HJ0xpyhF9M9zrh8uLPxsYlPdWoLoDbOeLsDiqzmfCq8ySNF/iPw21QtcBt+Y/uKb8MYuseZnljw6ld9Aiov3aMa1YKEyffCZaiqy8Sjx5nqt0CN9XeYpj6qUd4Qxvkt0Gq5yRNnKXOI352jqoDjlUktRyT94vA10TBYjROD4b3a3JHjqG2cKSznuV/16xBUI+1xRh/iVQVcN/3YP4D6GEkPAuIQ79vjTMGV+OOzhz30qvj/aqJFqV8TAgMFrJ/0t1OEU9SvjVpsV0G7mdSvJtNoIXjwhZmgJhdN67mqKhyd6epXoEn6J6vl6DU0mM+uYSb0wk7to0YfKjficaY8Y443oH5tEYGeJ0ipKWzThErWO8Tr+9oQcYqKbG2/fzj9EH+eFagqYJd43l7e4T2Rkpz2UQT0hoerOE0K9nNkEglx6ldRuDizrDlTZMz0SBgGmEdD0G6ltj8Des5NrVEVS2T62imh5twnqwaZSUxMuQyd8kAXjqYEN+VDCf7q52c/H1L3tWETZ3x+64LycJbmWlEOqPfo6+cZ2YyiGj4ihMcZdd2UEHupyYeUynU4yoP4PJ5NOBukE3NucuJMxaMzzbmYojzkdBN3SnCNs02JW1pPpBbV6HpND8tzqHxYRYoP9zjzh2ps8ehqzt3sadQUabueDahG14V2sZ7JRrihAXmc5KgqvREOALuLaPJZ34ZqHDJF2vcV7ot0umcGUacJ+2IL09dOCdUT8mRFIzNdhnaG9jhxRqFXOZwyRXlYjJ04y8x2B1PWs9if1Jw7CAJc3uVxyklekOsZ0KfzXYUJ+WnaD28QE6SAG/Epd74dvJ4LfYJUvS5lyWp9X+GyrC1cfE2Fi+fl8QY8SLdBx7Zxtg1jpEWJUMbGUJ34nH5IiART3eB8oRrFA4VDh7kOFRHIGXVOCQ7VSBZBiSI6ZVQuqxaoMGERqRH5sVFPnNFqdoAutJuaefsODMCpMKMa+aK21eNsgrqGmwar74n3dFGvV9FuctLI4SDJ6UcPI+lBELSfU8D8PriMFhG4aVRjSU8okBOkSnN+qMcZa1Q+sPFmCvF5VpNpkyeSqSm552k9J3mBtCiNqEZqPZ+lBfKyMqhfJx7imT1RHDbHTpypn4mqqsxqOSnp55q4U2PZmK6LME0KuYogCHqFdl/rmW1WEFM+s1j1W9D3NfnZxwWnZqc8HcaGCQFyaWdmQa/Se4ELHwMqjk3YmJkZG8OtZ2C6uIXy/AXqA7ndj7LEvKd+1Z8DXDNsFjPqV9ceZ8Qhfn8eaxN8rkNFfq5yGoc2JchmhQG9WpSd1y05QTqzUx5UZKv6M9zk3PR6LpqpkDH3tLeIkRWV9Tk1Nky53sKwH3KUBxcTZ20+TDzP1UlqKlo8+qy/pimPMxbV2PMV9kht2XDOrVEe8oLEoU0NtVnBTfnQlIdCoTwME6fwYjVd4Do2Tpk9etAZ2jBx5lrcYsolTBPY3Bka6Jr2UyLlxGpDfYWVhkW9nvVGOOkrrOzRmxKrbcLjrEUErrr1LO7FZah7ohDnkx5UrFitvieRq6XFEGoLv57TYv31bBIqXDThlA01RxeTmVSYG2f8fmjKuZO8nESM4vLh4eLTQpsgBYaJ1WaKr3DmidpCidW2mMabE9vG2TaMIZQ1LTaGOLxwRSLRbOslCV5RjZ3H2TwKnRoMU6EiArni9JSgmxV0IWSuqOWKskJaKGq5AR4opgTbDTYm15RyQKeWozETfDNPTJC4VteYUY38IV7cv6quiaMQizicNKHSmogzaLdVXhiboh16tT+WriYIAK9+VZN+10X29p5a9WvzPmwIGyN+nk8+ew/VKIxth6hfM3o92yfOGKRDe4h3j425sIgRBozfglAWG1CNrgvtXIMPMDepjhj/FGBD2JhBaDcCM9Gs6a4RTuzRDKrR/VR4v7Bgwn24jH2p0G6aWp4SVLMiLyvWb0FFr9b31PctHDKhwjUMphbau3VCiFsM6tdaYc9MnHnzOMtYFbW6r8nBTZC6KbTz4rChEyrkIb43FV7R4qkwQFYSvsKeUY0nK/8TpICO/Eyy0pvHWaagGofg0Sk01Twa0Ag3FBgpFOzY4IpdwreTwq+axGrqZIGrEBMvxgkVYv0cnWcIAuDCcrMeZyqijQp24mxAzj1rc257E3dKdMjvrhEObAa9CvTx6K7P0ADfrIhVn/BYP28nKnp1QOOsQ7YOE7iOjZO0rnGo58DLu4b1bHjG+EI1mrzyumYtsZ7bMzThK+xoQoXKh4fk3HlRoqxU8WmEvKzadZoxjVmg8RUmzn8+Gmdi3ynKCmcM6cdlzJoahzZx5hnVKF53qhah5sOcWG1QI9zoE+7iDE3XxY7ODXh0Jv/x5UNq8soz7YdH5ynrEw5MFZTTJLNZFCIKAyvlQZ04W8Z6rjHUV5jDAE8NakBkE2fobegx+FU/PDx8AoCXAXgRgBcC+AYAOwA+fnBw8PWWa2MA/wWAHwbwbAAFgE8CeMvBwcFvWa59KoD/FsB3A3g8gK8AeA+Af3ZwcPDJofe/jfVCxcbEUYg4DDS0G5kgCD67lvQ7Vr+qnfgk28ghvuOzF7i0GzZYRPdFOQBaksCpX4FuA6fUPjLPmWPjmpT5cweH+NMkxxMuLrW/v2RAu3V+C4RaTml4uApR6KO88haEIkUEp34FpiczpoR8OYtQVWIChU6mVPQqoPs0dId4Bh2oJAmu17N6TyeGhofLEO+z+HmrvEAUBs4b/RqqkTnEz4gDuua3INbzgKSf+kwMaaTbolWVKs3wMAxwkZlQMa3nRRxhHoXOC+3tIX6pr0tqXxNxnfFPAYB9V0blk/wWChLVKH4Xm9/CJlCNtVF593NMiD2XISMCTZ49U0I0w6qqQhAELapj1CFe9SG1HMJVZKscU/foU2Y9A/Ua+BSHaswKLC4syH+7sIzxpeurte+Ji5Mkx+Mu6LkEYPYfun6e4TlPvKD9vRMfUgMaUVWmUyGmLtprKKNyBtcWRyGqCr3Pn4+pcHX6p/bE29x6FmstyQsSJTglKDEJ51khF82Ws4gU2yxm01GN032FC5LyIE+F335Fv6cwoAtAcqH9Mfv0ml8nTlY54jAY7fl547xuoKtTnrvzCEEwsXFGNL7ae4p5H0URpMdZrOLRR1AeGMzclIjCALOoKzCeGhqYLoPyRHJ9hgaoPMc8caaK1R4v3VOLdjOsyRbZShbaHeDRGWrLxeb9un6uf95NzxhfYrW2AUvaHfDr2XSG3lvE+MLR+aT7ypj6B4VoU6MTn/apLUAtHtqXcjxObEGd/9w3w7tcw4TMdB0XlhTlwf0ZWl4/7Rl6AE55lRfavjYfQnlg0av6hPrY6CbOaBLTIycJfU8GAd3+0pdYjc/1FrFl4owUqzWEmTQn/31IcOsZ6LxRTaGL1YgBEYasNgv7n6/c1xm6zbk7nPK2cXZzYsw7+wMA/iWAnwPwLaibZtY4PDxcALgTwC8DeD6AzwL4UvM9/sXh4eFvHx4ekjvG4eHhiwB8AsBPALgI4K8AzAD8fQAfOTw8/I9G3P821gjKt2KpmK6nOX0w51CN7vnsfcwEd0h0HfIDH+BHuaeE2JR13CXxeiuFdoov3fGc+eLNyqDMd+JxxmBj2omzkWi37vDl1uOs5chTaDcD0uHoLMPePCLfo6kTKqaE3ISyESFwBGqSoK5nQJ9qi8mCkvuinHpPJtWiy2gRgY3H3iornU+bAQSqsUUB9X8W9fxU8S/dId7ug2XExkw8xO/OI4QEmuzyDj2hYkN4+PBEsvl2qPuaCKH2o5J6FxNnXEI+hM9eVZU16TdNqarGxt5QjVKhsENmbmbiTFW/ui60C79RgYsxoTpUZSu1r83jaG30qvi5k9TshnVSq18NqEbDxNmmPc5s2Bha/TodE2vaE4cU2lX/FBWL2P4MZj0D3WexKOsCrmtUozr9c7whbMzeIkZedojAlYeJs5gobNtyblE4oURni2gIHp2f7prHHnNuIVYjKQ/1eqaweS4mM7n73F/SyE/zhEpKTqcEQYC9eTzpbMB5/op7WsdXWEU8cns07SvsvnEGqGK1DaMaJTy6j4mzWEU1tns0M3GW9wvtpPjUUCg3TpA68jij3ps4CnFhEZMTKqZnTIup97CeAdqfumtSUROk9f3TU+GRG0+kNcVqpPhUEaslzBkaaKalSn3te0E15t1EOOD/DA30sdx+fcKJMzTpcRZplAd1Xxs6cUY1qaIwQBA48iwk9+g573FmENBdWMST/bepsE2cUWtnlRVYZaVXPPoUykOiehaSlAc+56aauD7Wc31PXV1s2zi7OTHmnb0B4F0Afh7A9wH4bwZe988AvBTA5wE8/+Dg4OsODg6eA+DbAVwH8A8B/LR60eHh4S6AP0TdMPsdAE86ODh4IYAnAfgFAAsAv3d4ePj4Eb/DNkZGkhdaEWA5CzXMBPVAIdFuHtRy6kPueJW3+D6foSICTWPT6wY1Bp4Z1OxA9+CmDvFD0G4mZX6NmatQlhMU7QwywMxn11VeIrxhJpIMy1lIqphao05GLUclCMB0TySTOs2EshHBJf39iTNa/dpiY0r1EO8e1biIbyaq0e8hXk20OGwM5YWgoRrFmjck/RSytfsZemN+bHDrGeA9kWym0XuLyL1nobVxFpJJv9lvIcJZVkx6HnIotUHYmKYw3sNAKU19UyIfhwFpsu0c1dg8Y6qq2ughfn85a1XP3g7xCt7JhOqYKWhMal9TzcypMHkbzKNgkvr1LDV7nJ2lBfm8sfkt+DAqP17xXnncgTkrSpwkOTsRDgBnE/ZorhHe3pN1glT3LAwCZeLM4LcAdGu+Lcr5QjXmXaF9I2r25v057hXa3avZAUKsxqBXxb/X96OjqYbh0Xmk1VT0alVVOE1pPLox5zY05301zo4ZjDtgFquZcu7dedQ+09YJLh8GdEQbFeJZqeJXKU8kdc/gUP1ecm5JOHS8oT1az7nd+4QD+hS2eE84PLouVhs3cWazOwCmi9W498ZKeWCK/7vzyBuqkfMsDAL6vGqbOJuynk2evxSiTQ3x2aDQbirlgcej9ydIAR+Fdkl8apj8cx37Uq5nqttMCXWKrDtDUwJ+3VdY3deGTJypyFYRQRA0YrUpNTEz5YH1FTbs0T5y7jQvkeQl9pk9esEIw0xnaHeNM0POPUSspqCUAaVxxtSu40jFAPP5wpRQLYlMDcxt+I3B7+zBwcFvHhwcvPzg4OCfHBwc/GvUU2PGODw8fCyA/7z5z1fLaMWDg4P3Anh985//9PDwUF39rwZwO4D7mmvPmusyAP81gL8AcAHAa4f+DtsYH2leagrthYZ2o5OQmGr6FJVz9FmryJUK7ZzvhctQEYE+DvHka5jTh/iuyWZQv7YTZ0OSfh7tNqnQnuTYmxuwMQSfXeDIqKkWX6jGehSaPoy3ngAkqjHFJUL9CgB782lqOW4aDDCjbNrrScyEgo1pfqchxtk+jMrre+rQbptCNQpEYItq9OW3oCVa9MFJmBb3kv5cMSonphHUME13DWm82YJbzwBwaXdOT5AanjFALUpwjmq0NGAXzKSPyW9hdxGjqoBzi6LNFHXSPm6qVb4WUDBQStJPeayIqD+LlBLbfdJfVvXeZPKacx2yOlnkB948kZo1nRsO8eq0qTClVtWvpsINYBbpzAY03kxxYpi0vmzAKSeGQ/yFRYyTNDdO3YyNqqqMuJIFUwwRh3hKzb7bFASmKHVNGOwhEyqqZ2EQBD3sElA/77lGONCJ1fw1wvtTraZCrsvo8Og58qJEXlbO92jxWvXx6JxYrSm0iwm4XC+Ym3JFET59hVdZ7cljmjij9ugkK9mCZ5tzeyi0cw1YU65zdE57FgLT8eipobCt0k6oaFGNig+p/HukRYkggIaa5HyFvUyczbp95zTJMYtoZKbL2FeKpj58wgHhiSTnObS4hcqH1XNA63FW2AWKVJNqSOPNFqdpTXmg4vLujJwgTYgGrhw+PJFMXnliXyPXswGPvjd1PRsIDEMoD+17G+vnMJXywO3RfV9hP55Ii5swQQqolAd/E2eUrxQnKNfWs/LeL+JoEE6ZE3ouJu7RJo+zSzv1WbhQxJlFWTeATXu0rwlSE+WB8yAF6JxbNAunCMq5fBgQNgFD8Ojy/qzv6/WACJ0DClQ/0DXCnVNblHP9pnLubejhNysC/g6AOYB7Dw4O7iT+/bcBnAF4AuoJNDle1fz5mwcHBz3A68HBQQXgnytftw0PoXqcAeLh2E/6qU2/Y3nXD5SqqpCVPlCN/YbBxvxTFERgzUD2g2pUEy1KQcyrX3W1nKmwlhDXtddPVMuVBpPa5SzCchbSRTlD0uIL1XiSFOwh3pRg1+pX+rq9iePzpkKYCWUjgpo4U/2H2okJFdUYUod4Px5nC6mZt9kJlbhrhHvwTwH0wnZ3cBpSaO+jqcTnwKx+5ae7XKlfTRNnN0wTZ4ZCu2u0m01FzSXYNvUr4MATiXieD2uK6s8DNenv1jOd9PcmSHN67U8NeULleEMTpACtfnUtblE9S7jnJ6BjFCn162LQxJkZ1ejLqPyiZSrchF6tKuAsdbdHi4aAERszUs3uYpKGy4e7e7IomxXPQuo6DgfZeeKq04+O17PqK7whbExLeUhyI1J8Sszi/noGeG9mNZ82Uh4moN1ceJBy/ikAN3FmWM+L6Q1mKkxeeaYJ7OvnWftsUsMdHn29qXBK7LZUGuHCF1FFVNK+wnxjfkr00G5NUY5CZroMUTQ99khtAfQ9kfOhoT3OGDz6muJTVWizTpwwqEbARHmw49GPPRXa+XM0vUffOM+wiEPyXvfmMVZZaZzyNIWJCDBoPTcN03V9hedxX6zmE+0mPqMnrV/7TfI48yBWy4qqbVaIJhonDlTFp9rEWRRa7Q6MePTYVc7N79HqOdpmd3Bh4d7jbJjdwdgztH88uk2IqOLRSV9hlvJQ/51obPoUnwLduf54O3F208J34+ybmz/fS/3jwcHBCsCHlK9FM332ItO1AP6s+fMph4eHt028z20wkbIeZ/YHilBciwdJUVaoKn+H+ERK+jelrAHqpKT1mnHdOCNRHSWrZgc6xYM4BPUmVFoUwfqH+Poe1kv6xUGb23gv79A8Z5t/CuBD/WrGQIn7UuPojPZPAaar+kwJ+ZAJlYTBTKR52eLmOBykYHnnhVrAc3+4lhW5J0mGnVmkqXF9xN6iw5Ukvg7xoWpUziuU6EK7rGYfg40h1nOsP1/Ghul5W3ucGfwWmKKnH7Vc/TPZQzyTYB+dZ4jDgJyq2/eY9FOINjW6olxfzQ4MO8THilKyXfuO15rYg5Ks3GwjfDHzQXIY8gAAIABJREFUrn5Vp8Izw2s4Vw/xBJqqnjgboH5l1o5qPj82TI0zMXV5XfFQqaqqLiyw4pau4eEq2gYs2wiPSG8poX6lPQvrz8akQrtJ/Rrb/RaoibUlSXkg9ouw38gx7S1TosVCS4f4zXic1T/3eJX7W89Uzp3TzVBWrCZPIwzao/lpkLmiaB4bpvW8M6un7Lmc2zZx5rwwtzL4p7T5LSFWO8taj2Q19haRIzz6mjl3Thfa+6jGiswBaF/hSsN6uwjVV3gT6zls8iqxLyQE4cZFxApKTfx/Fo/evOdVVfspUj7hZrsDXqw2J97TsWGaNri8S/uQmgSxgB+xmgnVCPCen0dn/ARpu0evKcIxoRGHNM6oZ3W3HwrKAy9YUSfOMsPXTonlrD47FmW1UVSjPBHYTjk6xyn3BeVZ681Mi4nktZ8QXmVDUI0mopQqcB0bJ0nRTPjylAd1TdvsDvYXMZK8nOyP2r9PWyM8JKevW2oLURdTp47Xiayghwnae7KK1frT9WEYYB6pPqQcWa1vYWJa+1NiIeUaSV7j8jlk5jb8hu/G2bObPz9j+Jp7mz/vkP7uaagn1UzXPgBAPEnuYL5mGxMjzUsstImzSPc4MzxQhiixp8QsChAG3UZyvCn1q4QITDypX8MwaBKtfqGdPMRz6ld5QmUAZkJct+PB2NhkggqY1XJc8hWFAXZmkRdUI6UAAuzqV97jbCqqkd+Ud+Z2VKNoDKjYGKBLcrvCb/9nBEGAWdhPQv0ZlYcSenVzyhq50J7kfvwWdFRj854y+FWT+jUI6gTPqGYX65lo/HSeDtP47NzzVqxn1QOMwhfJMRXHQoV4PrCHeCbBFuuZUl9PxUwUjUcZtYaCINAK5mqIg3r/EC+mYfuoRm6iUZ4445TYU0Mc7lZZYVUtuoz9xiuvLCtpj/aDahRrOi8Mh/go7HsWUurXIRNnOW1UDuieDmOjxfqM8ESqC/s0mgroNzxcha0Bu2QmNo3q1/n06XXTRMjOPLIWaChEnlqQYMVqCtrN1DSfEvIzpqoqnG7M46xrwLbr2ZuvsEx54MRqogiu4tGJQrtpcphAtqo/I1/TR9OE6QqCwOiJdFM8zizrWd0Pq6oy5tyuxGrUmlYRbVSkeYm4wW6LUHMN7kynFuW6r/WRc0dtPnG8QQzU/rI/Fe4D1ThXUY1F/Z6o603Nh7vC/0i7g9yQcxMTrWPDRnngPAsBPv/x4Yl0kuRYxOFojJptPQPrF9qN4tMB6FXa46z/HOieGXaPs7wsERKY1qkh3uc078RqnH+ky5ApD0lWIAh8eJz1RfliIpcSCKmev6xYbQCqkaqJifuZbF9iWM+AnnPbhEMuaChq2JCfC0Z8OojaMpHExD1jduYDxGq5nrMvZvRUuBqcWI1a+1NCrtO1dgfbibObEr4bZ7c0f141fI34tyvEdey1BwcHJYAj4tptOAwaG6Mk/YwZunoAFQ8W12q5mpUt85yzjRziRQInq1+5QvCUiBUj1JxRPqivN6UwG6N+pSfO+p4OY6M1QWUaUpd2uUN8aSyQ+JhQqRuwdPJuSrCvG/wW9hYxziYW5QB6U+YKC3LQHmf967LmUEn5ycXKATTLae+PqSErck+SYiOICaDx4pEmVHysZxXr0DYrGPxqv9BOJ/3mxhnfpFo03lpT1K9nFmxMWQEnSlJsnTjzgZlY5QgCYJc5aJgwE9ZD/JpJv62wbVPLURgodarYhHdVPc58iVsWkiJ3o0blzc84ywppj/ajfm0PTi2qgxK3EEblyroc4regIlvlmE/ExpylBTvhK9aBOqFiM4G/sHRfaLdiY5hpkOsG/5QwDLA7j3A2Vf3KYmMGeJxRE2cU5cGA3m0LSp6MyhfS9M95VtTIzA17nLXreQOoxryomNe7v/ZpX+Go9zVUmJpU4rOw7poWeFSuaHppJ9YmSIHmGcO8tjuzCGHgyeNsJOXhNC2QlxW7R+/OY5xNKcoZPEKHohr1RngtPm19UZiiHNXE5db+1FhIucamGuFAU2hPu0K7D181DdXIoFeDIOhNjxjRq5b1rF4n34vteluYJs4u7tQeZ+qEqt1X2I/HmelzxAnDjs5Tg/i0yenWXNNGj7MxvsLrohqjsNcI5wryU2MRd+d626SQy5BrMavm2eca+aoKVnJDnqOhGomce245Q7fXsWK1aTjl0zQ37M/rNc58TIUPEavRE2d1fmHCo0+aCicshdp7iiOjfYm4Xq2P1NSj+rqqqli60owRq1FCqykhr+fTDYpPt6GH71d92fypZ+VdrJo/d4jr1rm2jcPDw58E8JMAcHZ2Zvg22+AiLUpcIbAxcuGEM0MXiutOic0nLFNj2SiX8qLEKis3oqwR6K7TpPDmnwLoG39WVtg1+S3k9qTfhnabRQFZOJt6iD81qNmBemN94Kq+Vm2m0XXDw63H2WlqMCpnEux6jLrk/RbmtcdZVVVrJZOmhJy7JzlSoggg+w/VP6Ni1+hMSfqzssT+zP1aW8QyNibbCDYGqBu6j5zUlpqrrMRj9t3/3FkY9A7NpkRLnj7JGuwGlfSb+Oyd0pTCWExXv54kOYkxBDoc2vWzDBeX3ZqwqV8vLD1gY5IC+/OYbAiLe7mx0pv2188yEusGALsTVX0cFlW+J/PEmeEQL61ngN5347B/4PMlbpEVuZudOGsmVFa5URAyJdQpbHPRpN8Uo9Svg/wWjNiYaY0z06T1ZeYQn1iLcvV1PtSvJo8zQJ8GEffOod1259N8SO0eZ0MO8ar6tX8dVyjohE3KId6xuKVXlLPguFxGO7mY+BOrUajGtChp9KqSD6/aCRV94szsiWRGrwJNkZAmgBvD5J8C1PhVbkLllj36BwZB4KXQbmoILBixWrueDWK1aROkvJhERbRRkRBq9uUsQlXVn6tFHPFn6JDw2ysq5yhloH+uP0ly9r13HX0fUvM5b92Io7CH9kvzkn0mzqOwszugfMJH+QrrvwvVDB0TVVXhNC2wy+Tcl3fmSJs6iDzxZkW7ecGjmycXecpDjtsuk2U9yRNpTVSjoclCIdrUMObczXWUoE1EHAXIVnbh+dSQzwG2SSGXsT+vEYFpXvoTn6piNcO5RRWSrXLdu34RR/hKzpeaBbKVIyrMpGfGOnFqyrkFqlGxPLDVHC84mORSw4pqjCMUZaUJQW6cZwgC+rpFHCIMpqIaeTHJMF9hao/ungN5YzNkrnP3xWo+PAuB+qxl82vfht/w/aqLxpYpAxNNsnPiOnGt/N+2a9s4ODh4C4C3AMA73vGO9eUA/z+OJLOrX1PG04FFNXpKElbZZkdY4yhsEYG+TFABHdeW5fQhXvNbIIrTIlm0Tahwv8dUjzNbAnd5Z4ZPstgY/nNTYyYcoxpXfDIThbUykS3KGQ7xZQWcZwV212jumjETIlE2J/2zqD9NtlRwM9x6rn+u3vRxrWav70k3Kt9E7C9nuO/RUwD+DvFaI9xgVi2/3pzCzKaWG2ZU7h8z8eTePfGFBaBuMJ9ntRCCQt6tEyeJuQErN2vluH6e4dZ9zrNwmsdZZjhgA2Id2A/xff8UfYIU4FGNlN+er6RfLrRvGqe8ynlByJTg1K/UIX4W95+fK8ZvYYr6daYUCceGaT1ftEyc8diYzaMa5eaOHOLeOXFLjfecNhVuVOSuc4hXfO84cYvqK2zCtE6JMAwwj2ux2vEG1ewXyEa4rwnSPuWBxkD190+qgTwIj24QhqkI9rFhEypc2pnhoRv6EdvkcSa+n8tCe1HWDQETBgqAhoIyqdnr+5yIRzeIW1REG3k9hYGSrlvEUb2eiTUq9irVV9jfGbrJuVc5nnLLrvOfQYU6oeJDfKri2vLScMaRCu3UuT4IArtYzUBUmJpzJ3ktoLPl3EfnKXbmXfNplRWIwoDNp300wm1eeaogRMT1sxTPfeJF8poOj+6H8qAi2tToxKey3UE/1zD5IqpiNQ7TOjXkc/1JkmM545GZLkOdCvclJgd0sRqLR5debwoHu7CsZ5sVi0qSGBunBmqLyFNvqBNnuVk4JL6fy6lwW/1OPufJn7Wj81o4S4lWgyCYbM3A7Z+AfT1XVWX1FbadoYFNoBoJ8ekW1XhTwvdT9Frz562GrxFYxmvS38n/n7z28PAwBHCZ+PptOIxaEUc1zpTiOfGQUA+VJlXI1BBJvzCM3xTaTST9tgmKKRFHQQ/XxiX9OjZG3+w53w85TP4pswGNN1O0jU1D0k8Zldd+UwZUoxdPJB7VCPQ9AUQcGTBQwPRCu6kQ1m6shqIpNZK+IyU7gBkdEYfhhlCNXbJzkhQb9Djr1Mm2Kcd1YxYHPY+z2j9F91sA+ko2rlBo47MnhqK2eBavu55LS7GLm1CxYba6w5e7KVKbV56MZpDj6Dxlp1M6jvx692k6YAOimTcEG6N7FqrqV7oxGyoeZxWi0H1zSb6n06RBZjKKaZexL6mTKUSLi2iNyst+nkMpIDXPQmJfG+S3YCgwziyeh7Y4TXhsTBQGuLCM9Ykzw1Qr0PemchVWVKPi3Sni+nmG/UXMrrm9xbRpVyM2RkG0cddre/S8j5vhptrEZ04UisTa9iJuaZp5m8TGLGchojDAaZJbpxzXDYFr63kisTk3Q3mQ3r9BnkiGZ9NcyevHxukAsRo1cWbNuZduPZGEMp5Vs1s9C2lxy96iFuEUa3rEtfsnQQQYgmpMcn3qQlaP1z+jID9fwsM263mc0djQqSGjGk82jGoUn1F/e3TYigkAYXdA5ziyXxHnVWbHo5vEatNybtu+J0Sb+h5dstNm4vudrHLj3jQ2bF55dc5Ni9VM4lPAxRmanwo3N1H0swtLeSDJQMP2lqkhYyc3Kj6V3h9fnoWcrzCHapQ/Y6us0LzKFhZfYZswfqrHmen94fDoIp+wnaGPXebcA32FKUE5t57F95uac5spD+MmSLvrmvWc80Mf6mfRF6pRzjW2qMabG74bZ3c1f36V4WueqXwtANyHDtHIXftkAGIl3sV8zTYmBj1x1i/mWY3Ky/4DxQeqURSbNm2aKBCBlJ+Yq5hFYVuUA4arX89TfbMXKilb0s/9HkP47qawY2NmOM8KLXEVykwu6gamuyJ7khfIisp4eFwQG3KHgeIP8cCUQjuPXVOTdyooz0LRJD1vkwSa5QzoTZ/MV9LfHKiqqqo9CzflcbaMcdI03034pCmhJtkZs56BPmaiazatO3HGF2bSNSdIzzLRCDejGvWk32waLd5v1RttStSehWtgY854j7OpBswiITcW2i1FOaD/PJhFIeIwGKZ+VZTYvtWvSTOhsr+InfseUKGiGjlByJRo991cmawnDk6zKERZoS3irtJCK2bZ1jOHbO2un6Z+tRVZLhGFdtsEqaxCdhWnFtUl5/lp8k8B4ED9SmPX6nvqEG1ckL7Ckvq1KCsUjEfPTEG7+ZogBboC4yYnSGVEoE+xmjoVzk3ha5SHrEQY9IuyLarRWJgbgmqcVmg3KdqvE2I1WxNjfzENaaqGrRg0j0IEwTjPQvn7TfEh5Tx/ORysHJxnoXxd3Qyj90Nqj/ZFeUhuBuVhMWsnkW3N2nVDnTpJi5ItbM6jsEXdritWo5Ct7fd3ZXcwstBuI2jsL2PkZWUV7YwJm1ce5fmZFSVO08K+nqfi0dk9eqCvsGx30DwnRc3FtO/WE2fy3uIZ1dhQHja1nmU/2yT31AhX6lAmJPU8Un2F9XPAXJnoV8NGVJh7FKst4gg7s0jPuW12Bz4nzrh7ZYQkR4YzNNCI1ab4kBrE3ss40qbU5RCfIb1xFrY1MdMzo0U1Kr7Crtf0LKpFY5umPGxDD9+Nsw80f76E+sfDw8MlgBcrX4uDg4MCwIeb//w25nt/e/PnAwcHB1+YeJ/bYEIw2OXQjcqZQ7w2ceYb1Vi0Re/NeSLViECbUeeUUI1HU+bgpB6wqY11IRUwuUgMKqFWXb9u0p/asTEA7aFiamLUDUx3qMYhxaDlLByNjZlcaC/0pL27n2EeZ+q1qiGyiRc9C9Wmj79DvCgw2nAfLmNvHmOVlciKsjEq3wSq0YTG7NY+94xZEJOPcrTPAVYtt36h/cyqZq8byJT61WQa3SL2XCraLYf4BWFUXpQVbqxyXNplGuHzaUW5IYd404GOMiqvr4ukohwvWJkroozay8fnIb7c6CG+U79m9SHeQyM8bvOcvpcrN+FXf223R1PrOW+aI1TYco2pHmdnacEKW4Ba3DL2EL83cdKaimNLoZ3bD2+cmw/x+4sYZ5MO8XwhTEa0UVGWFYmdkYt5RmxMrKhfc76gNDXEM+bYsge4jv1FjONV7lWsFodBL+fOS3pCRZA2UmmPXs6i3r42dOLMRnlYe49uirmcD+nl3RmOk1x73tiEQ/vLmR/0KrNHB0HQayCLsOHRBRL9bG1PJENRjmnOy5FkFLWluS6Xcm5DDtjzFW4aea6jLjDWoowzA0XAddRo3LwThHjZo4NeYTs3+jh3+TA3aWIrlJumYdsp1bUbZxaxGkt5MDcl20K746nwsRNnQ+wOAKyNo86IxlfvnohnjBwJ0RRdKNOwmSUH3ASqUb4nG23DZcgTgd7Ep6pAqDRPBMl7J1VLkr3EqTCJT8X103Nu/v25vDvDEecrvEGxmljPJp9wgJ4KtzbOJgjfTZSk5Sw0i8mzEWdopjEL6L7CrlGNQEd52KSv8Db08N04+zeoJ8eeeXh4+HLi338YwC6AhwC8V/m3P2j+/NHDw8OF/A+Hh4cBgJ9q/vPt7m53G2pQfPb6QaQU20j1a7+g5FP9umgeKJs2TezUr/TD10WoxqPcxJmK6VkRG8IwjzPDxNnEQ7zYxHfH8pwtTYy9hVtszBAzXdmHS0SHjWGS/ql8dgNmYojfQm1wSx/iE1n9yqEaI2XizJNaTi4wbjLp7/HZidfKRdQH8z4eb4inHGfubU/6zWq52YSk36ZA4w/x9vVcf3+HzXCDqg9oDvHK2jlemddzFAZYzkIHjXADZmIAe58qzMlFOYCfOMvVQ7yniXDg5mFjRKHdz/5MH+JpvwUVp0wf4gF+j7Z5O001Kj9JcnZ/BriJMzN6dRFHmEeh80J7HAbse9oVp8cd4nfn0bRDvMEjVEW0adcK9au2R+t+C1ThTxTURTPchoKdEgIjK/KuTaLdhGdhfR8exGrKnlrn3MPEahR6FTAXyilkq/ozplAeFnHIehtdMuTcZjx65KURbs659WkQa8491YfUgPUbQnng/FMACY9u8RXWhFa+UI15YUUBuo7W7iDzuJ6V4rnAo1MhF9o5ysOCQQyKMKHdVE/UsSFEWpxHNptz54XxPOPFE8nmcUZMnA1dz+vn3GYBt43yQE2c1SLA/noGaEHcLAp62FBfnoULGdW4Mp99XMa+9DkyCUKmhComMYrVYhWPTu/RRmGLRRimNkPHxkmSG8VqRsoDs6anIk2pqNczf5+cr7BNrLY3n+ZDaqM8ZAUvREzbRpc6VTzM40z1FfZa527qAaIuskU13pzw2jg7ODh4GMCvNf/51sPDw+eJfzs8PPw2AL/Q/Od/f3BwoK6atwD4IoCnN9fuNtfNAPw8gG8BcALgl/z9BtvgsDFFWSErapRaPXWib1ixUlASDyhv6lcp6d/YIX5Zq199TpzFxMFpSFEuyer3TlaHiMTZ2DgzjNdPVb8KnOIu8zpdbiY7NMyExTT6QvM+uOKzHw8oBhkP8axarkn6J2BjggCkB1GsINqoICfORnicUdNSvtYzUCdcWVFtDjMhFdrTvPTmt1CUFUoJYTvoEM8k78P9Fvhm+PqN8EbNbmCez+MQR+dp7+9tSkSx7m6cu0U12tZz2qieRYjnEOdxBvR98caGLcm2qV/bQ7wp6W/57MQzI6zV7OK5afL+mBJygfGmNcItheB1Q5usN4gbWkyT5FvIFtrZxhldzJN/xrroVaB+rfYNRZbLO/N2srq7J9HUNyjalzFurNw1wsV65qZWF0pxWsTRmd1vYTqq0VJoZ4o0CVGUE9d1h3h+PauNHJP3x9QQ92SjCLiO/WWtTrYVjqbELOq8XIV5/IzYoylUoypsEZ9D24QK5z8kngfrFuZsQgWxFmRFe1VVjcjKNKEy05ptU0Lk3BctPqQ6ejXDLApYz0wXaLc581zrGmAWsZoV1ciTG2S0W33e9oR2i+sCo3hPN9cIn6EoqzbX8raepbwuzelGuPhaeT1T91RPnBkoDwSyVYTwkJ0sVrN5nBF4dPP+3DTQHe3RVVU1e7TBJ5xazxb06s4sQhg4oLZMRDXKz8YgCHpNQJPHWawIJ72tZ8lvapOehTKq0SQImRKqSLxDNXITZ/UZp2gm+rUJ0sHi02HihjFRVVWNarSJ1Qj0an1PzL43jxEEuiBmShwnmXU9AzrR6sjicTYdj65TGrp7Mk+FUz7h4jp9gpRez/LXmD6LU6NG25ZtvWFTzfBt9GPwq354ePhkAH8p/ZWYAnve4eHho9Lf/8LBwcEvSP/9TwC8ADVy8eOHh4efAjAHcEfz77+LrrnWxsHBwdnh4eH3ArgTwD8A8D2Hh4efAfBUAI9BPcn29w8ODr489HfYxrgQ2Bg+6a9NNquKTkI608RNHOLDm2KaeKFh89qK01Oi9jjrTwWQprPaIZ7wT4n6SAEqVlmpmafK9wJ0Y8ljo2Y5R+yot2lCxZSA3bI3R15WOE5yXDRs7EPj6mnafl8uOGxMEID15OrQYet7nM0iHnFnM0JNyYkz1diYV+/ExGfR58TZoycJgM02wuWf67XQXpZYhJEV7XXtTMHGEHx2U9JpnTiTPB3GRneIp793EAS4tKMX2CjVnxy3NA30a0qBfkpcPU3N61lK+oWa16Z+BQRmYtoh3oiZsPinAEzSn/UFKySqUTqAzuPA6P0xJeQC4yYnzuRpA9tnbt3oiudN87Hk39O58rXUvtZ6IuUFOhvfLhKL+nVKIxyom+GmQ/zFnRmuKw3tIfnPlT294TYlrp6luDJgPVN7tK/1DAxEuzFFV6ooV/93R3noCn/8NIPqK+xH3FI/m44tiD3Xsb+IcXQu4dE9iFvk4mZhwECpfkX29UyHKb+dKlYbUpQD+jm3OB/Y13OGqqqc+FVea3LuKwwWub6fiJ0g5e5hug8p7/m7sBTlgPq1VJ83ajEvM6EDJV9hsa6pJu7UEPckcl/hD+o71Jzbx4SK6hOXl/x7KgtPuL12MbOL1VRkqxxTCu22Gsf+IkYUBgyqkV/Pt+zV7/c1wu9wrftMC6RF2X5fKqj89oYl5w6CAHvz9Qvt3RQ2f4Y2fe/WV5gUt9gL7TSq359YLck3TXlofIWTvLY7uLCwXDE+dC9XXkwkC0/E1+uehfUwQM6I0m25hupbPiaSvERemsXBl3Zm+NxXzuh7Yp6XYRjg8s7M2XoGmjO0aX8mqEdVVVlz7il+qSbPX6B/DqDyIMonXFzXTZBW5NcA+pnO9FmcGq0l0cqMzNyG3xhTIYkA3Cr9b5/5+135ooODgxWAlwF4DYBPAHgmgCeh9jT7sYODgx86ODggq3YHBwcfBPB1AH4DwDGArwWQA/g9AC88ODh4x4j738bI4ApuspLFhILpEEb+UY2t38KG2a8CEdhxcj1hJnpJf0VOqARBUKPdDGr2OAoRBmb163lqQDXGEz3OLId4MdmhTpwllomzdlLt1E2SIAr2VwwqmcVMN4gWJqjchubC48zUeLbynMmJs36yw02QAjVSLu8l/fyBf0qIz+2jJ/X7sClljXh/xM/10wjvPxfzkj84zSQvBbP61bCeWwQOt6anTJzZhQqXd2a0UbnhWXmlbZy5Wc/naYEkL9vnBBWUF41Q4RvVcvP1C+1pzhdlgXodnJuKcpk96R+CdpONjX2sZ7nAuEmPs0UcYR6HOPbpt6ApDu0TQWletlMdFHoV4MUt56mY7vKkfk1z1j8FEB5naW+6uyu0m9b0DNcc7c9A7SdqKrIvmNfx6DxjJ8KBeg84S4t2InhsmIQQ4pl3zviziEP8gvAhTfMSZVl1GKgRlAdvOXdTlJtFgZfcl4r91lfY/plbN+RCWG5ErzbrWcKjq4X/IXj0cwMevX2+rIlfPbE0wi/tCMpD19Qecp65sjtDWpSth9rU6HJu85pWMafXz+xFOWAKqpFHI6qINiqGUB5MxfNZ2InV2jP0JnJuwx7gMsRe0+Xcfs7QQ9Cr4mu7iXBGrBbpZz85zi1CzymF9tOBYjWV8pDkZjx6R3txI24RjXBTzl17nBW9XELct+k6F2I17hy9iCN2fwbA7r+ykDbNy3ayUI16mtm/+FR+xmzW46wRq608Uh4UwUqLaiREf3J+bhKfAjwOuT1DexCrteuZmZgGhMeZup7FHm0Qt+zOnYpPbbQGSqx20vinCr9zKvYW6+PRuz2RaYSLnNsycUb7CncUJuprgC4vzJU6t48BkUVT5z5Jso3tz9vQY/CT9ODg4H4Aa7U3Dw4OMgBvbP439tr7Abx6nZ+7jWnRPZh1vjdQPxzFw4EeYe1vbjalz5QQSctN47NbVOBTYhYHvWIuh2oEdLQbdT+LODKrX3O7UbmpCGCK07SwKmuAvvq1NY02JP1C1Xb1LMVTbt1lv25oDFK/xpHWEBiiZgcmYGNyszptQUzBqddP8VuQsTGAf7XcV4T6dYNqdvnn+pxQydtCu209d9Mp1D3Z/BaSrGgKPLz6df31bBcqcHx2G6oxCoN2HU6Nq2dignRA0i89G4dMnE1Ry3XiFNMEqdk/pb6eaJzlit+CaY/OK2Befya9GJU3BcZkwx5ngCi014d4E3Jz3dBQjWLKhzrESwf0zmSeRjVya3qI38K66/k8K1BV9vWcFRXOs24y0+ZxBtR76eevnrH/Pjaunma47fIO+++Un9gqK5ASEyByiELuWWbOVbgY4nFmw8ZQ6xmoPxOmCVLVV9gn5WERR3j0JN1oIxyQfIUtgpApMZdQjaZzi9oUS3K9ASbWhI30nzWYAAAgAElEQVTyYPIgBYBkzcLcWZobi3JUzt09Y8wTZ0CtQnchVLx2miIMOp9jKhaGiTMuBMJx3QafCV2uItqoSAhvKdV/0ZhzS9NSNn+mKSHu6Subpjw0Eyptzu3JJ7yHajTh0eOgbcobfYVt69nwe9jEbqYQBWbbOVqfCi/xmH3+GjFJctVRzi0K9sYJlVmEsuqIB0CHmDSfoyOcrrueDflwfU/mpqhAr6rnqaUyFc7l0bGC6TR5XE8JefrH5jXnMoTItRWreVrPgNysEOIWs1hNvD+U+FR8DfVxTTLzfjgl5xb70jpn6PqeDOKWPbeNs6unKb7+yZfZf6dQ5L6pLaamFiCLNun3pzuH6XWxIROkHKrR1x5dT5AGW3+zmxju39lt/H8mTCOs4t/bQyVjggp0is3cc9Kf5CVOkxy784hU+viI/UWMrKjaSTcfivZYUhwKxj03EaQW2qn7sSX9ScZ7O6lomrFxmuTYNSglLlKH+AH+ce2EirNCe41cNG32VFH7+nlmLM6KAsYUdY1pIkRGtFFBqQ7VZCc1JPIywqiqqmb60eMhvnk/OfSl6xDFAvFzfaFXgS7hM00o9CfOaFyE7RBuU/2p6JAxcTqAtX15V584SwzNeaDGTFzZnbUNr6kxDAOlJ9g2z0IA2J2ilmvVbvRrsbCt53YygFLL2RN5sY9kpXzgd/+ZFwXGJC83qn4FmsZmkjdTyx7U7IrfQpvnkFgPu/p1qMeZqXGWSx6KY0IIj3ZHToUP2aNv2Zs7K8oB9Zq2YaDqe5MmSFvPQv45IJqB6xzkhR+WyT8FgFb8F8GpiGW0mxED1RQfc/UQzzTmp4Q4xJ9uej03HmdJIwLygauR82jTuUWdNqUmqYdMnJn26BYFtHah3UJ52DXk3CaxmmOc8tWzFJd358az25JoUh2dp8bplKkTZ2luLmwPwqMr16v+i6mBJFE/z/vrmTv/TYlWrNY8ozeGalyoObc/X+GirUXwz+i+xxm/Rxsb4RYstAvKw64h5760MyN8SM33dHFnhjBweIYWObcBpyz2OVmsJigPJq9DJ3h0do82i9XEvmO6zuYTLvsKp4aJ1ikh3uvjVYa0KDd2hg7DQMq5feHR6+dfe4Y24NFlYRsvPrWI1SxNqno9T7U7MO3Rc6yysve5XOUFZhE91Sjiyu4cVx1RHqqqwjUrHl28jtJ6PrOfoffmcY2sXOOZmFkb4QPFahR6tZmGNfpWa8JJvok7NZZxhKTxONt3YEmzjfVi2zjbBhspd4iXlCymRL5Tv26iE99NnG1KWQN0Sf8jx34nVMSDuzBgY8TXpm3STxcKrUm/ERszrXF2kuTGInsUBriwjJVDPK0SkuOWPcdqudMUl3ZmRoPPBcFnPzrPjIrZOAqxiMNJEyr2Q/y4pL89vAhsjEH9Ou8d4nnu89QQn1uxrjaJXpV/rg//FAphy6kT53GnTuTUcoumgMmFbbrLJzYGEJ5I1MSZ+bW9sjt3foi3eRbW9yZNnDXFB+8eZwbMRNpM3FKRFiWCAJp6uoeNMaAD9alwHmE0NQR28qZMnDUTKqaJqHUjVvwWWjERg+kRX8vta6Koyq1p237YNvLK8Wu6U7OPm1BpUY0mtFujfpWxTOtGVVVreZwNnSAF1iu0C5EYV9ieOnG2yot6OhSM+pXJuf2IW+pD/LElp3Mdwkj+PM29qNkBIRBSXkPiPY3CAEEgN870vTaOQkRhwK5nDtkqQvVQHBu25227ns+onNu8ngGXOXdmRKOL+9FQjZ4pDyZ0OdDfa6lIDL7C4ncxCVbiqPPc6j6LfiZIATnn3hx6Vf65Ps7Q+lQAbXcAcHh0He1mFp+ahWFyY35snKQ55lFoPHet4yschQEu787didXOBuTczB59YREbP+OT8OgWDyIZ0UZFPXFG1FUUPDrfCCfOfx7EH51PuGiEb3KPjhrKgy88upLnGHKiVrgiNc7U988mbhkiVpsibAHMNQ5RU7qhiFts9Ylb9mbOztAnSY6sqKwTpPW9da+FzbMQkPfo8QJU2xS2POhBRYtHV97b5SxEVdWfG9OASKwMiLRnek+C8lVe4GSVGc9o2/Ab28bZNtjg1a9dsmNqhoVhgDCgGmd+koQkL3FjlW9MWQP01XIhUcB0EXLx3KZmmEtYD25jtWMm7Ebl6ZpJ/+mAomntoaKrX4fw2V2qX00JAtDx2eW4cZ4Z1a9AV8hdJ+ppQ0vjzNBESRvMhBxhGGAed95o9VQbg5mIgjZJ9bmexee2Vb9uGtXY/FwfhfY26W/WYG45xIvXWRRZKA+VSerXCRNnrVrOon7VG2eFFbFVq+XcHuJtfgvi3kRcP8+wnIXGZ8++E6PydZN+DhvTP8TPooBEdbYeZ+IQn5uLhFNiEYe4dpahqjZ7iN9fxDhuDvE+fJg4vwWTJ1JP/aoe4idPnPULM2PidOB6BvSJsyAw7wVXdmvE47prRY6ztEYumiZIZ03DoqdmH9gIB9YrtNvEYfLkGBUcHp32FaYas/33XuRpflCNYetZuCmsG9BNn189y4zF6SkhF89NhZDaV1gWq9F7rWkqnEO2dvcy1Ve4MDZBZlGI3XnUTnoA8jOG/9yIJpeznPvU7Fko7kcTq1k8znbnEYJgWuPMLFYL2QlSgPM460/DZkXFimdmYecrbCoQTw2R63aUhw1NnCmUB1/oVaBfizB6nEl2B9RUh9XuwCpWCyaJ1WxNzdrjbBweHajP3q58SMWki9EnnPAVvn5mFp8CQjwxlfLA7NHxgAlSauIs7ugQmWFKtfVE8kx5iKMQcRi062rTgnJhYeLT7qDNuctaQEh6ysVdTsSK1SznrC5XZ5qh8frrubOXGYlTJvxU1bjSNMJdiNXEc8HkcaaKsIFugnQIHv1kDUG5rQ4lD3pQYZo4E9dlhjyaEqvFYeCFhCCsWDYtPt1GP7aNs22wMeyBYi4UyEaoNrb0lBAbyNWTdOPYGAB49DjBchaxPkJTQvaVEipyVs0Uy0m/rnQEmiajYZNf5XyCrR5AxoYNGwPomIlOEcJ/bi4KTyRHh/ijs9SYIAB0gn10luLSjvn3mzShYpgGA+jCghwsZkJO+i3q10zBxvhQs4v3+tFGhbqpZrhIRh71OnE2/OBEe5zpE2fWRrjh95iCmRBoXFOSeHln3qjVunscgs27sqcjHteNawMmzigW+tFZZsS6AVMnzsyFbQo3JwdVlAP607DGCVK16VP6OcQDdd4g1tXG0W5pjsQwST0luj2xwUCVvKK581uoWK+yFtXI7LE2jNoUtNsQj9hLDNptGZvzH1EUd7Gmh/inAALtJhXlzu2H/9bcfp3GmaWw3U4T2g7xBh9Sk/m4ureIgrsfVGN9iD9NNzxB2su5/Tyr5pInUode5cRqYfu+s77Chj3a1gifW54HthiSc1/eocVqNvQqAGeFdhsGStyP3AgvyhqTbyrKBUGAvfmEQrsVj273FdbV7H2RjmmPls/QHZLMn1jt0Zs0cfaoV2pLXyCUl7wAcSbh6CeJTw0597QJlcK+nnc5sZplQmXXnSfS0VnjWWhAinFiNdvZe38RTaY88DjlDtFGRVowjTPp2ZQVJd8IV/PFovKCahT31J6hN5pzz3D1NEVV+WmE61N7ZruD+mtKyauMnjjjfYUtqEYXdgdD8Ogy5WHAeebK3hxpXuLcsD8NjVETpIRPuDnnXl+sZvL87d2TTazGNVMtAyLq+S8rKi+YRqCr750mxcZQytvQY9s42wYbKfNAkVWzaW7GtfW8Akp/ajnxcHz0JNnoIV4U9B89Sbwk/ADtt8BNqMylr0049WvDyaUia7BgXNLfJixrJv0nQ5L+nTmDauRf3yAInPKcr55mxgQBEMXpbjMuy6rxOPNZaOcTcsCOjamTfv117E+o8IfKuXyIN3j5TI32EH+y2UJ7FAbYnUftz/WhaJeL54C5cTaP++jVINALpotm4ow76A1Rv66d9KdDGuH1v+uYCfPn5pY9d9iYIZ6Fre+IkvSbrgGaQ3xarOUpZZ9QsSf91GdUnoY1Ff46tVw3oeKtcRZ362rjqMbV5tSvpilCuVHJqV/nhApbDg7Z2t7PBB/SIdiYTv3arc0hanaXOGVRrLcV2hdKUXuY+vX/Ye9tYmXbtvOgb/3Wrtr/573nd5+fnQTbkDghWHFC4hhLMXGCIlCESIMgEDQCiYRAiAagONBANKBFC4k+NJI+Eu00bSHo0qFHA9mOffbe5+xde9f6pTHXWGuuVWvOOcZctar8zptfx8/3nn123aoaa44x5vfjbxtjs3QB5hcL458ndb3b5WGuptMZGyhgvVzhj6rB60d11ryFG73nXoHYAozPRBdBSM8rMtWBTRXutF5dQFZr21ad0Q4rzbvtmKRCzxjb0vPuqstEOqG1m+sinFSOBI4NFKBUZ0us3Wz1M33GTHGo6qOebaqGteUippo6yXZpvhT0/fvD1wO2WbKaZfMUtNCn3mAVa7fJmagUZyZ79HE9z/VXm9Rub656DfN/x5KMM47agFwe9J70UM4TaXU8njCHlBSkNlLdnLXbM6PnPok9uoWsRhZtcziUtSHjbHg22TMLj62917gIp9c09NznO6NvN6lWzyvkCs8oSE12l7oNo5Gslg1/Zg4cq8amhdFS3waJy8PITrlyu7bQeXqKmqZZnJVZOJMrzHF58CKrOc7EuWeMjoNJIDIXSWSzatS/iyuSTz/KGl8/yrNehAeMES7OAowYHigGtlxVD7f9RoXK8QC6CltOa/rPKUm/Hg3xK7Ff07m8BfNFJX1uJtsYW9PvahCmmQ5S7IvK6c07tZk4GJqdKU7p5/zEsY1JE1RN2x+Yr0WFpnUP8Yot58cAWpxxZrDIOwo2Ni7aj7+L6wSVD/UcR8B2pUvpOVyPmv412XKk8jEzlMgyqm1bo6qDBnuTauyDkbdgY8/aoJhPLvarqqMjhQoz4+w0NhMFHraZNUi5DzaeDvEO9iudAT6sPqfNhNPa7XgpB4zVsLbF31H2R3WuIf68CpWX9xJlbSaELMH0TLSRW0ZDvCmovHuNtsUNYLN281eovBUM9utMPXNC4PtMpBMs2j/37FeXKnx8YdEv2hns1/0C2xhzxpmjnsv5AV1Xw9oWf9Nc4cJBtFqCqzRB3ajA+HPmLdycgayWjqwa7Zk4+iWbSdXBUpwZyWr+CtKPskHTum26HnbjTCQTM19HHEcns1Nu21ZlnDEUZ3o9c9jsgPrO+OYKO10eNLeGKapavf8ma7cPzeXBvGjXcoUre8b1Eujk03PO0JtUXSKuuWin52KhndGmi/CpPfrsRbjlMwfcGb5LMs72LLJahrYFvnaL6KZpUdSNOxPphIoznoKUlD5SxZl/PbvORNei3ao4o57b8syg712lkVvWyEMCVC95bvIpoNSqa5JP08mZWFmsVzMGWW3jUpyVzaxla/87FpBb6Htsm4moHsaKM45ry+lU4b1ri2UvFkWRcrSaKEjzJLbucOi/fe+TceZweXD13GaByLDnpu/FfE74ND/TfJYvhZ4Tfi5FeMAxwsVZgBHGB0o6NBYsq8ZmaCaAdRUqT/vyvBlnXTPytC9XVpzxGIfZlP06817nk4NNh4v9OmQ6yJv+pmmxL2rsHOzX+8kQ378mTibSCZr+tm1Vxhm76Vevj9hArkX7Ll8wxDsuznSLtjmYmK26xaPJ/g3orBrPwGanZvtpX+J6k65igWrC7SbFU/dZrqlQGawazRcbtICtmtbIYh1sJgw17bBFzBawX8mq0Yb7OZsJix0s4dN1jqpp++F/CT4zbaDUaxsz2p1s9iU2E44zUT9rTT8/P8Rr7FdLPef9d5FU4eux5TZZ0tfVuRVnQz2v8982VoVz8hb0izOD4syVt+BUqCxgv1qGsus8QRJHk4wz9xBPA/cpyC30d7gzkSaKs32JOFK5hCYQ83cJ+9WtIDUv5YAZq0adrGaxPI9jtdyptO+iKd9wKa60M/oSVo2q516JrKZbNTbuGYc+E9Myy6o4cxDDhsWfvJ45+SkAkdU0BalD1Up4vD7Nov2tUCRM50W4h4IUWK5QMWX+9q/JkkEKzDPV6b+FLtfM36/oPFaNWj2fk80eRdH4jF4lh3SS5Wr5TEfkUwMhJHfFHTiIYUsyzl4PNbvnppn00Neze9H+9FaehKz2+Y2XEw4cK1TcCtIUH2XTk1YloMW26UzULdrmcChNcQfjXGGzC9OEOGnJN1yKqyzWeu5zklsyrZ7XI5/SGV02thl6hqzmkStst15Vr8eLrNadSztpxhmDrEbn6UnIam9uxRkwR24pcLfNrD0oPc98eu6lLg+9VaNJIOKwRz+yarTkGy7FJovx9UMR9INV4+UQLs4CjKDFjTnYuO4ZH0Y2Zjz4hfdWjSuwa/QD5JzMGv2Sbq2g8jSOtUUIMQ5NsnSN/WrKW2Aozmz/LRtPhQqHWQNQxtnQvHPyFgC1RHs+QYPwXqrl1AO76Vev74U5xFNwrg9Mi3L9NZkWrm3bKms3jj+75fulX/gAa7Ffh7/znBfhwPj5sebF2diq0c1kMy2nXU3/wWGLmCd22xkbXjmZhZNMpF4953hvqf6eT8CWe94zFKQztogq48ytIAWWNf1OmwlL029aypEa1vb9OmbLrWjVeKEzWj9v1iK36BkHRd0ii+cXM7oajJZFU4WKe4ift2w9+h0+ZzTDqjGKotlMJJdtDNXf0wkzzlw1vcnGOaRkvWqzj6JLwyUX4Tbr8iSOnIqzI6vGdFjmEWnJtPidqsLXq+fh7z3nEH+Oep61arQs5orO4ryoDVaNaeJt1XiKpZzcHp0sQ109d3ZSNruz5+5UWjQbcBVn16u6PMTGerY9D0ihMigazWS13qrRYCt1Cozr+cw992iOXmPRPlaElHWzyHp1kya9E8QcXNbFeffzPnhjWDVOVeEusg3hcZehqBvsi+WZSM97t3JMz+4E1GygyGquuIPujPZ4nYXDVUG3aJv9eSv5dIg74GRu0d93lp77nFaN55qhGU4ZeqacKfajz541zdCV3bVl4+jZbXg91MiSyHrW3l5liCLgZS+zR+9n6BPsxZ73JZI4wp1jdpueh1wFKbCQfGpyeWCQT4E5sprm8mAhq1Ff2O/FGrMN8FLol7fnnKEDxggXZwFGmBRnG23B6Lrt19UMrku2JdAXDZdgv05fwymRpcce97amTLeNmW/6zTYTHFtEX4UKJwQVUEGoVadOA4YDj+fPvnyIJ2aNm/3aHaykOKMh3sl+XRJsbF9s6xZtU1RNi7adH7qnbDnbEE91vKZVo2IEqv997gZhNMSvGmw82Ew4h6zKfNlEr9G8mHOzX8nuQIq3gpe3AAzs17JujfZFOk7LlisZ1qvHAzMn44wUKj6LOZfNxEYjqczBpjgD1LPJVs9HQ3y1XtOvv87bCy3a1zqjdUtqUvnMQWcnms5aVj3PWLYSps8XCV4ZeQvAsZ3yhyFrT8ftVYokjk6mOIsjlc1kw1UWj4gkrPyUXnG2IOPMYe1mzFswKs54Qzwwzrkt63YVm0ZgfKlyqYvw9epZ73NcVo2qH7b1zps0ZihIDYozspnzWsrxLs7ud+OMM45VI9DZKZ/gfKa/w5lxlo0XnLQQXJOs5rRqzMw9d89mN9h36nEHtjNjmiu8BlltVM9nvji7XXmOTmesGm0KP3qfTUqTflFusVO2LcJ1gqsUbxyyWu/yoOrDpWolPJ4wh/Tzm9u1pe9vu9f33u2UOPUM+C3aS0sUAcAhq81/top8ql+G2S9yerXUihdno73YN0RW0+diQL2XtnoGeC4PNrKaPSd8PEdJwKnnJI5wu0mP4w4Y1qvA6TLOHnd25RigzpEp+ZSjCAfg5cTkcuFyzdC9QMSaK9z1gDPPjeH7NZzRa1k1bi5IKA8YEC7OAowwhiZqFnX0sDBau2m2MaXFwmgp9MP5nP7s2ywB/eesaRujKwIA+xBf1G2n6jArVMyKM7ctYubZ9L8ybKCAY1m6KwOC8Ok6w9N+eSYSMWilCpUXRn4KQLYxfow+m3pEvSYz+/VguAinf0ZMXhdbrtQafvpnpwZ5ZQPnrefp71u16ddq2pi3oA3oH+X8Jckpmn7/Ib5mXYQDWj1zh/gTW7txbKCAoZ4PVY33smaz5Xyt3ZLY7J3f20daiA6mIR4YbCZcQ+XIwugM7Ndz+rOfR6Ey1JDKLHRfVHoP8QbL1v53OJZ6NrwdKmyzxNmjHdsp21WtAGUiZSfLOHvY5c7XeTUZ4l/eS9w7zvU4jrDL/cgtrn4YcFi7GZQ+c7YxttzC3h7dYhm1FJuRQuUy9byWy4NuR145FEFZGo3Z7IYz2plxZqjpOI5GKkIJ3gQX4QfNysqlgiN8uj5NxpnEBgoYzsM+s9ChUFlij27LCAWOnzGjn7UpztIEB90GypIrXPW94ppWjcPvv1TPvUnNFnpLkKeT5WZjv9iomxZ1s4Cs5rBRW9Jzv7IUZ9MZmlnPvSp8WU23bcvLOJuoQfgK0oUXZ47zWb0mc03Pne+bTKkIm6Z1kE/nXB7WsmocvoO7M+eEE9a4CE/iCHGkv4dmwt/I5cFJVjOTW1z1DMCLgPp2qJznM6DUY9Kc8Ltthjg63Qzt2okB49gPoFOcMS/C17BHV2eK2Xq1qBqkMzO4roa1kVumucIuos0S6DvQc5/RAQPCxVmAEaamn9QgnCE+02wmbBZGSzGydjuzPzs9wFYLKo9jNC1Qdw0Z/bM5ZB1T1uZpvrHYRHBsEfXPVII906qxD0LdyxftddPiy8eyTCRa7DnZcr1CpR693gfHEE/Bxj4XfG7bmMGi7ehnLTYvlLfQL/4s/uxcC6OloM/77OxXfdG+iuJsUJ2o/2u3xqQ/czBar6p/ZrwMdwzxtot0F5RtjLt5B7R6ZtjBAkP9LV3MUWaha4gf6nk8xHPZcntPtpzdNoYxxBuWcvRzRd0aGbbppOm3MTeX4upS7NeRbcya5BZVz3a2sc5+NdnGuBRn9jyxTT/E+9gpuy/CgcFOmXBgDPFAp1A5yRBf4tGxXAOOMz9f9oWzngFV0771DDgUZ5ll0V4brBpFF2faJe43aAM1IraskIcETC2pqee2K85svbPdHt2sSupfj6fLA7k2+JLVnFaNXcbZYrKatOeuxj03L+PMn6xmt0e3WDXW9D7Oq8I5OeGpdom7JllNr6VzztDA0OOvSWwBoF1Ats5F+2CPLiOrqTm9ZZDV5DXTtsqJhVvPRz03o56B5T3366FCWbeMjLP5GZqtOPOyarQrQnR19/zPN7Pk0zGh3ExA0xUqTXdBu/YZfbNJrfbUp8bacQcAkXiHM9oUAUO1qvfc0+cxK+NsLbIaw7UFmHF5MBBpdSRxhIddfrKMM9cMDRwTwziKs02qLMz3Pq4tDuIJkbA/DJ8t17UFmI8ZigWXuEsx7rnDxdmlEC7OAow41PMDXRRFPcvO9dDKkrhvVm0WRktxyQcKLdrXGuKzdFi29UHlhvd70w3YpqwMgILKTcwa84Wb/vNLgsp3DnbN3dEQz2PLnUqhQvYvzkX7JNiYu2jf5SnaVtlSSOFShEztI3UM1qvzCpWD1iCYFaQx2nYYDoF12K/AUE9nH+K735fG0SqXgnk6ZhzaLivGTf98805/xqRKcjHTdEWrFG+HylnPWRLjRrOZODBUrcDgz76U/bovVGahiy2XJjHSOOqb/p7N7vi564UZZ678FMBsG1MYlnobbfgvq6a/TJni6BJ3TbZc9x3Mk9i5wDklzqNQmVo12ut5FFQ+eU307PW2Xk3Hn6kEyjbG/R4dZ5y58xYAdUafSqHCYr/OKM5c7FcAuM4TL6tGjh35JjNbZZvILfq5XjjILVOrxm8tszBP4/6Zt9ZFOBHQAPdlRZ7E1noGTmCPvrDnFitUqhpx5O7tHncZyrr1tkEkfO5dHmSq8Jf3Ers8caoqbxbZo7tcHhLjUo5mA3PGWd2rFEw991yu8Boq0jiO+tdw9oyzK7o4W6+eAdUvta39smKj99yGbCNbphGbfOpBbDlUKkvR1XMbXVsYGWfA8p6bXFtcyrHNTD0D7riDXe6fQ1o6VNguxdnBoDjTyWpl1Vp3YoDqE+niZ+0c0ouST9ckq1WDKjwzZL4O9uhNZ6F6TN53Wa9+lI11v5dPVIQSvB1q7Dg9927cc7ty1/SfO0kOaWfV6MK05/7yXjpdmKJIuTz4zdB2RwDATlaz5YQDumtLZLx8znQ75VUvwi8jEAkYI1ycBRhB0lZzEOqgbDINFso2RlNWrGQb88fBZmLNBgFQ719/WWF8gEdWSTqgFje+tjHqd8R+bPZuEeUc4rcUbKyad85iARjYqkub/t42xpmJRHkLHVvuvUCexs7vwc2CRXtZOWxjLE1/7+U82/THEza74fulXfq4LtmWgt5Hjo3BKXEOBSkgtJmoiP1qy1s4/sx7y1ar9arfUq5pWpFC5XiIdyjVKBNp6RDPzE+h10QLTgmbHfDMOHNehNuDjQ8ls+k3DJW9VaNm7bYeuaWr5zPaugET9utKF3ZjlY+bzU7Wq+o1jT+/KIoc1m52punivAXG8/Z+ezzEsxRn12Olmi84NlAAZZyNbWO4ijOvoHI6P22LOYu126GaH9BHSzkXuSUZrN2KNdmvo1zhM9f02me0dibS/GK7DB8rSGeIDGliWcrxem5f61WAkXE2WbQful7D5Q5CPfLSmn7ed5mFV7xcYappST2/lzXqRt7nuKzddIu2KUwKUmBg5rueGeko48yuflyKTX9Gn/niLF9bcTaofErHolUnEx0MC/OerGa7OLOcAXm6LO7ANUNfZQk2adyTv3oHGmfcAZFPl9UzV0E6V8+AO7uUvp++1m5LXR7mFWdDNpqNEDfMf+cjn547J3ztuANgnCtcNu64A1tOuJN8yrBeBfxzhTkXm3fbrM8JB+iMdu9ePp0sh7R01jMwdnmo6p7run4AACAASURBVAZfDxXrjL7x7LlLA9lMh8tO2ZRBCqg9eOEglOo7lNJwsX4KXCqSKGCMcHEWYISz6WcM8Vk8LIBcXvFLoD/4zh2aOLDl1rWZUI2W3R6PLrVsy2mlODM3CKaf63+HZ9P/xs04M/izu2Tpjye6OHt6KxBF7oV53/RreQv3W3d46tJFu2kJrl6Tuem35i109Ux/xjTE637Oa9rG0GsCzt/036x8EZ6l4ybbnkGlL9rnw4BtTf+Qa2dv+inTQYJ9SRfh7ufe3TbTLsLdqlZAXSAohcrCIZ7Y7MxFOz0DpVaNfk2//UzcuvIWDOzZPgvGNcQf5e2trzi7VD2r17Aeo72oNKtGi5Uy0A3xVW1UtW4sqnDXJRUtYXwW7dwh/n6b4ctH2S+LXYxcwqfr09jGPO0L9kU41U7TtKJFu99Szp1xts3NGWem/BRSg3yUzXBGm8hqcXT2If6cVo3A+gqVvCOgqcxX6rltucIDWW3urM3TpS4PkRdZ7VV4cabbo3PmmVPZKZOC1GUnNl1qPzPrebB2k9W0K/MXGM7ouZnqYFWcjes5t5BPh7iD8/Tcl3J5WM21RbMv5livAoMqfNblIUn6PzPFB6O/9c04416EA2M7Za49+t1Vl4m0lHzKdG2h2A8iab9IrRpXyDjb5oO6ew5KcTbn2tL9XFfTrlzhsm40hfpKe7Hu8z77RfgZ7JT1Giortz36gWO9alOcOYgtwHnJatwz+vEEOaRt2woyzpL+LKTYFDZZbYk9umUvts0TM/m0qh3k08bZA4wucR07uiXQv4PBqvFyCBdnAUb0Tb8pE6lyH/xZOijOqroxKqWW4lK2McA52K+dKqButKBykyJI+eHb2K82NvvX7qCzMT9zT/Yr2zZmMsSb5PVT0CJt6aL9877AwzY7CgudYnpJ9bxn2kAtaPoLQ9NOuOu++19nct76SxTbEO/MW6Dv4sCWW4vRTk3/uS/CaWmwlp2czn4FOpsJY8bZcGmuGmVz03+Yqcm+ni3fy2xiHcmFZIh/mFWcMdhy19li69Uhs5CRiaQx04bMQsfFWe7PfjVdfBFuLPUMqDN6tp5T6RCvLk6b9gwX4edesp+B/arbaVWWISvpQqgH69X512M7o798VNZ6zrXFnxRvB3d+CqDsS9t2+F6ank1TUMbZkkwkNcSX/LyFrp5fiwpN67aPAvzZrzZyCuH2KjXXs8V+Z5MNqvAogrE/0RdKq2YW/nHouVdetOuW1LbMGmKzm14T2TnO4euHOmdslxWZZw4pkbOuc/v7NLg8DGQ1Tr5rn4l0AlU4t57p9QF8xRlZ20lrmt5zVz0Dw+c49/PzZ/SYfGqzAh3iDtazagQuZ+22OlmN7PEafYZ2X2yYzughh/T4Mpy+B64z2ud8HmZombUbN+4gjqOT2ClTz+4it/SxHxPFmeuMXjJDHxzqkdtu9zFXz4AlV3ji8pAbXR6G7+K5rBovNUPrr+HU0FU+VWOxR9cuzU2XTb09uoGg+PWjtO/EHLnENih7dN4M/fxe9lazZd3yyGonUJx9PVSompalOFOuLRPrVUbPrchqHpmFDDKJ6rkN9Wwin45ywt2Ks95O2aJ+XIpL5pAGDAgXZwFGFJ2N1BwLcNNbu3VNqMlmIo61QN71rBo3F7yJHxbt6zb9BUPlQ3lFtiF+kyaoDAqTfllsOeh8/dn3BW/RvssTpHE0WrRz3tuHbjG+dNH+tOcv5QCMFCoi9qtvJpKFzXK/NVvnHCxLvd42xiF775lVzfpWjfSZX2opN2fHcQroqr22bVHZbCY0JpvLqnFOcUYqL9vlT649XyR4Y16EA1P2Ky2TOMP/coUKPQ8eWGy5IYuGqzhL4gjbLOmfbxK4rBEpH85kheVSnPVDvNOWSGNir3URnl5miNefH2ud0bpVoyscmvLQbCzWTWpWhb90xA7z37+A/VrwhvheodI9Xz5KXt7C4y5H1bT4uiAT6a1Qgywnb2GTDaHgxGZ32UABqkfZF/5B5bYh+2Frtqs0Kc4AYvIOQ7yJSJQJvotLoNfSpRbta53RgxKXpzjTc4VnrRozcz0/71VOl+089FWo7IsKmzR2ZrUOirOhnlls9hPlCivFGSM/pVd1DAoVHpudMpFkNc2xUqNZ6fl9pucmpc+sFVTSsdkdZLU4RtPnCq9s1UjWbt8oWa2oW23RaiCraeqTj8qhUJmpaQ7hKkv97NHpTGIrzoRxB0CXiXSmuANgIIQAqp9I4sj5/RsUpKe3R5+qb3U0TWvMFdafTTZVG50jRbW+VeOl6nmUK7xiTdPzsKhbqwsToF2Ez7weskefI58C3Tnj2Imp3+GRK1zUrIvw+22GuotHkJBPH65VxtkSsppkhqbdMDD0E7y9WIL9ArKaree+7y4d52Ain2ZJhDhS+z3l3GCZ6SYuD+spSNXfm8bRarNsgBvhnQ8wwpSfAmjWbq5MpCTqwxtXDSrXDsNzNwmkOOAsjnyQj4Z4u8pnWMqpg2s7wzS1Nv3vBTZpbLeNSf2GeGKTbB3vUxRFo4POdGEwxe0mRXqKTKQ3rg3UoOoAVKPNY792Q7ynLN3W9A8h78fvAQ1Pc43sVZagbYfBjKNQOZdV48UyC9dq+DWrRtfg1L/flZv9Onfxxb0Ip98hAS2hXEHl9Pu9FGe7vG++fSHNONNtoADuoj3xYstxmmx9ATKFUuPO1zOg20yYbd0AUpCufBHe1/N585B0G5Q1M1QoqLxszEO8+rNKPXLwVJw9v5f2ep5YwUrAtY2hpeBLx4CVKlSeF6jCaYhnkVvSIX+oZ79y6tk7qNzeDwNq+WB6ph0M+SnAoAovq9Zao3qusCubYQlGeQsORdOpsbbLg253WvWXFWayWuHquS1ks+d3t1OBbgUrAdd69fYqRRShz0T6KBvWPENn6tPijLOSbQOlXt9AVuMqSAE5WY1jpfZgIavZFGvbjpnPdXkY2aOvrDi7VM+9GllN63FJGeBatL8XKhNvnnxqVpj02bgu8mlHnJOAziROz32/zfHy3inCmbnCgLJfXZpx9rwvkcQRSxWh5w+9MOMOrrIYceRr1dg64w6usnhki0ew1TPX2m2kOFvZqvHS9QysW9NDrrDZzeqYfGohq82QT8sup4ue83PIPWfotm3xdqiw4yjOdgO5RVTPuxxF3XgRwQh0vnNcW650slpPPnWf7bt8PXv0h10+yofTYSKfRpEixBK5xXbmTomTJrXpUtCsf71Jnc/IgPUQLs4CjCjqee9XYGDm9428RTGhB5Wv1SAQOwC4gEJl5bwF/eCvHNJ+aiYGn/UZ9qvl4uxl7x5EdYm8BGoplzhzDAA1dPSLdqaXcxRFeLxeLkv//FYwmTXHQ7xtWCLQEC9dtHOs1IbmaqbptyjO6DvxpZOzmxftXdNfN/2ieLUhnhRn52a/rm4bM1w+OutZuxQ7GBVn5ryFgf1qafr7RbvfEM+ydtMvwgXsV+XPvjTjrEAc8S7ANumQcfblvcTtVeq0bAU6f3bPvAWX7dLDLhM3/Vz2q37J4rIBXoq+ni2WJ2sgiaOerLBmDmnZDEO8jZ3Yq8It59qmu/CZgi6AeApSnzO65rHZtXOGk6NIoMF7iYpUchHeB3xXzbDQ5OYteNYzYB/iVT5cNav4tyrONGs3l0pVt2pcL+NM/b3bLHEqmk6NtTOR6JlaaeQWm2qX6tn0mjaZ5eJsX+Le8V32JatxbaDiOMLd1XBGHyqeywOdj6dQnHFsoOg10Xzz/F6w6xnwuDhjWDXqC80p6DM32qNXg2uLadmW94t2t23oUtB39+wZZ6tfhA+XFW6rxvEsNGvtZpuh393qDOoPKmGusNTl4aVXkJq/h1M8nsDa7fNeKUg5sz4RQgA++TSKIlx7L9rduZ8P23lyi9V6VXOgse26+u8iY/5biktlFtLvi6J1nZjGcQd2sq+KMLFYYRvskL8w7AZ94w4OVYOqadn1DKg904flXJni8QQ5pE8CBen0IhzgKs6WZZxZz2ib4qyaV5wBA5HWJfrIkqg/V86SEx7yzS6KcHEWYETheqBUwxBvapDSJB5nnK20lIuiCFdZgjhyK5pOjduVFSpjxmHX9JvYr50FxHthVhcNfszHFzecxlWXyEvAHeIBavop48wezKrj0yn82fcFm1kDDKxDrlXj0iHeJUkH5m1j7EO8+p5Q9oqpCcm0S5ben33l3MKLBZWvNcRrVo10+WhaPNKAR/lz1oyzuXpmNK6+1m6iIX6X9WHrfd4Cx5/9WtnGLLGZ+LxXF+GcCzDlz05DfMFiswNK1eTNfmUpzuZtY8q6dQ7xtsu54buoKUhXY7NfrulfO0MlTyb2eBaP+zyNu0wk87mWp7EhP6VC28K6aF/Efi0qXn6KNsQfepLOeazdPgsVZ4B6Ng55C+6fI6vGRrjY5DDI6Vn8xXBGmxVnw8WZbUmg+jN9iF/3fD43UQ04g52ywKqReu4hR2hOcWa2R395L3C/tb+HuWfP/Xqoe9KAC7oqnNtzq0ykbNFFeNu24oyzQ1n3vQSrnj1zSDn5Kbae22WPXtZDNp4puzjVXAfO5fJwdmu3tXtujUzCtWqkWWiefErnikVxtmLPzSGrjepZQFb7dH2ajDPOkp1e00EYdwD4k1s4KuyH3byd8sFyAdn3Go4zmlweirrpVcTrOTFdhny6SePeTm4tZUyW8iypoyjSyGpm9yITWU0yQ/vGHXAU+6TaetmXvQUwV3EGYNFlOD0PuBlnH2WNtm2FGWeJ2EoZUJ99bMn8BSgqopjt5w9Vg9ywi7jqFGcUW2TC2B59xYwzyiwM+WYXRbg4CzDiYAhBBXT2q+MmPo76w2hNq0ZAPeQuIWG9XpktlwuGeHp/aUC0BxvPWzXa1Cn0O3yCyrm2MYBazEkVZwDw2Pk5+0IN8cyMM01xVtUNXh1yfoLvxRnHBmqbJciT2Jpxxro4M7G3Yu0S91w2EwxbklNi7XqO4whJrBZhQzi0fYjn1PO84qzzGLfaxgyDnARvzMxCYJwbMAzxPPZr3bT48uGfifT0VrLyU9RrSsSZhYAaTH2t3VyLbTXEm9mv9mDjxroooHOkqpvh+bJa009LufMSW4D1FSqpbtVYt46MsyGH1PR6TOzXZ0ZmoS/7dV/UaFthPb/rQ7z7e/PpFOzXvWyIB1Qd0HvHzVsA5HbKrsxfwJGJZM04i/sh3nbm6rnCRdWspgbbXGgpp//Otc7oVOtziPhnzTirtFxhQ8YZYFaFc3puX7Ia9/MZ5ZBKeu5dvugi/PVQoaxbkYL0o2r6i2eulTLgX88se3SLy8O8nfL4gsZkH9fn7XW5wpFjSbgEl7J26+t5NXXKcPlIygBzrrD6s/S5zClUXGS1NI6sy/DBOlLq8qB+H1eh8lbUvUUdwHt/ybVlEVntjXcRDgxZf4D04sx/0e4ih5nIaoPizFzPrwfVR5lcB3TFWcmY6ZfgUuSWKIpwvUlXO58BypXqdouNvSdSVuqdPbrhs88NucIc61V9RycBfX8lPffLe6mRdM6kONsLyGqZyuSsmlbs8uA/Q7svwpsWeJ05/20CkU2vCndZNUajS9y1rBovFV8SMEa4OAswwq44i51LOaCzamx0q8b1LrWu0rhXf50TZ7VqdDAO6QD/2ttM2BQq802Cy24w9xzi9wXPBgroFGdaJhJ34fm4yxexX/dFjaJqWEN8HCsm00fZ9It9F3MYGNhF4qByC3uVEEVRZ3Npto2xWbvR98bUJIyb/pWtGi/U9K9t1QgMqgCubUxfzzPvta2eX95LxBGsz8Vce75I8CYY4mkxqDf9HGu3UylU+OzXeDTEcy7CATXE+3jIc2wdVFaFhc0+8/P9grHLUHGxX8tGr+d1l3I3m/NaNarfmSJPYpZ1kA/G9ngudmKEQ23OLAS6IX4mb2FVNrvgIvxOU01JFKQPJ2G/qveAcxmuW5bK2K/qPZDWNC/jzG7tZs0VrmqrnaP63YOFEceWyhdRpBjl3+LFWW/FVjPs6FOqZ5vizL5o59ij+1iv7guhy4Nvz73IBopfl7riTJJZOGScCXtuhsLrZqPsKudySOnztmUi9T23caYbckjXjDsAhp7sW7VqHOXEmchqRzO0lKym6tlG4NUt2CXYCzLOhrzrEh9ljTSOWCSKx12Gsm69ltiEp86qkYOrNBZnFgJLrN3c9sW6440OIgktqWf63lXN+RSkl1i032zS1YhqwDTjzJzjDKh6K1w9dxKjmDmfXzhktYU9N2uG1uuZ8upZM7T6uaWKszSOWPtVPYf05b3EdZ6wvt83eYpCU1Vz4cr8BbRLx1lCuSWSKO1ySCu7/X6mOasFq8ZvH+HiLMAIq+Ksk+M62a9HtjHrNv0XtY1Z26qxavrh2dQk0D//8u6nUHHlp6jfYc5rsOH1UAlsYwaPcRVUzvvePF7Pe5Nz8Vng5Qx0jJSy7n8nxzYmTWJs0ljc9HNsY4DOz9mqOJthy3X/jL43LoVKoSlU0rWtGs+8aKdnyFr1DAxNf+l4Dzn13GcamS7Ct/asgczy8za89UM8L+NMvZ7CysyfglQlS5p+rg0UMPZnfxawX3cLbGOceQudbcyUAXywDE/KIoVsY8xDZRRFvfWui5SxFFRPlzqj18paADoySUcQKiuG4qyyB5XnRsWZe8ncWwGJ65nYr+56vsoSXGWxqmeBDdQdZSItqOfnfZdZyMjK0y1LX/Yl8jRmvU5va7fKfskCDJY784qz2njubFItqNzFrtYyztYkq13s4qw/o9clq5EqIInNdvS9DVRJ9uhmcsu0Jtu2xQuDrLak55YozoaLM749+uP1fL/JhUhBqrk8cCy0CN4uD5X7IjyKopFab+7n5874ac9t6gNSzdq7Yiz9l+BSKtJhhl65npvWeVnRZ5xRz23JhJ4nq7lz93JtjpLgtaiQJ7EzFxcYuzx8GPKR50Cz77KaLln1DBAhRJZxBqjLQ3+rRobLwxz51ObykHFn6OEsKB3EyaWg7+klCOW3V+m65NN0TBCyXQoPLg/mc22T2RVntt1O79riO0MLXR76GZoVd0Dk02X1/LDLWW5em/7irJHVM5HVhOSWoq6d5O0HyzOtqBpsHC4Pzp47jkfOamtZNfbnc7BqvCjCxVmAEUpxZvN+rVEybuLHrJB1m/5LDPG351KcNa1zuUkHiJ0tN+R+TEFsORtyrWGRQGIbc7fN8PVQoW66QFfmJcanXY6nfSnOJiFIJOnA4M8uCUEF/KzdyNaDu2ifohCxX102E+6Q7aW4VJOw7bIS11WcjS/OTIMwh/2aJjGSOLKw2R02UH1unXCI7/3ZZWy5Q1kjingB948nujjjKEiBsW3Ml3f3QpNwsySo3NX0bzNUTYu3ifqlt4GaeR9JDbIvatSNK9g4Hlk1ru7PfiH2K4ed6YuRVaPDNiZPKW/BHlQ+rzgjgob5e0mZDlKFypugngGlIn3RhnjO0jOKok6h4j/Ek4KUox4cFGcNixREWJJDasv8BezWbnayWjxchFtUoSP264pWjeo1XZasdharRhebPYnRtuq7Ysp0MS3a3zvyoUvZnKe+ucI16yIcGGci2Zj5U3y6Xuby8FnQc2dJhDjq6nnPV6ptswRRtMAenXFGm6xXo2i+n95MXR4cMx1Z9dtIGUtx1b1PXILjqXC7esbZsNimZyPb5cFi1WhWnLnquftMPRbt3HoeWbtVNT8nfKG1W9u2oowz1euoPNEvH7Iz+tXXqtE5Q+fyjDOmawvNPeNL3JWtGi/Vc69JPtWtGh2EAqUma60WxLmBnNJfnFm+l/nCGZpjX7/LE2RJ1M3QfKvGu6sMcbRwhn4r8OmaV5dUG6Q4s+Ux66D3YM5O0YaycpPDBnv0OVW4O1e4cEUSpdFYcbaSa0vW7XouMUMHDAgXZwFGHKraeBgp79fG6f2aJVG/YF8zqBwAfnR/hR8/7lb7+0348YP6nd/dX63y9/dWahUvbwHQgo0F7NePssZ7WbsX7R1jXgrV9PMzztpWNaGHSsJ+VZlIXz0zkYYQVH6ToPJT3D7YOnyCjblD/P02twaV25t+R8bZpOlPuryuNfDd/RVur9KzN/1RFOHnHnf47m672u/IukV7X8/GvIVJPZsUKsam381+HZYK8kX7Lk9YC+wRW66zAOaw1+jCy3fRroZ4XmYhMAzxbduK2HK+QeWc3E+TtVtfz5amv89PsWYiRd1SrruYX6np/8HtBkkc4ceP69WVCT/3uMOPVjqfARlBiKz0DmVjZIzmaTLLRh8IGq4zWr5oH4Z4WSaSzaJuDp+us0XWqxIF6UZXqIjquRvivS7O3Et2wGzVaLZHp1xhjssD2aOvS1b70f0VfvxwmXqOI/VMWQO6lVpZt1YFoX5G26xXgeOLs2fm5c+SjDOOrRswKM7alshqzJ67yzjzzUSiZwGH3KIIIYlYcRbHEXZZIl60lxbFmI773by1GynK53qdaa6wkawWj63dVq3nO1XP584Jv9mkuN9mq83QURR1fY7m8mDMFR5nnNnJp6bMQnc9A3726BLrVUAp4CTk0z4TyXPR/vVQoWpameKsrPH1o0Lb8jILAbVo91KcsezRMxy03Er9ZwF7rvAwQ5syC4dc4bWtGqmefvYiZ/R2tXoGpj13Y3W+oX7YRggxKs4YWZq9a4tn3AGnpnVl80BWc9d0HEeL7ZQ/7yVxBwMxX6lvec+rZWQ1bs9tPqPnQPbopSOSSM8VXtMeHQC+u7tMzx0wIFxbBhhRVA12u/mvyFWaoKgaHFwPFO1wW9uf/X/6d38V5233Ff70d7f4P/7Rb+Fn7tZpEoi9UNaN0wqoV6gcSqOn+SadP+S/MAfRLI3EDQKgQnPlTX8pYr+Sn/PnfcG+xNJBB6ukSfgoa/Z7R/BZtPfqJAa75v/+/16O/rk946xr+g929qtu1bj2Rfjf/Us/j7/1575j2ZKcGv/bf/qvYLsi65aafvpMjBfh6VDPgNnTfJPNX5y9vLstUzaebLk3SX7KTs9E4tfzQ3eB7btofysUo5+dt9A1yvuiRtW0bPbrzSbBW6FYs5IcLVdGKDBckry8l/i5x/HPAual3lWa9N8bdybS+kP8j+63+J1/+NdXW3bb8F/9rT89OxSfCiqDaBicXEP8kLdgICaldvar0woqlS/ae8WZoKZ1xRmX3PKwMIdUKc649Txmv0ryUwCfTCT3RdXQ2xyf/y7F2UfFyBWOh89eDfHrndH/63/4V1a1QDXh137hE373t9fruXWymkvlQz3Q10NpqWd13k1rmsNmp9cjJau1bYu3gu/y8LBVpLPXQ4WPSmbtVjUtvh4qln3qFFJ7dFUHesYZN4fUp+cmMol7MffPXg9H//zguAgHtJ7blEPafxdbFIw8lyX4B3/tF/Dv/9U/udrfb0KaxPin/8VvrpqtNvQ5rriDcc9tywk39dx/5ke3ztcCeFg1ClxbiABLChV23MHCXGH6OU5sATDYoQ0ZpOvVM6DORNeZNZDVSnx3PzwHe5eHmQsLyjx3ztBkpV27bUOX4pd/dLfqbsqG//7v/HnUns4/HIytGlunVWNB9ugWJeCXmZ7sy3vZW4zb/n5gcAXiQurycL/N1AxdSXvubLHi7Bd/cMP6s1e94kzV9C98n/dzNHeI7dEZri33u4G4e/TzVWPcq9CzKYKdUKpmuhZ106Jp16tnAPjf/7PfWHU3FeBGUJwFGMFp+l8PldsGqmnRtu3qVo03m/QiIagAVm1Meo/7pkXV2PMWROzXiRUUJz8FGDIdpNgXFUuSrr+G571ccQb4y9IHxRm/6T9UDXsBQlBsudMHldNrMCnO4mg+T2uqODMN8XRhW3UKFRsTeynSJMb3bs6/ZAfU8LamzYTKRBoUZ2aF34T9alKoJGZ/9jXZr9wh/iZPEUddPVuUNlPcblKkCzKRaIjnW6+qYYyeA5KLcEBZb0mgrBp5NhNTRrtbcRY72ezq38V9lg/9/2vhZ+6uzs5mB1S/wv0sfZCnsaasbx0q/NjJfs3T2GilfJ0nzkHRR6FCVqAScsvLe9l/D9mKs92yHNLnfSmwgRqUAZLMQnoP9h45pK76SZMYt5vUbBtjskdPB8WZ9SI8HVweqpXJavfbbDV7NRuiKFq159aV9RXDehWw99yDVeO4puk74Mw4S+XWqx9lg6aV1TOg6su2TJqCztZnT1X4875U9kPMS5OrLMGhbPCyLxBFYP/czSYV5wqze26TtVvVIDfWM9floSNONk33XVwzszBhX1ycGp+u81WfVVmXt+6MOzhyeTj+/JJYKdjmzmhlCeywaux7bllN7yVkta0+Q9fsnpuUn0+eGWf0c1zXFoo76J+FgrgDaT0DTJeHPod06vJgjjsAVC/ucnmgXOFKu8Rdy+UBWHc3ZcMuT3HrQaTgQndVKBt3ZAx9V8z26Imh5y6cz0Ry3vEhnwJCl4f3QrNq5NspL804k8SXAKpWJC4P9B5IM844Cq+erDYzd9ic1fSemxN34FIznwJr76YC3AgXZwFGFA72KwB8+aisS5zBZqJdXaHyrWJk1Vi3VjY7fRZfPio3+7U2sV/dVo1NCxGbqGla7ItaZBsDaIozadPvy5bbF4gjsJmzdLC+MOT8Onb5mkN8hn1RH7EhiZkzn8HRBRu7hvh0bDPhso0MmIfKRGr6Id5oG5MM9QyYGWYmxRmn6fe/OKvYWRhxHOGuW7RL8haiKMLjde5/cbbn20ABQ9P/B18/APCH+N2aNhMGttygODPnkPb1bHl+pkmEsnEzsQPMSLWhuWqavu+Zw6bPOLMElacm2xh3PQPEsPVkvwoyVHwUZ4/XyzPOJDZQAHpVOPd8JgawPIeUp/AyW7uZLfKGvAU7wzYdKc7sTOyAeYyV9fZFq35Gm/rUjUGh8sLsuX3IapL8FGDoXens42ciDS4PPlA2UBlbqa1U4YrNfrtJ2T+3yB7dUdP3W7NVo4t8tkevtgAAIABJREFU+sWxaB9yhSnjLNSzD6aKM5M9uj5DAxay2owqvKwbvB4qlvUq/XkJXg81u+e+6y6U1RnNJ5/eduqapYozmWtLI84J3+UpPsphhuKgblpn5i8wJu7qGBRn5poeem6HtZuWcbZWrvC3DFLW102LtoX1uZinsTZD8+sZoJxw93fSxx6dzqOdd8/NV4X7ztBt26qccMFFODAozrjOT/Rck9uju+t5kybY5clRPVe1IheZ6pkyz10Zemkyruc1VeEBl0f4dAOMsLFft70/e2ldFKRag7i2P/u3ipFVo5P5QAqV0vjZ5Qb26wtTcebT9EuZNfqyWBpUDvgHG39+U4tJ0RDf5afcbFL29/tmk8ol6ZU91Jpwr1l0jH/ezMwh6TcFG5v+HDX457Bq/JbRWzU6BidiJ9qCyoF5xVnd2Se5M87oM5Ut2l8FmYXAoISU1DOgLr2W1DMgUJx1z8bf/6Jsl7hN/413JpKA/WoY4s3klgRf38k2xs7GLOu2twILZ7QcurK+rOzLzSyJsS9q1E1rXcrNXZx9YaqmzmHV+OCRtwB0GWd7v0wkGuIlClJAqeuf94XA1k39t3hdhDPIJA+7eVW47VJsmydoWsXItdezUla0bav+vnBGiyGzauwUKu9mq0ZTxhm/5/ZfyrHruXsNdPZxyWqnsHbjLtkByhWuu4Um/+euF7g8uBZhD7tMZTtNPqOD4yIcUN8bW1YwESWVtfe6ri3fMo4tqR2uLV1tXuXmmp6STyX1DEBsv/omsGrslc17Wc+tMpEy/4twqWtLqqxXuXmPhP6MLvg13X/2DoWXTtzVcXD23LFzhgYUMaOotO9iIKCKkaWUzexW+eRJ3NfzVnpxxlRN6XbtXLx2vRy3dyZl80fv8sAlt/jP0F8+KtRNK7JSBtC7UUgVZ37kU3eP+9BdOurg1POhrFUkkUMgouqZt6ML+MlG+HQDjLDnLXRsuXeXVSM1/S0rzyXgGPpFlbK7tDcIgPpcXEP8cd4CzyqBfr8kM0YSggoM7Nc//HqwMkKmWGrVqGyg+PYCuj+7xArs2iPYeAgmdli7aaHQOg5VbfFyHuoZMA8W9NlXdbt6ZuG3jIysGhlWHZnmvW5myyVH9fj1o0Tb8qxXgfm8Bhsk+SmAzpZzZwzoeLzOvG0mesWZUKHyey8yxRkpVKSLOc6ZOJAI5m1jzIu5GF9oiLdaByrbmKoJF2e+oPe3rFuUDkYzp543XSbD9HLpec9nv0rr+dUjb+G9rHtrIkmGSt20PQNY+hrLuhUrSF8PFd6KWlzPr9J6Zp6JD9tju8q2ba326JteCVEy7NGb3hEg1LMcI6tGB7kh0z4XU39l7LkFZDXfepa6PPz+F1KcnY+sxr0Ip9dFLg+injv3Iavx7dEBHD3TeK4tpf0iXMugrRyWZAFmkIWtq88ZFKR2stomjY/jDpgZpPSZHjwuwyVktTstE0lCVnvc5YtcWwA+WW2TJWhb4A+7jMA1F+2F4CIcMNuj26zd+hnaoVKugsvDIkwvwl321UM9y1weXpgEjdzjjJbW81Rxxr1wI9cWH7Lak/AinF4T9RFSe3SpE9OBuVe+3+Vm1xaby0PFsEfv6znM0D8NCJ9ugBF22xj+EA+gW8zZL30C5kE5UmXX9FvZ7NoQ785b8GPLbbRBjotXDxsoAPj9r7Ih/jpPkCWRtxWUxAYKUE2CCiovhBdnqZz96rBmI5hsJg4WxdlVOh4WnbYxTbN6ZuG3jDyJezY7YLfqyJKY2fRP8lOYDE5d0SrB26GWNf27vG/6ufkpgBri/dmvZfd38GqTlv/03OEy2mmIlyzmekWI4xLxKkuwSeOjIZ7T9LtsoIDB2q0IbDlvDAQhtxKXVc+ZwU6ZbRvjpzjbZok1BF1Hr1ARntFLFCp0gc5lpVOvMtQz7+fiOMIu9yC3VHZLF8L9jOKs6iyHjGe0Zu3mso0pO2ILENjsPtDruagbuz1692e/WDPOhqw9Hc/7EnkSG1nww+tRitZGYI/+dvBzefi9buHFJbc87JaR1Z46q0Yu6MLihfksJFwvyThzvBf0Hkwvwzk54V8+HORTbf4Lri3+IEVI2Tl3mBQqmVbPgMOq8Uhxpj5/V9+oK1oleBUoztTr8CSrLXR5SOMIt8zXSa/r93wX7YIzmuuq0NfzEVnNlSucaDO0zYkpQlkFa7clyJOp9aqr5/a0atwXrOx6X5cHLlENULXx9aPCvlBKNW6v/rjLUNatmDgCDBbMUsUZ1TP3jPaZoQHKCeeQ1Y7tlPt6tuQKl3WL99Lu8pAm0SgnfM2Ms4DLIzytA4ywsl9pseO47U81xVlo+v0wsmqsWmt+Sm+7VjXWBoH+jA4K6XY15j5WjXuhVeMmTbDNEvwB2cZIMpF2x2xuLtQQL7g4y4YhXnJxRsHGEgYQ12bCZO12qBpjw58mMdJ4UCmYmtAh+yNkFi5B2lkv9U2/Y9FOn4skb6FnszMyCwG/jDNufgpAOSBFl+0kuDi79q/nZ4/MQgD9c0c6xO8Fi7mqW4JyGOQPu2y2ngGL4ixNWIx5snYblgqhpqWgi++PslZ5C5aL8DwdnrNGhYpBBapsY5gZZ+KgctlFeJ+JJLR2+7RAFe6rIJXWM6BqWlLPgMCq0TbEW5ZygLvnpv7wvbOwsi2UAuah99EVIxie/uyV4bPve+56ao9e4H6XzebOzv182Uh6bnJ5kJHVhp6bn6WUxNGCi7NSRFYjFvjLnp9ZCPiR1QqmIuRes5Yf/bxNcZYO9eyydQO6XOGqDUs5T1AmUulQnCVxhChSn0scmT/7TZqYyWqO76WuUOeibVVOOLeeAVXTPvboj9fH/SYXT3ul0HE90wj6Gb1JY/br7BVnIqtGHjnsOk+QxpE548yYKzzMYbY+II3jLleYFu1hLyZF2s0tFeM9HM3QRvLpsWtL07RsggZZ3kvg49oCAP/s64HdbwPDpZdPTT8LFaS+PfcmjZHEEfYedsosl4dddnQR7iafDr2dqwcstH1OuAj/thE+3YBZuNjw+kPbZTMGoF8Sh4szOUZWjY3Da1dr8m3qFGCG/fqumDWuhrd/PRW/SXgV5i0A6qAjubdEobLEz/mzMG/hKlPDkw/7tW2B95LfJAxB5VxrN37GGTA0PHkSG78D9PNVyCxcBFKEkG2M7XPJRzVtVpEeqVPIetVl1Wi4SHdBypYjj/FDWRsXjHP4tMvxtC9FbHsC1bMksxBQNhNpHOGaGcR+7cGWk9g6PGxz76Zf/Q77GR1sJpaBzmRaVtvIDfr7a6zn7Lgm27bFy3vBOmd82a+Si3BiZf/+lw/rgnGKJXbKn4VDfJaoYby3jRGc0SqHVD7Esy/C38sRcaavZ6PiTKtn2/dr8l3ksHEDxhh67tbplMGqZwtZjcVm114PF69Cxdk2S5AnsWbVKCOr+bg8tG0rzji70shqnPeOcONhj146FuWE3h59umivzTnhm9H57L6YLZtgj74ElIlUOS5PVK6w+ndXWWKdhebqGVgnJ/xQKftd6QxNWUPcega6Gdr3IvytwKdrSdzB0HNLZ2hAqDir7T0zIYqi2RzSgkluARwzXRp3CpVg1eiLLIlRN63TPnP671wKUr0n+3qo0LS8y58sieRktYPsInzIIf0Q78QAPztlOtfZ9ugTq0ZurnAUqXlbrDhjujzMkU+JyORShQNu8qmuOAtn9LeN8OkGzIJsY1xWjYD7gQKg9+QNDYIcQzi0avrttjGMBiExXJxxQ1B79qxHxplQli7NWwA6f3aPpr9tW5VxJmG/pgk+yob93hFoIS9btPPYLMTCnbWNsbyPVNN2STpdnKmmPzDl/EDsNA7jUL8ot+XfTPMWyHrV9b30Wco1TYu3osbO059dqjirm7bPUpLgaS/LT+mtGr984J5BIiD0QeWCRTsRD1j+7Ns5xZnd5547xPe2MSETyRt0WUJEiMxhvUowKlRmzuh9UaOsW/aiXcx+PVTsPCRgnIlkWzBOQQO4z6K9z1uQLNrTWJy3AMDLqpFLJrnfZqibsXVOX8+mHNKUN8RTf9h/F0M9i9FnuTYNisphjz66OLMrzrx7bnLuEOUKy8hqURThzrPn/nSdeVmvfj1UqJrWS3H2LM4VTvFe1n32HwdslwejtVttXNJv0hj0yLQTLYbPXmWchXr2wTQTyabcy7WLMxM22XEm0jOz58565w6PuAPhGf287+zRhQqVpze/TKTPQteWq0nPzcXOY4YeyKfuXuV+VhXekVEMNbgRnNH6d9HWLwbMg95f6nPsri3DvzP1V3OE8hdmZiG9Hh/rVWnGGUA9N/87QzOwz2U4neuPzMtwfYYG5C4PXj03gxx2tz0mq32UfPKp7bI9nZBPgyr820Z4WgfM4uBkszOXcl1DQHL6MMTLoRhwUZ+3YA2dTfUhfr5BiKJo1trt5b1kMbJpSShhy70JM84AujgjGyhJk5B5MWveihpF3QjZcvEQVO7FlpPYTPDYLLebFHE0XJwQiqrGxvKz1PRbG4R4GPi47PqAY1A9c/zZ6fmap7FRObVJkxnFGc82xst6tRtWZAqVDE0L/OFrIWv6u7ryafqV4syH/XrwrGePIZ7xbLvvmMM6RGe0VaXc2cYEq0ZvUJ9DKh/rUo5xRs8pzp6ZGaTA8HyRQJyf0g/xB9GS/aE7X30W7XSuS1Xh1EdIFCrXm1TMfi2YrgpzdspuxRm/ngHtuxisGsWgi7Kicmczs+rZpDjj2kAtyRWWqMJ3Ws8tOKMfPHNI6RnAzRIF1AXyH70WqJtWplDJydrt9Krwh56sdqxQMZGdoijq/50rsxBQl7jBqtEfvVUjqXysdsrdxZnlOZsnxxdnL/sCUQTcOqzBc4+eW3oRDgD32xxf3kscSqE9+i5H1bT46pGJJFaQpkPPzVWnAJpVo4/ijKVQmXd5yJLIOIdJFu1EnExi898XYAadyUPPzd2LmYkMwPgy+5mZWUi/Y+2Ms0FxJuu5l+QKf96rzEJ+zIoihFAfIZ2jpTmkBTMy5GGbo6ia/rKMfpZe8xy4e+4sVmpmVw8f8G0gfLoBs+gl6Qw2u906kIb4avT/B8jQW7sx8xYAs50AAGySeNafnbNY8lm0S21jAHVxRj8nbRJ8vJyfPJdyVWcXIGXWAH5Nv6tJiONoVqFiy1sAdMWZ+/tVhczCRRjquVMRMp6h1iE+na9nwM34SuIIcbT+EE9KyNdDJVacAX7Wbs/70muIfz1UQgWpv1Ujy9ptrp4dTb/ECirYTCzDYI/n7nM41m55Zw2mL+Z661VuxpnYelWenwJ09SwgttxuUqSemUiUw3p7xX/uXGWD/Ys4h9TD2o2lOOuWCfpluMR61TrET3ruYNUoh67CdvXcOaeeDYqzl33BrmfA0+VBWNNUKxKFyifPXOGn7kyTktV86tmP3OImNgG6y8MxucXec6v3mOPaEnLCl2GwanTPUfTvbH2qKVf47ipD4vi+DHEHPjO0rJ6LjnDro1B59lGFS11bsqHnlmYWAsIZWuDyMNdzH5hxB+p32MiQUadQsZMyAsw46nMW2inPRRZwrVfpd/i4PPgoztQMza9ncmh48sw4e7zmZxYSIeT1UCkSgeC/79rbHp1zEU4RJkOfcnAozsYKUvf3K7g8/HQgfLoBs+gl6YuH+HFQOYddH3CMwdrNzjjkNAiAqekvWMwaPQydCz+23NCsmJbDc/h0rawapZlIxGaX2cYMr0u6lAOENhOM0GGCYssdN/2295EzxOuXLFx2fcAxjqwaLYM2fd7Wep7LW3gv1JKa8RlJF+0+F+EPvvW8hC33VnjXs0SdksQRtpnM2q2vZ64/+9QGqrSz2yTWbipvL1g1+iKf9jmOpQnBZe2m1+SLZIifyTx0QTrE60suSd5CFEV4vPazU1Y2UJmIob3xPKN9bGNULjDvIhwYL9oPFZ/9aq3no+9iqGcpeqvGrs9Jbdar2uctsV4F+Iqz3KfnLips0lhkp62feVJyyxLrVSlZjcC5dCQMdsqyM9qW+UtI4gh3V+mMy4Nj0c5weSBlVFk3KINVozcUQWiw07JdbtEz03aubdJk1npVoiD1uwiXK1QAufUqIHd5aNsWT3tZxpl+PksUpMMMLckJ5++h7ucykZjkU8CtIiWrxnA++6G/rOiV9cvIanNWjb3LAzfjzMOqUXYRPpx3piiWOdxepUjiyH+GFpzPwHDhdL+V9eo+OaQFk6w213O7FWca+dShIAV481/ATz7CEztgFk7bGOFNPMmpsyBJ98Jg7SZgv1oO1s3cxRkzbyH3afqLGlGkAsi58G36H3c5mhb48iEb5GmRJ7GN0RkpEpsJGn72All6UdtrUodSnB3bTHDYry6GetpZu1VMiXzAMfJ04nFvtYRxs1832Yz16p5vH5onskX73jOzkCAb4v2CjWmIl2Wc6Us5/hAPkM2E3HqVowh52OX4KJs+KxQYLCrMtjG6tZv9YrasG+0iL9S0FEd9zkLF2WAbM3zeEqvGPPGwjSlkVo268ktyEQ6oy3AfO2WpDRQwnNE3TBIB4WaTiOoZkLBf1X+Dvmh3W6/yFKS54LsYMI8kjhB1BKHKcRk6dnng26Mfqhr7oha6PPDJYG9C61VgCVktw9NenonkQ1bTX5cPWU1qj849Dx9mVHdF1VidP1guD6nm8lAFspovsiRGUassV9dl6JBxZn6v1Qw9/i69vPNcW3xyhcnC7BzkU19rty8fFeqm9XJ5AGT1fJXFiCPhDN0rznjWbnMX4TYlLpespvY5LbtfCDjGUZ/jcGQhGMktc2Q1yizk9NwzcQk2tG2LfVH717NAcRbHER53maedcsnONyPQc1M8Q+c+GWe8M5E+wzl7dJazGkMgwrENDfjJR/h0A2bRs18ND+fAfj0vems3R97CiP1qOViVtdtwyFd1g68fFVuSDsiH+F2WiNgnvot2OuSlizm6ODuH4uy6DzYWDPESmwlDJpJdcUZDvP0zyjVrt1DPfkjjeKzyYbDlrPU8k7fAZbMDw+UJF6Q424kyzjS2nMcFulSh8nqoUNatLONMqw/JBTqgGO1eGWfMi3AA+KIv2kvHEM+1aowjVI2q5zSO2JYcAQOmjEPb4DS6ODN8fr21m+bHz7VeVb8j6s8LLt4ONXaCi3BgqE1JPdPPPXkoVD57XJz5DvE7nyGey36ds43plrCmmubaxkx77pCJJEcURchitWivGrvijGPVCBzbo78IMwsBuZ2yZCkHjBeEUrJa3bT48iGrFy+ymva6RBlnnvboXJeU+2026/JAtrtzGFweLPXczUxlo4hWoZ79QOTTivEeDvbodvLpXM99z3Jt6bKifVxbJJlIvjP0zo+s5qcg9XN5iKII17ksh1SScUa2tfoz91DVLPIp4I4wqeqQWbgER7tFq4JU34vZ+6vRGd3bo3Muw2W5wocuP1VyRudpjF23O5IozgB1xvpmnMl7bvXaJPUMLMg4Y7k8EFntuOdm5YQzZjr6LobL8G8b4dMNmIVLcaYv4Dns6j77I1g1ekG3dlsqSQdUk6A37TTwithywqZfPsTri3YPtpxw0U5WMxJZ+tWZh/gkjpz++YAhE8mlOEvdVo2AalgpZDtcnPmhr+euhjj2q1LF2fO+YKsg8yQWLdrfPKwafdmvN5sUWRKJraBoMe9rAyXJWwDkbDkiHsj82XWbCcEQ77KNqYJtzBIMjMOuz2FYrwLuoPLDXFA5o6alQeVt23aKM9kwTjUtOZ8BRU7xYr/uCzn7VbONkeB6k2Jf1CLL56JueTZQc7YxTsWZriC11HM87rnDEO8HWrQXlX3RPu65LQqVyRlN1qucRbuPy8Proe6XbFyMyWrrK1Q+vxW9zSEXV56qcN8cUm79PBis3axZ06yMM5q32k5lHurZB0Q+LevWmVlHi1gX+fTY5aFgzdBRFPXPFy6GuAN+Td/51rNnrvBnL/KpVs+CGRqQ2ynLXB5mckhrHvkUcF+Gh8zCZZjuFtlkNWOu8LHi7HlfYpcnrLxPer5wMVyE+/bcsp9b5PIgqGdg6LnFM/QmESnC21bV0EYyQ88qzpa5PKTT+Y9xkRfwk4vwxA6YxaA4m384x3HUNx9Wf3Y63Eq6iQ8PFB9kzMsKfSBwK840GygB85MOBalCZYltjI+1m5TR/tQN8beCIX7jaTPhzX5dYBvDZcs5L87iODT9C5GRVWPjDp/nsF/zJEHVtKi1Ja9iv3IVZ8IhfqFtjKSeoyjC48z32QU/Bam/VePNxo/9yvNn78La92PFmT2onE9uKZs2BJUvQD7pc+xWesN7bOqv5hRnL/sSeRqzFmCZ1Hq1qNG2snoG/If4x2t5PQMq3FxSz4C/4owuESUMWO6i/SpLcJXFs1aNS4d4shXkfBcDzMhSpQqoHLlSIza79YyOvfNTfMlqZ++5xWd0icddLlI5e7s8eNRzIbBGvN+OXR6aRl102TPOuhna8mcoV7hqGlR1y1r6Bxwj05wyXO8hh6w2dW0BhC4PwkU7uZP4ktUkCpU7ykQS1jOd6TJ7dL96BuSLdlHPPbNoP5S8uAPA7SJC818gtvhhulvkRMZkiZl43PfckzOaq5oiMiwXPpmFwFAjEqtGQDkxTYkdLjRNi+f3Upxx5m3VKJyh66ZF2wrrWWKPLo0kCj33TwXCpxswi17CurDpp4UwJ8AzwIzeqtFxeUJZCoBLcTZerD0LvJzpUJAFG8sVZw+eTX9vM+GxaH8QhpmOhniJ4qy3apRZu0mGePKb73/e4c9OjZhrqMyTqA/ZDot2P2TxuJ5tiyNapNqZy8dsuZe9rOmXsdnlirOrLGY9m+bw6VrOlvvsMcQncdR/p+U2E4lsyS7IFBuG+OE9KGpHfopW63Zyi17P4Xz2wbFVoyU/haU4U5/d6Izu6pmzZJZmnA1sdukZrWpLahvzaZfjaV+K1Fxt23plnPW2MR5sdmDFTKTt+PLQzX7l2cZQjx2sGpchJavG2m6nNa5nW3+VHLHZAaZVY/c7pJlI4nruXos6B9dXqDy9FfjkqSDNkkikqKNeRWSPzrhkISjF2fh8Bux9myhXuB7slAPkyJIIRa0uH117iJxxcTbNCW+alp1xpl6PdNEuP6N9c8KJrCZ1eVjq2rI2Wa2o+XEH9Fp0azeX4mxQkJqzh+n3V41yHAnnsx+oz+LEwNBn5rJeBY4VZxxFOP1+ifWqzwwNLFCcebg8fKXMQiFZbePZc9/kKYqqYc8u9PzkuDxsswR5EntnnLlmaEC3DQ1z9LeM8OkGzKJ/oDCafs5NPC0fglWjH0ZWjY6mr2/6bezXNB6z2X3Yr6IhvhZZTAD+QaiD4kx+cSaWpHc1EEfq0OciTZRygMJEOZDaxgDA14+xzQSHLef6HalmeRIW7X7IkhhNC3yUdutV9WfJNsbOZgcGwkPbdkM8s3GVLtr3Hmy5KIq8rd0ed7nXUg6QDfHAQms3wVKuzziTWLu9j5t+u+KMv2gPCtJloBrt+xyGbUwUua2wD+U4E0nGZpedz4B8iL/zredrlYn0VZCJ9PVQoWpaD8WZXz3TeyFVnHFraGrt5rJqzJK4Z0vbnhnp5LsYGO1+oMySQmSPblOaGjLOGNarQ67weRRnV8I57VOfiSRctC/IT7lnkggI1Kvs13J52OZ4eR/IAD2bnaEKdz0zsjhCUVHGdahnHwxWje7LioHgZXdt0YktXz8qtC3PepVej4h8WlTI01j0+d9s0v7MkCpUPl1n8hmaMs4El+FXnq4tANkpy8lqPHt0ykQSKM5SXj0PcQeh5/bFdLfIsVM2OTwAmh2yTj5951mvqp+XubbsPVxbAP2MFro8dBlnbcufCwbrVSG5xbPnHs5o3hwtyQmPogj3u2zi8uDKOBv+OYesNuy5w2X4t4zwxA6YBa/p7y7OODfxDDl1gBljq0ZXsLG7UZ42/S89+5U/xEuDjSWhxuq1+GUi7XLFLJGyaz6/FeIlO72ue6FSDYA42LioZEs5YGA1N50Vm9WfPXVfhANd09+x5ULT7wdqrN7LmlHPPNsYYKjJt6JG1bTsjDNfttxOyHqjIYTjGa/j8TqTK848gsqB4bkpVqh41DMgyzh72Y9tJjgqRMBBbkm1syU0/F6gz/CdYdWhW6+aFr9zmUbP7/zMwiyJUU+sW20gNrs0E4m+l+J67n5OckbTUo7To+joz2hhPe9ymZ1y09ud8lXhc7YxtvdycHmwKKAE38UAM7KUVOF2ezxurvA0E4nUSTyXB/V5T63hbHg7+JDVVG3ZFoxzeOgWaz6LdvH5rPXcEmyzBFEks0eX9txNC7x2C1GXghTg26NnadzXc7Bq9ENGWa4Me7x+0W5VqCSomxZVd0YPGaRcslrkMUPL6lInq0nP6IedXKHyeV8gjSPRhb1y3Bh+pwS7PBUpSAeyGi8nHJhYNdYNctv5zK3nzjY0ZBb6I/PpuW3zUve5jiNMZGQ1H9cW6Rnd99we5NOqafFVcP59Xthzc+cVAr0Xr8zL8GGG5pJbsrGC1DGDj6xXGT1g6Ll/OhA+3YBZ8Jp+N7umf6BQaGJ4oHiBVD5V0zhlwJxF+9Rmos84YzT9NMRL2a/eXs5pLGKWRlGk/JzFGWeliCkH+DNrAJ9gY/5iu89E6hZz1NDZFWc8tlyeqOyPsglWjb7IteciZ2kC2FngvUKlq2nJUg6gi3mZbcwuT8SXxUsUZ1J/9ud9Kc4sBIYByoctJ61ngHcmEnP4edL0c4gtUQSjrz+gbCWqJijOlmDa51it3VhDvMk2hp9ZCPDP6OW2MXLFGSCzdnvq6v987FeZnXLZuM9YHQ+7bHQRXjjYrwBvMZce9dzhjPYBLTerxm6Pl8RDboqrpkdktfcScQTcMmpucHmQ9dw7IVnNV3F2u0mRemQiPe1Lb5cHaT3HcYRdlogX7ZKLcGAgt/RWjdaLcLJqdJDV4jjU80JQlmvFUJyxXB6hqJjDAAAgAElEQVQm5BaJ9SowXMxzoS7CZfUM+J/RnzxyhZ871xbpvO7r8nCzScQ54YB/xpmKOzjBRXhHhK7qkHHmC3pm9s9FqyqcX89HGWcSlwchsQU4o+KsO2clezGqf3nG2TLFGbemJfUMzLs8RJH5TNVr3b7n5n8XA37yET7dgFmw2K8Ma7feNobhQxxgRt5bNdrzFgCuQiWZDSq/Yxx01GBIg42lDcLtVYYokns5A2rR7sOW87aBEjYWgHzR7goa13E/yUQiW05OPbus49LukiVYNfqDFnFvRe22jREozoaLM771KuBnG+MzxNMQ4uPP/rQvRJlIygZKrgTtg42l/uybBG9FzX6NJeMymxBFER6246b/UNWspVyW2IkHaRKhblocKjcpI2AeR30Ow9pNOsRL8lPomcGtaf+MM8963sntlJ+WKkiF7NcbYcYZXYSz7ZS3+egi/HAihYp+trj+bIAZaRzhUDVdz+1ehAL2/mpqj/68L9lOBVKrxrZt8VbIrRp9z2dFVpPZKbdti6e9R8ZZrwhfv+eW2aN3i8nujD4wFGJsq8Yk6us55IT7YXBt4dij88ktVNM0Q69lj/7qYb0K+GciPV77ZJzJXVuA4X2+E5LcxDN0xV+00/7heWLtxqlnlwImjfm2oQHz6O3xBLnCrHruviNt2+JlX/YqbBfy1DOzUOzE1OUKe1ivAjKXB1Kcifdini4PNH+wyWrCi7P7bT6ZodX5bpqPoyjqvxc2wgr1h33PHZxbvmmEDixgFq68BWC8mDNhYGIHq8Yl0Jt+pyKIqVCZstnvrlKrMmF4LbKlHEB5C7LGPYkj3G5ScYMAdIt2wVKubVs87wvxMN4v2T0UZzebRGTtJrFGpIUm+Tkfav4Qz7ExKaoGdchb8AZdTr4XNWtpAvBsJqim+/wU5vc5F7JfXw+11xB/58uW2+VoWuDLB3+Q97GBAk7gz15K/dl5Z+L9LjvOODtRPQPddzE0/F7Ip32O5X2UZBZOz2j2Uo7ILUwG7KvnxVmvCve4CAcgsl/1H+LPxH6tZPUszTgDhktA25mRp9OeO5zRPsjTGB90+XECstpUcabY7PzzGeBfnL2XNZr2fPUMqMtwST1/+ahQN+2ijDMpbjYp2wYKUJfhEgUpMFj2DYqzUyhUYu1sCfXsgyyJ0Xa5wq73UEJWGxRnncuDyB5dtmhfpjiTntEZnvayTCQf1xZAvbbbTeokKExxs5HZo9PFBif6IYkj3F1leNmPXR5Y9ez4+0nNHFwe/HG8W2SQ1azWq+Oe+72sUdSN2KqRWy++Lg93vhfhPmS1PWUWnjlXWHhxJnJ5mNiju54FHIHIoDgLPfdPA8KnGzAL8vm1PVSGId5uAwUMQZhBlu6HrFecue3xuLL0aVA539aNlnK8BqFuWryXfjYTD7v8LIqz10OFsm7lkvSuEeMqAXSoYGO+bUxZ2xflOqhhGdiv3RDPySx0fb/iuK/nsGj3A9XQnmPVyFzKAcNzmz53buMqZb/uD5XYmx0YVB9ya7eOLSdctPtenG2zRJwJMQQbC5t+gRXUNOOMZ+vGOy8438WAeej1DNhVAbRUsfVWaRIjiaO+nj/KGu9lzV60DwoV3hlN55DYqrFXqMi+N7SMkFk1+uUtUB1IMwv7IZ65aO/Zr8wz+m6b4VA1/eXMobONsdkCcqzd6Of3wdptEbJk6HNcC12O/eqx4qxgOTzQawGAglnPpJKUktWyJMZ1nniR1R52GZ4EChVfBekSstr1JmWfzwBY8xZhmolEn7X9Ipx3cZYmkTZDh3r2wajndhBEh0W7pZ6TseKMFrLc76XYqrHwnaH97FcfdznqpsWXD0Em0t6/55aqUwBVz4eq6XPmXPCydhMs2jlkcvXvIxR9Zn3ouX1APRCnz/FxeZDP0Or3V0zHEXrd/i4P8noGpDN0iSyJxNmKgypcnhMO8F0eiHggyhXej10ebJmFgCySaJj/whn9LSM8sQNmwVKc0U28dQFEhxvJqcNXzgdZMgSVO4f41N0kbNJ4bNW4L9hWRpTpwG36+wZBKEkH1EEnVacAatEus4Equ587H/v1Opez5aR5C8/TvAVLszUs5ThDvNuSLMCMTHsuuposbj0Dw3O7DyoX+bPzmaWvHvkpwALbGGLLCRftfuzX2HMpJ8xEEtjGAGpgmmaccdivznruyS11qGdPTPsc2xDPYbMDY1X4F+lSTmjtRgzPnXDR7pu3cLNJkSWRyArq81vRscBlzx3fRfuuWxZw2a+Fx1IOGJ/RrjzXQUVqfr+HIT703EuQxkOfc5ozOjnKOJNar3IVpL7Wq4B/z/3pWkZWoz8rVZD6ZpAC6ozmLuUAdcaye+5ecSbIOKN6dilU4lj7LoZ69sGo53bZo3Pquft3Re1LVuPP0ECnOBMusPXXcxaFylshnqEB1ev41HN/RjMJqGXdIHZk/uqY2qOrnptRz4yL8CFXOCzZfaDPLYC9z+FZNY5dW3ziDgBJrnCNLInYZGjCEutVQDhDd+RTSWah/tp8c4XlijN+Pb8Vdf8Zu2ZogLnnjoezJUsi8fsV8JOF0IEFzIIeLKzFHMeqsQxWjUuQJRGKqkHFsMfj+LPn04szQQgqvR7+Us4vBBUAfnC7wa1wUQYo25iX9xI1k/0zDPGyg36TxsjTGN+/2Yhf47Uw2LgQNNlpEuN2kw62MZVb3cKxgaJ/H+p5GfTnIreebc/ipWw5OfvVL2/hB7cbRJH8WUDLNRGjfV+Kl3IAcHeV4Qe3HvUsZMuRGoirUHnonmkEt+KMWc+p9l0MClIvHPc5y4Z4+nN9PQvzU+i5zLVTfvXMW6BzT3pGR1GEx10+Yn+68LQvvYb4uyv1nn3vRvYsoPfidcWMM2BQKhSVO09psIJys6vfe5vBMOb5IE+HPsd5scFktB80G1+J9Sp93vylXHcR7kFu8e25H69l9fzsaQN1s0kRRcD3Pc9oGVnNbetHoF7rZZIrzIk7cFqBptFwtgSrRi/49NwcO2U6o1/eS1znCXsRTmRYLnytGn9ws0GexCx7Qh2fhIv2pmnx/F56ZZzdbTOvGVpq7VYIrRHvd7kw44xv1djnCofz2Qv63AK4FGddBinHenUSd7CWE5N3Pd/69dwUxSIln/rO0GkciXOFr31dHoRktT7CpKrdF2eSSCLG2RLwkw951Qb8VOBQKWaOjcVB0n9bk5BNmNhhiPfD6LKCazNhY8t1OVVt2yKKIrzsS/z4YSt6PeKlnIe123/7t/+cKEuN8HjdZSK9l6zBvPdyFjb9cRzhn/z9X8Mv/eBG/BpVsLHMqlFyWXG/G6zdaLizKs4YF+GAqul9yFtYBF0V4GK0ifIWtKb/KovZrDSyDuHi7VDj+vvy9uHf+gs/xj/3/WtxM97bTDCb/rZtvTPO/tG//su9fZoEVJvcxZw442zCfj242K8ps55HbLlQzz44Vvkss40B1Od2zH5lZiJ5KM62WcJmYhN+eHeFf/z3/wp+9U88in4O6BQqQja7lNgCAP/Gv/Qj/Oj+Cj+65/c3gDrbdzmf3OI7xNMFwqGqndlSnEwkifoxwAxl1chT+fT26A5yyyjjbF+sxmZ/88xPAYD/8d/+FbFNMaDIak/7Ek3TImY8R0htKl20P17n+Mf/0a/hV37+XvwarzcpeykHdBlnzHrepAl2eaIpSDm5wkyrRk1xFqwa/aCf0W4yESNXODsmq0lshLMkZiulANVX+tTzf/Drfwq//kvfFyuPpQqVr5RZ6LFo/x/+zp/3sjeT55Dy6xlQCpX/94/e+v/fRW7Z9Ioz3o4mLNr9Md0t2twy+hnacq4lcYRUs0d/IdcWbmbhJPPQBaUgldfzL//oDv/L3/vL+I1f+r7o54isJnF5ePK0Xv27f/nn8Rf+xAO2QoWs/wzNVYUTWa3AD243zpxwgKcilZwtAT/5CBdnAbMoGHlKnKY/itRh9B5sYxYhFYRDc5oEWtCo8OtIrDjTl3ouLBni/8T3duKfAQa23Oc9zzrCN28BAP7in5QvDQH1frwVVX956UJRNch3gqZf82cfFGc2mwn+EP8erBoXgWr0nTPEMzILe5sJLahcwvaS1DNAQ7x8ubbNE/zVX/ye+OcGxRlziD9UqJrWiy3385/8njnSIZ7eb24NPewyfP2oUNUN0iRG4WDLxXGEPInZ7GrOdzFgHmRf/M4gCA1LdodVY6ZfnMmtVwGwa/r14JefAgC//ouyAZ7wuMtF7Ncl+Sm/LlwyEBS5RVjPgotwYFATHliKM/4Q/17UiAS2VAFjZEmkhb27F6FpHFnnG90enbKD7pnfZ1oqs3vuwp+s9ks/cyv+GUAt2uumxdePisXS73tuj8twnx4CkNUzQFaN/PpRdsrjntvu2sJThef6/BfOaC/Q5/je2WnZQM9XG5FhMzljX94LkTVZJui527btFCp+Vo0+M+qnPhOJt2j3dW0BgF/0IJ4CPov2WkT21Gfoqm7QtDwXJu5M917UbJu5gDH0GTqJIytZg+PCBHTklilZjdlz5x4uDz47MQD4a//CD7x+7pMwwuTzW4E/892d+PfcXWX4S3/qk/jnNqnKdpb33FyXh3l7dOtrYrk8DPXskw8b8JOF8AkHzOJQ1k7W4dD02w9+Pdg4sF/9kGvvoYuZNcjS3QycQ1UriwXpol1g7fbmGYK6BA9Cf/bPb362MUtwvUnRtoPVgAsl4zJbx8M2H7HZAVfGGd/ara/n0PR7YVAFVM68BRr0XNarwPA5S2ygALltzN6TLeeLXZ4gT2K24ozqXsIAXgofm4kssQ98Oqjpp7B2V1A5oOrdVaP6dzGcz/5QmUjdGW2zauQO8cmxVaPEehXgK1T2hd9F+BI8XmdixZnPxdkSKHILM6i8z1sQ2sZoqnDb+QxwbWO0eo7tmWkBZqSJ1ucwcoWdClLt4owyC7mKsyhSJIii5tpAqe+s72LOB4/d95l7Rn/eF0jj6Kyv8UaYcVb6WLtNXB5OYe2mz9CBfOqHQRVQOd/DftFuJZ/OKc74PfdGMEMfKnVpc9YZursAk87Ql+i599yMs6oVX4S/vCsVLaueGeczoOdzVSGz0BOpXs8ncGECxuQWqT06fS+4OaT7ova6CF+Ch50sh/RJ+ExbiiiKcJ3zz2ixPfokV/hQnkYgop8tgdjy7SN8wgGzkCjO3FZQMShqKjxU/JAl/PcwS2JEkZ0ZRU1/UTV4LSo0Lb9BoN9RCof4cy7aiS33tOex5Z72BZI4wp1HtoMvKOiZy5Yra3e+nY77WcUZZ4h3NKFxFOp5Ieh9a1pePQOOIX5i1fj8XorYr+oinFfPTdPiraixO+MQH0URHq8zPDPZr1T3PuxXXwzBxvyLcEn90ELieV+gbVv2Gc39fnG+iwFm5NoZbRvk+UN8MuSniNmv9Dzg5y345CEtwaO2ZObgac+zXT4lRFaNjDNWR1/PWg6p62d79qtl+UeLOFXP4dLMF6N6ZijOXBfhmzTp7dGlSzlASFY7nJ+sJrV2e+7cIM55sXu9SfFe1uzsY84Zq0Mt2omsxlecuazd0tH8F2raB6M+h71otxFgOpcHredeKyfcN4N0CW43KVJBJhKRNH0yznyxE8/Qsnq+3+VoW2VDyVGQZkmEOOIrzkLP7Q/Je5gzrFfVnxsrzvIkxpYddyAjq716ZpwtwSdBrjAR6n1cW5ZAogovpWS1LfXcuuLMIRDp/m7bTJeGev6pQviEA2ZxKN1sdrYsXft7wkPFD5L3MEtVELBtINWDjWkpJ7OZ4GcivS3IOPPFo5At97Qv8bg7/xAP8BfthTBI+GF7nHHGYb+6lnf6EinUsx/0941j0wPwMs70Rbv0Ipxbz/uS2OxnVqgI2HJLrFd9Ic5b8LgIB1TTX9Yt2tZdq1cZ36px+r8DZOCe0YOClKNQ6RSk74rYwVVn0KJAMsSfU/kBKPvVp32BhrHEbtu2Cyo/30U4oGpaQmwB+Lmf13mCNI5GChV3zx07f4e+WA8ZpP7IBH1OlkTOBUxPbqkbsfUq/Y4/zov2Tx4uD+dcsgPD+yFRhUsykfQc0lMqVPSLtZAT7gdpPQPcnntwebgXuLZkScxWp1ziIlyR1fh2yqQ4O+ei/UZqjy5VkPZ2yoVWz+bvRBRFuMoSp/3iqOcOri1e0C3uOVbKgNseXe+5X94L3O8y9k6ot0dfOeNsCR6v+RlnXz5KNO15Z2hAlkM65Aoz7dFncoU55NM8se9TxzN0qOdvHaEDC5jFgcHMoUHQ9efopj4OeQve0BlyLvbrJnHbxuiKs8HLeZ2m/3VBxpkv9IwzDpQN1PmXcoBk0d6I/NDJn71tW1HegqueQ5OwHPryw2UzkfeLdouC9EhxJs04U0u5tnUvsS8xxAPdol1oG3POIZ6GIEmwsfQiHFCXojSccazdXMv4cBF+GtCz0NXnDPkp7v5KZ7/eb+VDPF+hcn7bmMddjqZVA7oLXz4q1E17GatGIfuVW0NRFE1ySDn26G5yC+UKS15LwDEkfU6eJgzFmdZz99arwp5bUM/Aeclqfc/NJau9lV75ZkuwNrllLlfYVtOkIHXP0IHcshQ6icBl1bhhkFv0em7bFi/vhewiPOVbrw4z9HnP6E+7nF/P+8vEHQDCGdqj537el6wZGhgW7Tbo379wEe6HOB76HFc950yy2iZNtJzwkm2lDAyfI9+J6QKKs+sMT51jiQuXmKEBIqvxyeQA/0y83aSII+BFO6M5ZDXnTiyczz9VCJ9wwCzUA8V+yPzc4xbbLMGtw96OHiThgeIPyRD/w/sr/Oz91vpnyGbiUDW9VdC3ZBuzzRLkaSxatJ/bBkoabCy2dtuqsPbXw2AzYWsAHq9zXGUxfnh3Zf17g0JlOSSXFT+8u0Icwfq5TBVnPhlnbQuWhdElLsIBoeJsf/68hSSOsM1k1m4uiyYdurUbx3oVAH78uHXXs4C5GWAGLTfd+SkRvned48cPjjN6krcgGeLlF2fnH+Jpac5ZzF1CQQrIbGMKIfsVUIx2UoUXlZus9uOHLT5d52xVuMuSLMAM/Vx25dB8d7fBzzLqGRi7PIhV4Vzr1aLCJo3PmodF/y1shcr+/JmFg52yu6brpkXdyFXhL3tFVutzhS01/d39FZI4wneOM1rvF13EyYB5SPqcH95d4SqLrYrIXLs42xc1yroVL9rlF+HnPaMfdhmemAqVz28lsiTqIwjOgWGG5mciSS/CAdV/UT1zzugf3rtmaK2eQ8aZN7h9zu1Vhl2euM/oZExWk57PgNTl4fxktbpp+5xsG548VPGngMohlbk8cK0a4zg6UoW763mHH95trH8mkE9/unDeUzjgJwacB8q/9me/w+/89vdwe2V/sFKTEJg1/pBYNf7nf+Ofx3/yr/6S9c/obLkXYVA5vQY2s6aoEUWDH/k5EEWRmC33C9+/WflVjTEEG69r7faiNf22y/C7qwy/+9u/hTtmPav/HWraB5KL8L/4Jx/xf/03f9N6satbr36UNQ5V03/+rNdDwcZ1CwdfAvsLZBYCatEuuQg/d2YhQDYTgowzYX4KoAa6vp4dDMr/+d/7VcQOlVKo59OA+iVXnxNFEf7pf/mb2DHYr39Uqe/7l/dSVs+9bQx/0X6Ji3CAt2inC/Nzs19vNomongFZn/uwy3vi0qFq8Liz/+y/8y//PP72r/wsYkZGz0cpe74EjCF5Lv53/+a/iMbB4l7ac0vJaueu55tNiiyJ2FZQTxckq3Hs0XsFqcTlYZujqBt8lA2L3PLjhy3+z//6bzjfB/3vCHO0HyT1/Df/7A/xu7/9W9Yzd6NdhPtkFkqsV8m67BIuD//PH7yy/qxybTlv3MFVFiOOJDN0IyK2PGgz9Pe6GnUpVP7JP/g1tnUgEKwal4Db59xsUvzOP/wtJ8l/k43Jai5y2/i1dPboDCemtm2xL+rzk9U0O2VXNAud42dXnOUp/uh1z/qzUpcHQPXcEsXZf/ybv4i/9xt/yvpnggvTTxdCBxYwi6KqsXE8jOI4YjH6ifUYhnh/SNivmzRxDs09W66ue/aFbDEX9YOhC+TlfM6GGkDnz84c4vflBYZ4CjZeL+MMoEU7L0T1YZc7l3LpqEkINe2DkVUj4z10fTejKOqDjYelnMwGCgCrpl8vZdXYNbwcVdwlMgsBGVtOatV4N2Mb41qi7fLUaU8S6vk0oIGJowi4u8pYdlFLbWP4Z/T5h3gayDmM9ucL2EABaohn17PQNgZQZ/SzQHGWJjEriza4PCyHZBlylSXYOYgkukLl2TdXWNJzn7meoyjC4y7va9WGpmnx/F6eP+NMYO1WeF2ED5lIql+PnP0055kWGO3LMbZqtH8mykbXcZk5qmf1nZdar0rqGbiAy8M1r54BdBmk563nKIpEOaQH4QxNn+fLvhieB4xLGpdbk27PHy7C/UHvnSvuAFD7LdezOE9iLSdcbr0KqJgbFw5Vg6ppL9dzM2q6t169hD068yJ86LllLg+6nbKrnvM0ZotD1P8O9fytI3zCAbM4VI0zg4OL3oc42MZ4Y/xgXv4+9rYx5bBolwzxueYF7cLboTqr2oxAfs4utG2Lp7cCn86ct0CLFs4Q37YtCkbuoA4a/JTijOfPzoFuixDYNX5IT1zPgMo2PFS1llkoWbSr18Cp6cF69cw2E9ddJtK7e9F+iXoGVE3zF+2taGgmBd2onk9wRp/6bPlpRW/VeCLrHT2o/Pm9kGWQdixmDqO9bVu8FdVZLZaAYSDn2K/27NczD/G7TYp9UaNhXNaXzMWajvvd2DbmFOczEHruUyAVkltcmNqj325S0d8ryTh7PdQX6rl5Lg9fKbPwAhfhAM8evfS8CAcGstqpluLj72KoaR+MrBpPcEbT5cihqr2sV/M0RtW0rLOFespz1/SnnSKfcl7j0wWsVwEZuaUUztD3ej2X8vPdhDEROtSzL3qrxhM9ZzdZ4m2P3mecMS7D+xn63D235OLsQhlnu03CUoQDuj26jNzysh9cHqgvW4Ioivpc63Bx9u0jfMIBsyhO2PRToxEeKP44da7URmPHPO8L7PLEyZLSkQtsJl4vYBsDqIsjjrXb10OFqmkvkp8C8C7Oqm5wkWUiyRUqHISMs+VY4z3cZPGI/Sq1gQJ4i/ZL2caIFu172UXDqXAjYL9KrRqBwWYi1PMfP9BnKXlG27BJx3kLImKLIG9hX9Ro2wvU8/VgG+MC/ZmHM1+Gkyqcw4AlW0xpDukXAfuVC3oNp/r7fhqRn5hQMLJq3MusVwH1WUrIapfpuXlktc89m/289XwtqGdpfgowuHZQz+2yUuYiWDUuh26Jd4o+h54JI5cHn0ykhuPyoBbJ567ph12GumnxlZGJpHLCz09WuxYs2stattfK0xjXeYLn97J/9kr2JCaMrRpDPfvi1Mp6yjij3ELpRTgAVoTJpTIL6bzl2Cl/3hfIk/jsl/USBamXPfpEcXYqgUjWX+KGi/BvHeGJHTCLNRRnYYj3R3ZixqGuOJMu5ej1SPIWzt0gAIotx1my01Lu7BdnOVk1coZ4ObOmZ8u9F51Fhds2hoNg7bYcI6vGUylUOpsJagrvhJmFAG/R/npB2xiAv2g/tzoF6IZ4Qd6C9JJFBRsX7KByDoLNxGmQ91aNp1ScNajqBl8/Ki/bGI4V1NuFrFev8wR5ErMvwtM4wu25X6MkE8njMvt+m+HroUJZNzhU9QkvzgL7dSlOTSjoe+6qxvP7yj13caGem6k4oz9zqYwzjj26V34KWbu9qzP6ZIqzOJzRS3HqGZrs0fWe24/cwlecXcrajTVHd/bo54aIrFbJcsKBLod0X+JQUk748voL1qunQW/VeEKy2qGqvVyYvsUZ+vE6O3/cQZ6iqBrW+1jWDdJYtte67+zRm6ZzcTpR/ZGKOdTzt4/wCQfM4pSKM1okBUm6P0693CTWVFE3C4Z4d8MPAG9FfXZbN0A1CZxMJMpBO7ckPU1iXGUx9gVnKSdns99PMpFOwZRTryFYuy3FmP16oqY/S3o2O+DJfuUoVC7ElqOLME5u4SUyCwH1nuwF7Ff5EK/YcoP16vKa1i9uQz37I1thiC+qBl86treXbQxnKVdchs0eRREerzM8MzPOHq8vkVnYXZyxFCrdoj2Vq8K/vJ/2jO5zhUM9e+PUdlq64uxZmJ8CqJpm99wXUpw9dktmF0gVf6mMs70g40xSQ1OXh5ORT4NCZTHy5PR9zoYuzvY+ucKdnTKH3FJUyNP47EtZrrVb07R4vkDGGdD13AKymrR+7rcZXt4LTXF2WrJaUJD6o1ecnYh8Sj33y3uXWSixRxfEHewv5Npyu0mRxhEz4+wyF+HDGc0ht/z/7d15nFxnfef7z6mtN/WiXZa6rcV4EbbVsi1jGQg4LHeScIEkL7awBRiDIRcyCSELN8DhgWSScLk3TIYJYcuwYxyTYUkClx0CsWxkUEs22AZLtrslW3t3S71WV9X8ceqprm51baee0jlSf9+vl1+t7qpqH6nqd57992t8Iby3M8P4dJbp4uZTd220NqstF3qHZUkuB/GZpFbim9WyVI3ZID97o4P4RgsbRzGI39DTTqEAh09PVX3eY6cmAVjX03Y+LmuBenfLlQbxDXTa29NJ2tOJYk0kl7vZdeKsWQsXK1yeOMsxWuz0N1QTKWkn9WpPzNnPa6ejNET1Wt8bxKeN10rOzsxxcmKGDT3t5+OyFmhk9+tsmE5/R5qxyfmFMycnzlKKZxfs5KbLFNcz5alXQ8RzXalXI9rNDrCht6NmPEMQ81HEc1cDdUhDnVCxE+3FxXDXbbTiOTzXm9XmT5zli/VTGpuUSjeQHn1iJprNapf0tnNyYpYz09UXz2zMb+g9vzHdkU7ieY3Fc0NpoBbHs7O+3fxnURtQw2nFKZ/SwtnULJlUsBGyXulUY210FGPoS4rxOVyjjT48OkW+AOuiaKPbUnWdIIVgHN3oop2H9kQAACAASURBVGlfsQ5py2qcaXNLaKXFigY2K1WTOWchvDXp0c9G1Of2PI8Nve119bmHT02yPqIxNMDZetKjz4WI5440hQKcOBOMq5ydONNmtWVDoypZksuJ9vnGTR+3sFq2+zUXdPobHcRnUo0M4ufozJz/Tv+O/l4AhkZGqz5v//AobakEV6zvPh+XtUBnnYWN5wfxjXYSMoxOzhYXwt3GM2hiLqzyzpWzEyqlGmdZUgmvocLDmeLAo95BfGcm6STtZyPWdbezoaed/TXi+b7DYxQKsGOg9zxd2bx64xmCncZhT5zNzjnc/ao0UE7Mp2p0tZs9SS5fKKU1a6QmUjLhkfAaHMSf51oGADs29XLg8Bj5KqfC8/kC+0fGSu35+dTZVn86ZVvjrJH+mT0Vfnpilrl8wVkbrVSNzXO/WS34LM2ErHHW6Ga1KPrc1/b3AXDg8FjV5+0fGWN9T9t5n5hLJDw608n6UjWGyPLQkQ7Sz7b0xJliOpSFixWuFs7mszz0dTSW1qy0Wa2uPnfuvNcaAnjS2hW0pxMMDdeOZ4DBCNrorkyy/j53iNRspT63wxpnrdg4uRyVsjw4PnE22kzWlrrSo9usLRH0uft7S/FayeTsHA8dPRNJPNs+d73zYo3OU9v39NiZaQBndUi1WW350DssS2pJoXKtxIe24Gi/g/clsyBtTMgTZ3UunJ2dyUWym/3KDd1kUgmGhqtPtA+NjHLNpt5IGryutvom2u2ESaiJ9smg0+8snss6qUozEY7nec4nNzPFmBydCuK5ZYP4iOqnAAwO9NaO5+Ljg8VJvPNpRVuSidlc1YUAK4jJcAvh0w7rLSycIFYbHZbzQuXF9/bYmRmgsd2v9jriXOMMYHCgj7Mzcxw8cbbicw6dnODM9ByDA1HEc/01zmx680buu/YUoX2P3Z84UzyH5fq+uLjGWcPxnKqvz10oFJiYjeaEip1oqzXRPjQ8Gkn7DA30uXNBzDey4dPzPHo751O7ud7Nnkx4JHXiLJTyeHY1F5EpxmSYMbT9bNTTRp+N6MRZKpng2k29NTefDo2MkkkmuGpDz3m6snn1xjPYEyqNZnnIlBbCwdX8i1I1uuA6m1XGLpxNhUi9mmpgDF3arBZFG93HY6cmq9Yive/wOPkCkfS5u0p1SOs9cRZ24Szoc7c5a6N1QGS50DssS5pxeELF3lBc7QpZjlyfOFucNqbR3a+ZZKKunTVg00yc/5016WSCqzf2VO30z+XyHDgczW52CCba6+kglE6chcjPPjoVpJlwFs8p96ellqNUwu3kZiaVYCZb3M0eYpId6tstd3YmF8kgHmBHfx+PnJwspa9bytDIKAOrOiKrtwAwma0nP3u43a/5AqVBj5PdrzpB6kSprpSjfo79bBwdD3ZGNpKq0b6+nkF8VGljYH6ifV+VifYoF8K72hpL1djw7tfifdq+x85qnCXs6UfFc1ipBafC3aVHPzUxSy5fCFnjrHY8T2Vz5AvRxHNfZ4bNqzurbm4Zm8py8MREJJNyUEynXFcaKHvirPFUUDa1m7uFcDuGVn87rAVZHhyeUJnJ5kJmbbGp3eqoQzoT3Wa1Hf193Hd4rOq9Z9/wKNs39jj7vDeikfToYWoi9RUXwmeKNZFc/B3LP38aQ4c3X1fKXZaHmblcaXzZyLxYI3WF7ec1inH0jmI/utq8mG2/d0Sy+bSxPneYhXCY73O7y6xmx3+K54udRlVyjly+wFy+4O6GYieItRIfmuu0MbaRHyum/Wq43kKqvkLlR0anmMrm2NDbEeo6mzXY38d9h8eZq9Dpf+joWaazeXZGNIjf2NfBweMTFArV/y3nC5WH6PQ7PnGmNBNuuN5Q0GZ3v07NNj7J3sBuuYPHz0ZSbwgoxWm1VBNDw2OR7Wbf2Bfc5w4er3yCxgqTqtEuiLo8oaKahW6kXadqTDd34iyTqm+i/eDxCRJeNDU+t61dwYq2VNX0q0PDo3Rmkjxp3YrzeGWB9T3tJLw64zlk/RRo3Ykz7WYPL7PgvuguPfp8PDe+EJ6towbpweMTAGzsi6aNHuzvqzopd6CU1i3aPnct2Vy4dMilmkg5d3XC7YKZ4jm8VtSVKj9xFib1KtROp1woFDh0YqJUb+x8GxzoY2Yuz4NPnFny8Vy+wH2Hx9gZ0ebTS3rbmZnLM3K6dt2mMOPgvo402VyB08X0fS42oGqzmhulVI0OT5zlC3ByYpaEB90NLGzZPkI9J0gPnZigK5Okp8E+vQvX9vfieVTd3DI0Msqmvg7Wdp//MYG9z9XXRjc+T33OiTNn82JKj75c6B2Wc8zXT3Gb+1WpGsNzXag8lUyQTHhlu9nDpWqsteBz96GTAOzetirchTZp50AfU9kcvzi29MSXnbCLahB/09bVHDszw6ET1TsJdpGy4RMqHRlGi7vlXKeNCf6smA7LdvhcbSiwJ85GJxtPA1XvbrmxySw/e3yc3dtWh77OZlxbSgW1dKf/+JkZDo9ORbYQftPW4D635+DJms+dzRUafu/tgqjL3XKKZzecp41ZdOKs0UF2us6J9j0HT3L1xl562s//ID6Z8IJUUFUH8WNcu6k3khRlK9pSXLuplz0HT9V8bpjdr93taTyv7MSZ67QxiufQnG9WSy2M54Yn2uusK2zbnpu2RtNGDw708fjYNMeKf8/F7KLatRFNtN+0dRUPPDFe9dQ6zC9ohErtNpVlJuuuTnjacV9xOSo/redqLJRJFrM8hEm9aifaa8T0Y6cmeXxsOrI+987+6pvVfnnsLJOzuchOkN5U/He5u0YbXSgUilkewm1uOTo+jec5yvijzWpOuE5JXd5G93akG6rjbcsv1NtG37h1VWR92svXrai++XRklMEIaoQD9K/sZFNfR51j6BCpGhdleXDVRruez5H40jss53CZyxlUqNyFVuyWa0slOB52N3vxGuZq1PLZ8/ApejvSbI8g9znM52iuNDE3NDJKb0eazas7z+dlldgFxVoTc2EH8aUaZ3Pudr+WT8o1Us9FFip1+h11nttSyZbvfr3nkVMUCtEthPe0p7lsbVfFHe2lhfCIBvHretrZtrar7on2MKkagdJ928VuuWTCw4axOv3huR7E26LVx8/M0NOeaniQXc9E+3Q2x0+HRyOLZwhi9WePj5dSIZWbncvzsyPjkS2EA+zetpp9w6NMzVZPvzo713gaqGTCo6c9PR/PacdpY9TnDq38XuhistT2v8L2ueutK7zn4Cm2ruliQ0QnVHYWJ9yGKkzM7RseZdvarobTSbuy+7LVFApw96HW9bnHJoMaZ87SoztO670ceZ5X6m+5OqHSlm6+xlmt9Oh2AjmqhbOBVR2s7ExXHkMPR9vnvnJ9N32d6ZoT7bl8gUIh3EI4BPfttlRjNUwrKf/86RRpeLZWnKv06PZ+ffzMTMNZW6C4Wa1GG33i7Ay/OHY2sniG4qnw4dElN76fPDvD8KmpyDaTQ3Cvu/vQqZq1wsMshNt+x/wY2u2pcPW5L356h+UcM8WiyM6OsJZSGOnjFtaC3a+uaqikEuF3v9Y50b7n0EmesnVVQzt3XNqyupOe9lTFifZ9w2MMDvRFtgC0dU0X67rbanb67eCq0YFzb2eamblgR6TrXM6qWdgc1/fFTLHeQrD7tcHUq8VrqRnPB0/SlkpENkiGYIC+b3hsyU7/0PAoyYTH1RujWaiHoNP/40OnKqaHtUKldmvRbrnSxJxiOrSU49Sr5SfOwg7ia020//SxUWbn8hEP4nvJ5gr8/PFzU0E98MQ4s7l8pPeb3dtWM5vL89PHTld9XpgaZxBMtJfi2fmJM8VzWHZDSyrhZoPQ4hNnYWoW1mqfc/kC9xw6GelC+NUbg9OhS020FwoF9g2Plk6xRGFHfy/t6UTNPvdsztY4a3xHu60r7K7PrTrhLsz3uR2dUEkmODOdZSqbazie7cJ8rSwPew6eYs2KNi5b2xX6OpvheR6DA5XTr+4bGaW7PcXW1dFcXyLhcdPWVew5VGMMbeM5ZGq3o+PTztrnhfUztRgelr0fuky9CvMnzhoVLJzVyMJU3FQZaZ97oI+TE7OMnJ465zF7Ei3aPvcqTk3MVswUZYXJ8pBKJuhuS6nGmYSmXpicYybr+sSZdss1a0GqxlQrTpw1OtFud8tV7iQcGZ3i0ZOTkXYQbKd/3/C5u18nZ+d46OgZBiNKGQPB9e3etpo9B09WTXtZqnHWcH72hbvlXFAaKDecn1BJJZjM5jg7Mxcq9SrUzs++5+BJrr90Je1pN7u0whjs7+PE2RmOjJ2bCmrfyBiXr1tBZyaaQuoQDIjOzMzxs8fHqz4vVGHjshNnCUdpY0Ax7UIpVaOj+6w9fXT8zEyoQXw9E+17Dp4k4cGuLdGeOIOlT4XPFymPro3etWUlCa92+tUwC+EQTLS7PnGmPnfzSunxHE2WJhMeqYQ33+cO0UbXmpT7+ePjjE/PRdrnbk8nuXJ995IT7U+MT3P8zEyk8dyWSnLD5pW1szzYzCsh6pBOzuaYmJ1zX+5AJ8Kb4rr2Y1sqWYrnRtvoejafFgoF9hwMFsKjzO6xo7+Ph46eYWJm7pzHhoZH2dHfG9nmWAj63MOnpqrWOQtbJ7z8hEqbo3GPUjW6Md/PcRfPYE+chVs4q7VZbc/Bk3RlklwT4eZOe5psqTZ63/AongfXbIqujbb9l9obyhvP8gDBONpl1hZwP/6T+NI7LOewN353E+1uO6vL0YJUjQ5PnNmCtw0P4oufDXs6cSlR1zezBoud/sWplu4/Mk4uX4j0SDoEnYRadc5mQw7i7ft6etLdiTMN4t1wXhMplWA0ZDzb97Japz/q+maWnWjfv2iivVAoMDQ8GmlaN4DdddQ5y+cLZHONd/rtIN7Gs6vJlJQ6/U1znnq1+PtOh0gDZa+nnoXwqzf2RpY2DYJi4Gu72yoM4sdYsyLDpr6OCK4s0N2erqvO2exc4wvhAL2dmVI/LJN0lTZGqRqbZf/tXJ4IKO9zh5loz+UL5KqkL4q6vpk1OBCkglqcamloOPrd7AC7t66uWedsfrNauJpIo5NZbVaLmVJMO2qjmxpDF9/LmSptdNT1zaydA73kC3Df4YUbUKezOR584kwsxtBQvc7Z/Bg6XDyfnsy6O3HWgnp7y1EpVaPjE2enQ9QJh+CzVU+f+8atqyLNwHXlhm4yqcSSm9X2j4xy+boVrGiLbvPpwKr66pzN5PKhxqx9nen5PrfjU+Hqc1/89A7LOeyJM2epGm3KE3X6Q1tYqNxdmgmr8fzsNrVblUF8xPXNrMGBPnL5AvcfWdjpL+1mj6gIqlVPnbNsE2ljLGcdhFIKIzUfzWjFIN4Kvfu1Sqc/6vpm1vZLukknPfYtmmh/9OQkY1PZyCfl6qlzls2HO9XdlkrSmQkm110OuG2bokF8eK4n2puJ5+B6vKrtcxzqm0HxVHix5sJiQyOjDPZHl0rZqqfOWZhC5dCaNlqpGpvXin9D+/62pxMNn9q2CzjVTqhEXd/M2jnQy/j0HI+cXLgZbGhklHTSY/sl0Y4J6qlzFrbGWW9Zyj53fW4thLuQKaVqdLdZzWo0a0upxlnVeI62vpm1o8IJlfuPjDOXL0Te566nzlnomoVl76urObHyerWuMggtR/N9brenhqDxVMoQbDysFs9xqG8GwX3r6o09pY0sVqFQYGhkLPKFcKivzll2rvEaZ7Awpt230Yrni516YXIOu9POfapGfdzCsjdjV/UWYP5Yejrp0dHgIN5+NqpNtEdd38yyqRj3LZqYGxoZY1NfB+u6o51kqKfOWTZkTPaUTcq5ThujDn9zSjuUXKV2K3t/G51oL8VztYXwGNQ3g+Dv+eRLes6ZaLeD+rh0+qvVObP/zmEWqux76yptDLTmdMVy43rHYXk8hzlxlklVTxsTh/pm1mB/Lw8fn2B8Olv62ZnpLA8fPxv5/Qbqq3MWtsZZ74I2Wqka46IV/4b2/Q2behUqnwqPQ30zq3QqfOTczWrbL+mJNNUz1FfnrHRCpeH06C2I55TbCeLlyv77uUvVGH5zy3yfu/pCeJT1zaw1K9roX9nB0BLxDESe5aGeOmdhx9Dt6UTpNa7mxDzPK30GtQE1PNcbCspTZfe0ID16HOqbWYP9fRw4PLZgjDpyeopTE7Mx6XPXrnMWpz73/OlHxfPFTu+wnGMmG+yqdTfRrt3szZofOLlNGwPQ25FpeDGuVn72ONQ3s9b1tLOxt33JTv9gxKfNoL46Z/P52cOlmYBWTMopnpsxn9rN/SC+4ULlxc9VtYn2ONQ3swYH+jgwMrYgbdXQ8Bjt6QRXrF8R4ZUFatU5sxsOwkzK2k6/y/ZUaSaa14rUq1aju9ntddTazR51fTPLDtQPlLXRBw6PUShEn9YN6qtzls0VQsVkeRuttDHxkW7BxKZ9f8PEc63NanGob2Zdvq6bzkxywWa1fL7AgZjsZq+nzlnYzS0L4tlR/Nn0v2F218u80gbUFpwKD1tXuFIbHZf6ZpZNv1puaGSUDT3trO+JdvMp1K5zFvbEmed5pcVwV2NomP8Mal4sPLt513V6dCBUqsYgPXr1zadR1zezdg70MZXN8cvj8wtT+2KyEA711TkLUycc5muFg06FS+P0Dss5XJ84S2mivWkZx5PsMN8JDFs/BSpPtMelvpm1o7+P/WVpJk5NzPLYqclSCoqo1apzVtot1/Ag3n2aCXX43SjtOHQ0iF+wcNZoqsZE9UF8XOqbWTv6+5iYzXGwrNM/NDLKNRt7Y7Eru1ads9IgPmR+dli4O7JZ9v1XTIdXfirchbYmJuWg9u7XONQ3s3YUT4WXp4KyaWR2RFik3KqnzlkwiA+/EA7a3BInragrZTcj9jbR5650Kjwu9c0gSEV2zcbeBfF88MQEZ2bmSrEetVp1zpykdnPURmsM7YbrU6QLsjyEXDibrRDPcalvZg329zJyeooTZ2dKP9s/MhafeK5R58wuaIRKp2z73I42k8N8P1GZW8KbH0O7P3EWal6sRqrGONQ3s0p97rLF8P0jo2RSCa7c0B3VZZXUU+csTJ1wWHwq3FFdYdUhXTaij16JHZuiwvUgXmmgwpvvZLVi92v4tDEVB/ExqW9mDQ708ejJSU5PBIPkOKV1g9p1zuZPqDT2/ndlkqXPjquFcNcLPsuV61MBzex+TSQ8UgmvYqc/LvXNrJ0DC9OvZnN57js8FovTKVC7ztlsyEk5mJ+Yc1vjTDHdrNLkprPUH+HTQEHxxFmF3a9xqW9m9XVm2LK6c8Egfmh4lM2rO1nZ1fjpnFaoVedsdi5kjbMW1ERqxaLPctOKxUd7zw67mx0qb26JS30za3Cgl/uPjJfGk3FJ62bVqnOWzeVJeAvrEdWjtxUnzhzX5lquXMe0vV8nEx7dbanGXlujrnBc6ptZdqxsN6COTs5y6MREbPrcteqczadqDF8TyVX7XP67lKoxPNd1pTLJJtOjJyuPoeNS38zasrqLnvYU+8rqnA0Nj3H1xp7YbNCoVecsdF3hFmRicp1xROJL77CcYyZkbvdKVKi8ecmEh+e5280O8zstmjlxVnEQH5P6ZpZNyWgXzIaGR/E8uDYmu+Vq1TmzC5SNTsp6nle2W05poOLE/e7X4Pd5XnBCIsz1VNvNHof6Zta2NStY0ZYqxfODT5xhZi4fm+uD6nXOmqlxNn/izOHuV8V00+ZPhbfixJnbQuVxqm9mBamgygbxI6Ox2dgCteucZXP5cCdIW7H7VWljmja/mcBhlod0M1keKqdTjlN9M2twoI/ZuTwPPnEGCOJ5RVuKbWujT6UMteuchZ2U625LYZsAV220vQ6lamyO6wXI8pqFDZc7KC7gVFsIj0N9M+uaTb0kPEoT7bZ+YVwWwmvVOQt7ghTmF8Odpmp0vOizHKUd15UqP3HW6zg9epzqm0EQL+XpV+dyeQ4cjkcqZatWnbNsLh+qTSw/Fe5qc4vG0MuH3mE5R6kosrPdckoD1SzP80gnE05vyvOd/jAdhOIgfondcnGqb2Zdu6kXz5tP/7R/ZIzL1wWT73FQq85Z2BpnUFYTSbmcY6VVNZF62tMN75IOrsNbMp4hXvXNIOj07+jvXRDPADtj1emvXOdsNuQJUigbxLfgxJliOjzXg/hmTpAG1+GVNkEtFqf6ZtZgfx9PjE9zdHyaY+PTPD42HauF8Fp1zmZz+djUOLO/R/Ec3nxtZod1he2JsxAL4fa1S7XRcapvZtkJuPLNatdu6g3VN2mFWnXOZufCxXMi4TmvQ6r22Y1WbVZr5gTpUvEct/pmAF1tKa5Y3106cWYn3OOy+RSq1zlrps/d53gMDUF/MZ30YvP+Xoicj6GTzfa5E1XH0HGpb2YN9vfx4NEzTGdz/OLYWaayudgshEPtOmdhszzYMXQ66Tnb3O+6bZH4isescQ3GmF8B3gbcDPQAI8CXgb/0fb9y0QEJZWYuSEXjardcKc2gbihNySQTTv8NS6kaQ+ZyhqV3v8atvhkEJ3AuW7uC/SOjFAoFhoZH+dWr1kV9WQvs3raarwwd4dCJiXN25ZY6/SHSOgSTNBPOBvEZLYQ74Tqdlk0zESaeIbgfLBXPtr7ZHzz7iqauz7Ud/X18/IcHmc7mGBoeZWVnmoFVHVFfVkl5nbPFtRSzTSyEtyJtzPwksWI6LNcnVBYsnIVMp1x5N3t86ptZdpEsOA0efB4HYzQpV6vOWXauEC6eW5A2phWpvZebVpw4y5SdUAl7PUvFdJzqm1n9KztY1ZVhaHiUF+/q5+ePn+G1T98S9WUtsHvrav6/bz3E6OTsOYuZYU+QQtDnPj2ZdVgnXLvZXShtKHCUHq8UzyH63PYevVQ8x62+mbWjv5dv/uxoMIYeGWPb2i56QmS3aJXyOmf9N3QueKyp9OidLVg4S7jdCL0cuU4x32yfO51MVKxZGKf6ZtaO/l5y+QL3Hxnjl8VTXXGpWQgL65z97lO3nPN4s1keWlHuQGPoi1/s32FjzJuA7wEvALLA/cBG4K3AkDFmc3RXd3Fq1YmzODUYF6JU0nObNsZFjbMldtfErb6ZNdjfx9DIKCOnpzg5MRur3exQvc5ZNpcPvTvGvr/OFsJL6U60EN4MG8uuctw3E89QnGhfIp7jVt/M2jnQSzZX4OePjzM0MsqO/r5Y7d6sVudsNhc+HbLr1Ksw/xlUTIfnvt5CWdqYMPUWKqRqjFt9M+vqjT2kEh5DI6MMDY+STHhcvTE+g3ioXucsm8uHiufelqSNcZs2dDkqjVtikh7dfraWXjiLV30zCLIoDPb3MjQyygOPn2E2l4/ViXCoXucsO1cIHY92YdRZnXC1z07YWHb179hMn9vzvOJmtXMn2uNW38waHOjj9GSWx05Nsm94NHbxXK3OmU2PHiYm7aK60z530nPatixHKcebT8vf3zCbW9oq9LnjVt/MsqfL9g2PsW94jJ72FFtWxyM1rFWpzlmhUCCbC9dGl+LZZbmDUtuiee6LXazfYWPMdcB/J7jOtwD9vu/fAPQD3y5+/UJ0V3hxsul9yvP9NkMr8W64TtXYzImz7vbgsOp3Hzx2TmrBuNU3s3YO9HLi7Cz/duDx4PuYdfor1TmbmJnjroMn6QqZVtJOuiptTLyU/h0dp+fqDZEGCoJULD957DSnJmYX/Dxu9c0sez3/8fBJHjp6JnbXB5XrnH3n58cAQqWKbU3aGPeTxMtNxnGqRjuxBuEG8V1tKcan57hn0aRwHOubAbSnk1y5oZuh4TGGRka5cn03HZl4pIa1KtU52/vIKcamsqHaaPveukwbk9EJlaYlEx4Jz+19dn6ivfE22n62vv3zhX3uONY3swYH+vjFsbP86OETpe/jpFKds9MTs/zksdN0tYW7/7g+oWLTAGsM3RzXY5f5MXS4PveKthR7Dp7k7Mzcgp/Hrb6ZZdOvfv2+JzhxdiZ28VypzlmhUOA7DwR97mbaaLdZHhJOf99y1Kp47m5LhVoA6WpLcmR0ip8dWZieP271zax1Pe1c0tvO0HCwWW1woC9283aV6pzZeA41hnY8JwZK1bicxP2u/U4gCXzO9/0P+r5fACimZ3wZcAa4yRjzvAiv8aIz4/jEWWlXSEo3lGa4TtXY1sRE++bVXdz69K18/p5h/uyLB8gVd4PEsb6ZZTv5n97zKJlUgis3dEd8RQstVedsbCrLqz5+N/tHxnj3868O9XvtJI27hXAN4l0oTW466qg2e+Lsz5+3nZHTU7z0w3dxbHy69PO41TezNvS0s667jc/f8xj5QrAwHjeL65wVCgX+5usP8MHv/pLfvm4T1126suHf2YpC5emERyaZiNWJvQuN67QxELzHnZlk6aRKI17z1C1sXt3Jq//xbn7w0PHSz+NY38waHOgrnTiL26QcLF3n7Ie/OMGrPn4Pl67u5LVP3drw78ykEnSFfI8rSTnelLFcpZMJxyfOwm9Wu26gj9++fhN//72H+euvP1DqI8axvpk1ONBHoQCfu/sx1na3cUmMTsTB0nXOjp2Z5mUf2cOjpyZ5x/OeHOr3lrI8OIpp1RV2w94PXf072vc3bMpj//lP5sDhMV718bsZm8wC8axvZl25oZu2VIJP73kUiN9COJxb5yyXL/D2fz7A5+95jNc+bQtbVnfW+A3nms/y4LaNVjw3x85BuMvaUoznkOUOfu+WJ9HXkeZlH7lrweaqONY3swb7+/jxI6d48OiZ0sJ4nCxV5+xf9z/ObZ++l2s39fLiXf0N/87SiXBHc2JQXnpDMX2xi+07bIxZAfx68dsPLX7c9/0TwJ3Fb196vq5rObCpGp2lmbCp3Rw1bsuV66P9GQcT7b//7Mv5wt5h/uAL+8jm8rGsb2ZdtaGHTDLByOkprt7YE8vdXru3rebYmRkOnZjg5NkZXv7RPRw4PMb/ePn1/OZ1m0L9Tte7azzPI5nwlDamSaVUjc53v4aL51uuGZhSHwAAGkdJREFUXMf/fO2NHB6d4sUfvouR05Ol+mZxnJTzPI/BgT5GTk8BnFNHLA7K65zl8wXe/ZX7+dD3HuYVN13K+188SDJU6lX3Nc6CNMCK52aUJjcd9nPaUonQ7fP6nnbuuO1mtq5Zwa2f3Ms37n8CiGd9M2tnfx9npucYn56L5UL44jpn3/zZUV73iR+zeXUnd9x2c+hUeX2dGbfxnHC7KWO5SicTsalxlkh4vP9Fg7xy96V8+PsHedeX7yefL8SyvpllJ+JGTk8xGLNUytburat54IlxRidnOTw6xUv+4S6GT0/yidfcGLoOsj2B5OzEmdKjO5FOeHgeofpdS7FjqrB97hfu3MTfv+J67j88zu98dA8nz87Etr4ZBPfDazb1MnJ6inTSY/sl8dp8CgvrnGVzed56xz5u//Ewb3nWk3jX//nkUPegltQV1hi6aa5TNdrfEzaet6zp4o433szKrgyv/Njd3PVw0DbHsb6ZNTjQx+Nj0+TyhVguhJfXOQO4894R3vL5n3DdpX189vU3hTrt255O0p5OON38nXJ8+lHiK87v8HVAOzAL3F3hOd8vfr35vFzRMjEzl3e6+1yp3dxwnaqxmXoLEExcv/W5V/D2X7+Krw4d4U2f+Qnff/B4LOubQdDp3V7c8RPHnTUwv+D45X1HeOlH9vDLY2f56Kt38WvXbAj9O0u75RyeGEonPcVzk1wf7S/FcxMT4k+9bA2fufUmTk/M8pJ/uIs79g7Hsr6ZNVgsZLypr4M1K9oivppz2TpnP/rlSf7ki/v55F2P8oZnbOMvfvOa0CkxWrH71XXbshyVUjU6PFnflkqGTr0KsGZFG7e/fjdP3tjDmz77E+7YOxzL+mbWjrLFsjguhMN8nbM79g7zxs/cy/aNPdz+ht1N3X96O9JOT5DaCT6dOGtOOuk5nVxp5sQZBItn733hNdz2jG18es+j/PGd+/nRL0/Err6Ztaorw8CqDmC+rY4bW+fsjr3DvOQf7uLkxCyf/s838dQnrQn9O53XOFO5Ayecj6HTzW0+BfhPV2/gY7+7i4MnzvKSD9/Fl356BIhfWjdrRzGOt1/S47QP6oqtc/aDXxzn9z77E7687wh/+mtX8Uf/x5Wh57RaUVdYfe7muZ5b9DyvuFktfJ+7f2Un/3TbzWzs6+A1//Me7rx3JJb1zazydjm2bXSxztmn7nqEt/3TEE970ho++bqn0NMe/r7b15FxfOJMqRqXizjfta8ofn3U9/1shec8XPy6zRgTv+2zF6jZuXBFziuxO7EzStXYlJbVOGuikwBw2zMv470vvJpv/fwoX9p3JJb1zaydxY7BYAx3s8N8nbP/9u1f8PjoFJ983VO45cpwu16tUn52l/mcE+r0N8t1HZpma5xZ11+6ks+/YTczc3n+8t9+Hsv6Zpa9rp0xvT4IOv3ff+g4d947wh8+J9ho0MymFNf1U0CDeBdKqRodnjjLNHHizOrtTPOZW2/ixi0r+ZM798eyvpl1+bpuOjNJOtJJLl+3IurLWZKtc/Ynd+5n1+aVfPbWcLtey/V1plvS51ZMNyc4cdaCLA9NfF48z+PPfv0q3vrcK/jiT0b47oPHY7sQDvOb1OLah7B1zv7rvz3AVDbH51+/mxs2N55CuZzrifaU0kA5kU4lnJ7CnT9x1tz9/xlXrOVTr7uJo+Mz/O23HoplfTPL9rXjuvnU1jn78r4jfPNnR3nPC6/mTbdc1tTvbEWNs5TjTRnLUSlVo+M2OmyqRmtdTztfuO1mLl+/grf90xAQ34Xwa/p78Ty4pLeddT3x23wD83XO3vXl+3nO9vV89NW76Mw0XtusXF9n2nGNM7XRy0Wc32E7EjhV5Tn2sQRwzhEXY8wbjDF7jTF7JycnXV/fRWtmLud0Z826njY8D9Z1x/OmfKHY0NPGuh53pyou6W2nK5Nk9YrmOv0Ar7p5C+9/8SAJD54dMr3J+XDzZatJJTx2bY7nRIPneTx7+zp6O9J89vW7nXS2tqzuwvNgvcPPzvredqe/bzla39vOys60s47Wqq4MmWQiVA7/xa7e2MsXbruZ9T1t/Mrla2JX38za0d9HZybJ7sviOSiB+fvhn//Gdv7Lcy5v+iR3RzrpvF7M+h7Fc7PWrGgjmfBY73DwuaGnnc0O4nlFW4pPvPYp3HLlWrrbUrGsbwZBCq2nbF3FU2Ka1gaCOmfd7SmeecVaPvHap4QqTr7Y5tVdbj83vW0kPFjjoG+3nG3obXf8vnSwZkWGrkxz7annefz+sy/nHc/bDsCzrlrv4vJa4ubLVtORTsZ2or0tleQZl69lXXcbX3jDbq7Z1Pymui2ru8gkE6zschN/6USCVV0ZtdFN2tDjNp7X97TjeXCpgzb6KVtXFTdhpHn2VetimdYU4IbNK0klPG6Oc597+3oSHvw/L9rBq2/e0vTvW7OijRVtKTY47tvFdaHiQtGKucVLetudjKFXdWX4XHETxrrutljWNwPoKaYfvzmmC3sAT3vSGtpSCZ4/uJEPvfJ6J/MRm1d3Oj2lv76nnfZ0gp4YpsAXtzxbYDhujDHvBN4D/Lvv+8+o8JxtzJ86G/B9f6TS79u1a1dh79697i/0IvT42BSnJ7I82eGN/tTELKscDSKWq8nZORKe52wSO5cvMD6VdTa4AxidnKW3Ix3bTn+hUOD42ZlYL+JOZ3PkC4Wmd9SUO3l2htUOU9mNT2dpTyVjWSfuQjGXyzMxk2t6d1u5k2dnWNWVcRZ/rfgsunbi7AwrOzPO6la0wujkbNO7ksuNTWXpzCSdLbrOzOWYncvT3UTqC3Hfz5mYmSOZcNfm5/MFzkzPOb3nuDYxMwdAl4MFqVYZm8zS3Z5ydrJ+OptjLl9wsghnqc/dvDPTWTKphLOUZNlcnknHbb7rtsW1XL7A6cnZWKZStqZmc3gezu6zhUKBUxOzTvvcY5NZutqSsd1QcCGYncszPZdrKsXXYq7HVq4/i61w7Mw0a1e0xXqcPzaVdXpfPD0xS09H2tk4YzqbI5cvxLqfcyFw3c9x3ebn8gXOzszFsqawNT6dJZ1I0NHkhp5Wcj23ODkbjDNczW3k88E9x+V8qpxfnufdWygUdtV6Xpzv2NPFr9U+heWz31MtvJZl5ZLeDi7p7XD6OzWAb57ryetkwnN+k4/zAB6CnbpxXjSD1gyYXA7sAKcDz+UqlUzQ2+l2EsT1+xznwbsV5wk5y/V90fUgrC2VjGW9iguN636O60mVRMKL9aIZxHvBzHL9b9iK+6z63M1zvZEg3YI2P+597mTCi30b7XrC0PM8532xuN+3LwSZVML5Zj/X73OcJ6+tuI+hPc9zfl90PVdyIYytLgSu+zmu2/xkwov1ohlcGPM5ruPZ9XxqogXzqRJPcd66dLr4tdr5UZtvJg+Mt/ZyRERERERERERERERE5GIW54WzB4tfLzXGVFoOtxU/D/q+nz0P1yQiIiIiIiIiIiIiIiIXqTgvnP0UmCFI1bi7wnOeWfx613m5IhEREREREREREREREbloxXbhzPf9s8DXi9++cfHjxpg1wIuK395xvq5LRERERERERERERERELk6xXTgreg9B/bKXG2PebIzxAIwxq4DbgW7gx8C/RneJIiIiIiIiIiIiIiIicjHwCoVC1NdQlTHmzcDfAR5wBHgC2A50FL9/uu/7h2r9nl27dhX27t3byksVERERERERERERERGRGPI8795CobCr1vPifuIM3/c/CNwCfBVoA64BHgc+AOyoZ9FMREREREREREREREREpJbYnzhzRSfORERERERERERERERElqeL5sSZiIiIiIiIiIiIiIiIyPmghTMRERERERERERERERERllGqRs/zjgOPRn0dF4qurq41ExMTJ6K+DhE5vxT7IsuP4l5keVLsiyw/inuR5UmxL7L8KO6r2lwoFNbWetKyWTiTxhhj9vq+XzPXp4hcXBT7IsuP4l5keVLsiyw/inuR5UmxL7L8KO6bp1SNIiIiIiIiIiIiIiIiImjhTERERERERERERERERATQwplU9pGoL0BEIqHYF1l+FPciy5NiX2T5UdyLLE+KfZHlR3HfJNU4ExEREREREREREREREUEnzkREREREREREREREREQALZyJiIiIiIiIiIiIiIiIAFo4ExEREREREREREREREQEgFfUFSHwYY34FeBtwM9ADjABfBv7S9/1TUV6biIRjjHk34Nd42pt83/+HJV6bAt4MvBq4AsgB9wEf8X3/k44vVUQaYIzZADwHuBHYBVwHdABDvu/vrPHa0LFtjNkM/Dnwa8B64CTwXeCvfN+/r5m/k4hUFzbujTGPAJtr/PoO3/enK7xecS8SEWOMRzA+fwHwdGA7wVh9FPgp8Engc77vL1m83hjTCfwx8BJgKzAF/AT4O9/3v1rj/30t8HbgFmA1cBT4OvAXvu8/1uzfTUSW1kzcG2OWvBeUOer7/oYq/2/FvUiEjDHPJ+hz3wD0A2uAOeAR4BvAByrFosb57unEmQBgjHkT8D2ChjkL3A9sBN4KDBUDSEQuXMeAH1X47/HFTzbGtAHfBP4WGAQOFp/3VOATxphPFTv0IhKNlwGfBn6fIC476nlRM7FtjLkR2A+8nmDwfgBIAy8H9hpjfqOZv5CI1BQq7svcR+W+QH6pFyjuRSL3LIIY/VPgaQQT50MEcznPBT4DfLXYvi9gjFkF3AO8G7gceBAYJ1iA/4ox5r2V/qfGmBcAe4HfIYj5A0Avwb1gvzHmejd/PRFZQui4L7OXpdv7uyu9QHEvEgt/BPwecD3BwtcB4DjBAvofAvcbY56z+EUa57eGTpwJxpjrgP9O0Ai/Bfgfvu8Xih3tO4BnA18Adkd3lSLSpK/5vv+aBp7/VwS7zB4Dnmd3mBhjngF8BXgVcBfwIbeXKSJ1Gge+RTC43Uuwo+y/1vG6ULFd3LH+zwQd6c8At/m+P2mMSQN/AfwJcLsx5nLf9482/bcTkaWEjXvrLb7vf6/eJyvuRWLBAw4BHwBu933/mH3AGPMq4KPA84D3EEyyl/sYcDXBhPvzfd8fLr7uRcDngHcYY/7D9/2vlb/IGHNJ8fEM8DfAO33fzxbvCR8BXgH8L2PMlZVOqopIU5qJe+vFvu8/Uu//UHEvEhv/CLwX+KHv+zP2h8aYy4qPPQP4vDFms+/7k2Wv0zi/BXTiTADeCSQJjnp/0B73LqZnfBlwBrjJGPO8CK9RRM4TY8xa4P8qfntr+bFs3/d/QNBwArzLGJM839cnIuD7/j/6vv9c3/ff7vv+F1ni5OhiTcb2rQSpIg4VXztZfF0W+DPgP4BugpTPItICYeK+SYp7kejdA1zp+/7flU+eA/i+/2mCiXOAW40xpfkdY8wg8FsEp0lfZhfNiq+7E3h/8Vv7+nJ/DHQBP/J9/8+KMU/xHvCfCe4Jlxb/LCLuhYr7JinuRWLA9/1P+b7/7fJFs+LPHyZIuwxB+sZn2sc0zm8dLZwtc8aYFcCvF7895+SI7/sngDuL3770fF2XiETqhQQ7zR72ff+bSzz+KWAS2EBZYy0isddMbNtO+j8u0YkvAB9e9DwRufAp7kUi5vv+uJ3ArsCeFlsFrC37+YuLX7/r+/4DS7zO1jfeZYzZtuixFy96Tvn1zACfKH6r+QGRFmgi7puhuBeJueKJr1PFbzvLHtI4v0W0cCbXAe3ALJVzHX+/+PXm83JFItIKg8aYzxljvmOM+bIx5r3GmKsrPNfG+g+WerCYmuGeRc8VkfgLFdvFXWk3Vnst832FS40xm5q8ThFpjTcaY/7FGPNtY8xnjTFvNMZ0L/VExb3IBaO81uFU2Z9rtfmPAY8sei7GmAGCnecVX8t87N+o7BMikagU9+XeaYz5mjHmm8aYTxhjXl2pJpriXuTCYIzZTrBgngd+WvaQxvktooUzuaL49dEqO1oeLn7dVsxxKiIXnp0ERX5/FXgB8A7ggDHmb5fo+Nr7wi+r/D57X7jS6VWKSCuFje0tBDvYqr12GLD9CN0XROLppQQ1UZ5FUOz7Q8BBY8xzl3juFhT3IheC3yl+HfJ9f7zs52HbfPu6WYIYr/a6dmBzndcpIu5UivtyrwN+DXgO8LvAJ4EHjDHXL/Fcxb1ITBljPGPMOmPMbxPUKgN4v+/7B8uepnF+i2jhTFYVv56q8hz7WIKgWKCIXDiOAO8CbiJI49AO7CBIweABf0BQRLRcI/eFlc6uVERaLWxsr1ri8QV8388Do0u8VkSi9z3g1cB2gvolK4HnE+xUXQN8ZYmJNMW9SMwZY24A3lj89q8XPdxsm3/a1j6v8rrFrxWRFqsR9wBfBl4EXE5wMm0twULbQYJJ8m8UT5iVU9yLxIwx5pXGmALB6bKjwBcJFrdf7vv+ny56usb5LZKK+gIkcu3Fr7NVnjNd9ueOis8Skdjxff8jS/z4APAmY8wh4G+APzTG/L3v+48UH2/kvqB7gsiFI2xst5f9WfcFkQuM7/uvWfSjSeBfjDHfBn4IXA+8j2BXuqW4F4kxY8x64J8J5nT+l+/7ty96SrNtvuYHRGKmjrjH9/3fXPSjaeB2Y8y3gHuBSwEfuLXsOYp7kfg5BvyI4BDLJoJ0qlcCrzTG/Lvv+yNlz9U4v0V04kzshz9T5TnlgVQpf7KIXHj+X4ITaSmC9I1WI/cF3RNELhxhY7t8oKz7gshFwvf9KeDPi9/+qjGmfBep4l4kpowxvcDXCCbA7wVes8TTmm3zNT8gEiN1xn1Fvu+fYD7TzG8ZY7yyhxX3IjHj+/43fN9/uu/7T/V9fzPBidEvAL8B7CneEyyN81tEC2dyuvh1dZXn2KObeaBS/mQRucD4vp8D7i5+e3nZQ43cF05XeY6IxEvY2C7/85KvNcYkgL4lni8i8fYfxa8JYFvZzxX3IjFkjFkBfB24Drgf+E8Vahw12+avXDSxvtTrFr9WRFqggbivxbb5q1g6jhX3IjHl+/6w7/uvIDiFtgl4c9nDGue3iBbO5MHi10uNMekKz7ms+PWg7/vZCs8RkQuTPY5dnrrX3heeVOV19r7wYJXniEi8hI3tQ8zfKyq9dgCw/QjdF0QuHOVpWcr7Aop7kZgxxnQC/wrsBh4CnuP7/skKTw/b5ts/ZwhOtlR73TTwaLVrFpHmNBj3tVRq8xX3IheOfyl+vaHsZxrnt4gWzuSnwAxBA7m7wnOeWfx613m5IhE5n64pfi3Pj2xj/VeWeoExph14yqLnikj8hYrt4unUHxe/fUaF3237CsO+7x9u8jpF5Py5puzPpb6A4l4kXopt9FcI4vER4Nm+7z9R5SW2HV8yfo0xlxKkfQLYY3/u+/4wYOO5Vuz/uHivEJEWCBH3tdg2fxooLb4p7kUuKHbRO1n2M43zW0QLZ8uc7/tnCY58A7xx8ePGmDXAi4rf3nG+rktEWs8Y8zzg6uK33yh76CsEu04uM8Y8d4mXvhroBI4CP2jpRYqIS83E9p3Fr681xrSVP1BM6XJb8Vv1FUQuLH9a/PqzJQbDinuRGChmhvki8GyCBe5n+b4/Uv1Vpfi9xRhz1RKP27H/vb7vP1zhtbct+jnFe8Frit8q9kVaJGTcV/t9KeCPit9+x/f9uUVPUdyLxFwxbeJvFb/9adlDGue3iBbOBOA9BPXLXm6MebPNaWyMWQXcDnQTrED/a3SXKCKNMsZcbYz5sDFmcNHPE8aY3wE+V/zRv/i+b3eZ4Pv+MeDvi99+zBhzTdlrnwG8r/jte5focItITDUZ2x8BjgBbi6/tLL4uDfw18FTgLPD+1v0NRKRRxpi3GWPeYoxZvejnq40xH2Z+g9y7lni54l4kYsaYJEGf/TeAJwgmzw/Vep3v+/uALxHM+dxujBko+50vAt5W/PbdS7z8fcAk8DRjzF/bkg7Fe8DHCO4Jw8DHQ/61RKSKsHFfjNffNcZ0L/r5AMHk+G5gjmAOcDHFvUjEjDG7jDF/YYy5conHthLE8fUE/e+P2cc0zm8dr1AoRH0NEgPGmDcDfwd4BAHzBLAd6Ch+//R6GmoRiQ9jzE7md6GcIshFPkeQu3hl8ef/DrzA9/3RRa9tB/5/guPaeYIixBnANuCfA17p+74aEZEIFAfA5bvM2oAVQA4oj+f3+b7/vrLXhY5tY8xNwDcJNtSMAb8ENgNrCHa4vcj3/a+6+PuJyLnCxL0x5gPAfwEKBGmejhP077cTpHrJA28vv08s+n8q7kUitGiz2yPMp1Nbylt83y/dI4oL5v9OEO9Zgja/j/kUjX/l+/7/XeH/+5sEu8vTwAmCccTlQA8wTpAybm+ov5SIVBU27o0xXwJeSNAvOEgwB9BL0M/3CFI03ur7/mcr/H8V9yIRMsbcAny3+O1JghjMAuuZb7tPAS/2ff87i16rcX4L6MSZAOD7/geBW4CvEgzCrwEeBz4A7NCimcgF6RHgHQSnRUcJFsx2EjR8XwNeBfzq4kUzAN/3p4HnEKRz2E9QSHQjQT7k1/m+/wotmolEKgmsLvtvRYWfd5a/qJnY9n3/bmAHwU7TM8C1BIvxtwO7lmtnWuQ8ChP3twP/DbiboI8/SBD3B4GPAjdUWjQDxb1IDJSnTdoCPK3Kf73lL/R9/yRwI8HpkoeBqwgWzr4DvLDSolnxtV8CdgFfIIj5awkmzj9GMD+gyXOR1gkb9x8CPgzsI5gAvx7oJ5hA/wBwTaVFM1Dci8TAEPD7wD8TLJA9CbiBIJ5/SDC/d+XiRTPQOL9VdOJMREREREREREREREREBJ04ExEREREREREREREREQG0cCYiIiIiIiIiIiIiIiICaOFMREREREREREREREREBNDCmYiIiIiIiIiIiIiIiAighTMRERERERERERERERERQAtnIiIiIiIiIiIiIiIiIoAWzkREREREREREREREREQALZyJiIiIiIiIiIiIiIiIAFo4ExEREREREREREREREQG0cCYiIiIiIiIiIiIiIiICwP8G8PBwfXEw7bQAAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot(fine_classes[0, :300])" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": {}, + "outputs": [], + "source": [ + "wavfile.write('outputs/nb1/model_output.wav', sample_rate, output)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/models/WaveRNNModel/notebooks/NB2 - Fit a Short Sample.ipynb b/models/WaveRNNModel/notebooks/NB2 - Fit a Short Sample.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..9e0ba7935d7662cbaaff63a24dadcca0bf5974ff --- /dev/null +++ b/models/WaveRNNModel/notebooks/NB2 - Fit a Short Sample.ipynb @@ -0,0 +1,333 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# WaveRNN - Fit a Short Sample" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", + "import time, sys, math\n", + "import numpy as np\n", + "import torch\n", + "from torch import optim\n", + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "from scipy.io import wavfile\n", + "from utils.display import *\n", + "from utils.dsp import *\n", + "from models.wavernn import WaveRNN" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "notebook_name = 'nb2'\n", + "sample_rate = 22050" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sample = wavfile.read('data/female_vocal_op8_8.wav')[1]\n", + "coarse_classes, fine_classes = split_signal(sample)\n", + "\n", + "plot(coarse_classes[3000:3100])\n", + "plot(fine_classes[3000:3100])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Instantiate Model and Train" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Trainable Parameters: 3.050 million\n" + ] + } + ], + "source": [ + "model = WaveRNN().cuda()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "coarse_classes, fine_classes = split_signal(sample)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "batch_size = 32\n", + "coarse_classes = coarse_classes[:len(coarse_classes) // batch_size * batch_size]\n", + "fine_classes = fine_classes[:len(fine_classes) // batch_size * batch_size]\n", + "coarse_classes = np.reshape(coarse_classes, (batch_size, -1))\n", + "fine_classes = np.reshape(fine_classes, (batch_size, -1))" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(32, 2521)" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "coarse_classes.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def train(model, optimizer, num_steps, batch_size, seq_len=960) :\n", + " \n", + " start = time.time()\n", + " running_loss = 0\n", + " \n", + " for step in range(num_steps) :\n", + " \n", + " loss = 0\n", + " hidden = model.init_hidden(batch_size)\n", + " optimizer.zero_grad()\n", + " rand_idx = np.random.randint(0, coarse_classes.shape[1] - seq_len - 1)\n", + " \n", + " for i in range(seq_len) :\n", + " \n", + " j = rand_idx + i\n", + " \n", + " x_coarse = coarse_classes[:, j:j + 1]\n", + " x_fine = fine_classes[:, j:j + 1]\n", + " x_input = np.concatenate([x_coarse, x_fine], axis=1)\n", + " x_input = x_input / 127.5 - 1.\n", + " x_input = torch.FloatTensor(x_input).cuda()\n", + " \n", + " y_coarse = coarse_classes[:, j + 1]\n", + " y_fine = fine_classes[:, j + 1]\n", + " y_coarse = torch.LongTensor(y_coarse).cuda()\n", + " y_fine = torch.LongTensor(y_fine).cuda()\n", + " \n", + " current_coarse = y_coarse.float() / 127.5 - 1.\n", + " current_coarse = current_coarse.unsqueeze(-1)\n", + " \n", + " out_coarse, out_fine, hidden = model(x_input, hidden, current_coarse)\n", + " \n", + " loss_coarse = F.cross_entropy(out_coarse, y_coarse)\n", + " loss_fine = F.cross_entropy(out_fine, y_fine)\n", + " loss += (loss_coarse + loss_fine)\n", + " \n", + " running_loss += (loss.item() / seq_len)\n", + " loss.backward()\n", + " optimizer.step()\n", + " \n", + " speed = (step + 1) / (time.time() - start)\n", + " \n", + " stream('Step: %i/%i --- Loss: %.2f --- Speed: %.1f batches/second ',\n", + " (step + 1, num_steps, running_loss / (step + 1), speed)) " + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "optimizer = optim.Adam(model.parameters(), lr=1e-3)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Step: 1000/1000 --- Loss: 6.08 --- Speed: 0.9 batches/second " + ] + } + ], + "source": [ + "train(model, optimizer, num_steps=1000, batch_size=batch_size)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Generate" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gen: 10000/10000 -- Speed: 1186" + ] + } + ], + "source": [ + "output, c, f = model.generate(10000)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot(output[:100])" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot(f[:100])" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "def save_wav(y, filename, sample_rate) :\n", + " y = np.clip(y, -2**15, 2**15 - 1)\n", + " wavfile.write(filename, sample_rate, y.astype(np.int16))" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "save_wav(output, f'outputs/{notebook_name}/1k_steps.wav', sample_rate)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/models/WaveRNNModel/notebooks/NB3 - Fit a 30min Sample.ipynb b/models/WaveRNNModel/notebooks/NB3 - Fit a 30min Sample.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..1f5e9e8ea7433b6b7ad57afcde59416b5ec9b77e --- /dev/null +++ b/models/WaveRNNModel/notebooks/NB3 - Fit a 30min Sample.ipynb @@ -0,0 +1,404 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# WaveRNN - Fit a 30min Sample" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import time, sys, math\n", + "import numpy as np\n", + "import torch\n", + "from torch import optim\n", + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "from scipy.io import wavfile\n", + "from utils.display import *\n", + "from utils.dsp import *\n", + "from models.wavernn import WaveRNN" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "notebook_name = 'nb3'\n", + "sample_rate = 22050" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "sample = wavfile.read('data/podcast.wav')[1]" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(-28400, 29026)" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sample.min(), sample.max()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Split/Combine Functions" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def split_signal(x) :\n", + " unsigned = x + 2**15\n", + " coarse = unsigned // 256\n", + " fine = unsigned % 256\n", + " return coarse, fine" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def combine_signal(coarse, fine) :\n", + " return coarse * 256 + fine - 2**15" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot(sample[73000:73100])" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "coarse_classes, fine_classes = split_signal(sample)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot(coarse_classes[73000:73100])" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot(fine_classes[73000:73100])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Train Model" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Trainable Parameters: 3.050 million\n" + ] + } + ], + "source": [ + "model = WaveRNN().cuda()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "coarse_classes, fine_classes = split_signal(sample)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "batch_size = 128 # 8gb gpu\n", + "coarse_classes = coarse_classes[:len(coarse_classes) // batch_size * batch_size]\n", + "fine_classes = fine_classes[:len(fine_classes) // batch_size * batch_size]\n", + "coarse_classes = np.reshape(coarse_classes, (batch_size, -1))\n", + "fine_classes = np.reshape(fine_classes, (batch_size, -1))" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(128, 366411)" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "coarse_classes.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "def train(model, optimizer, num_steps, batch_size, lr=1e-3, seq_len=960) :\n", + " \n", + " for p in optimizer.param_groups : p['lr'] = lr\n", + " start = time.time()\n", + " running_loss = 0\n", + " \n", + " for step in range(num_steps) :\n", + " \n", + " loss = 0\n", + " hidden = model.init_hidden(batch_size)\n", + " optimizer.zero_grad()\n", + " rand_idx = np.random.randint(0, coarse_classes.shape[1] - seq_len - 1)\n", + " \n", + " x_coarse = coarse_classes[:, rand_idx:rand_idx + seq_len]\n", + " x_coarse = torch.FloatTensor(x_coarse)\n", + " x_coarse = x_coarse / 127.5 - 1.\n", + " x_fine = fine_classes[:, rand_idx:rand_idx + seq_len]\n", + " x_fine = torch.FloatTensor(x_fine)\n", + " x_fine = x_fine / 127.5 - 1.\n", + " \n", + " y_coarse = coarse_classes[:, rand_idx + 1:rand_idx + seq_len + 1]\n", + " y_coarse = torch.LongTensor(y_coarse)\n", + " y_fine = fine_classes[:, rand_idx + 1: rand_idx + seq_len + 1]\n", + " y_fine = torch.LongTensor(y_fine)\n", + " \n", + " for i in range(seq_len) :\n", + " \n", + " x_c_in = x_coarse[:, i:i + 1]\n", + " x_f_in = x_fine[:, i:i + 1]\n", + " x_input = torch.cat([x_c_in, x_f_in], dim=1)\n", + " x_input = x_input.cuda()\n", + " \n", + " c_target = y_coarse[:, i].cuda()\n", + " f_target = y_fine[:, i].cuda()\n", + " \n", + " \n", + " current_coarse = c_target.float() / 127.5 - 1.\n", + " current_coarse = current_coarse.unsqueeze(-1)\n", + " \n", + " out_coarse, out_fine, hidden = model(x_input, hidden, current_coarse)\n", + " \n", + " loss_coarse = F.cross_entropy(out_coarse, c_target)\n", + " loss_fine = F.cross_entropy(out_fine, f_target)\n", + " loss += (loss_coarse + loss_fine)\n", + " \n", + " running_loss += (loss.item() / seq_len)\n", + " loss.backward()\n", + " optimizer.step()\n", + " \n", + " elapsed = time_since(start)\n", + " speed = (step + 1) / (time.time() - start)\n", + " \n", + " stream('Step: %i/%i --- Loss: %.3f --- %s --- @ %.1f batches/sec ',\n", + " (step + 1, num_steps, running_loss / (step + 1), elapsed, speed)) " + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "optimizer = optim.Adam(model.parameters())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "train(model, optimizer, num_steps=10000, batch_size=batch_size, lr=1e-3)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Generation" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "output, c, f = model.generate(sample_rate * 5)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plot(output[:1000])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plot(f[:100])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def save_wav(y, filename, sample_rate) :\n", + " y = np.clip(y, -2**15, 2**15 - 1)\n", + " wavfile.write(filename, sample_rate, y.astype(np.int16))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "save_wav(output, f'outputs/{notebook_name}/model_output.wav', sample_rate)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/models/WaveRNNModel/notebooks/NB4a - Alternative Model (Preprocessing).ipynb b/models/WaveRNNModel/notebooks/NB4a - Alternative Model (Preprocessing).ipynb new file mode 100644 index 0000000000000000000000000000000000000000..6bbee409c0ac12c799765ea2e495ca06b95b738f --- /dev/null +++ b/models/WaveRNNModel/notebooks/NB4a - Alternative Model (Preprocessing).ipynb @@ -0,0 +1,283 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Alternative Model (Preprocessing)\n", + "You need to run this before you run notebook 4b.\n", + "\n", + "The wavs in your dataset will be converted to 9bit linear and 80-band mels." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from multiprocessing import Pool, cpu_count\n", + "import math, pickle, os, glob\n", + "import numpy as np\n", + "from utils.display import *\n", + "from utils.dsp import *" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "bits = 9\n", + "notebook_name = 'nb4'" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Point SEG_PATH to a folder containing your training wavs \n", + "# Doesn't matter if it's LJspeech, CMU Arctic etc. it should work fine\n", + "SEG_PATH = '/path/to/your/wavs/'\n", + "DATA_PATH = f'data/{notebook_name}/'\n", + "%mkdir -p $DATA_PATH" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def get_files(path, extension='.wav') :\n", + " filenames = []\n", + " for filename in glob.iglob(f'{path}/**/*{extension}', recursive=True):\n", + " filenames += [filename]\n", + " return filenames" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "10826" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "wav_files = get_files(SEG_PATH)\n", + "len(wav_files)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def convert_file(path) :\n", + " wav = load_wav(path, encode=False)\n", + " mel = melspectrogram(wav)\n", + " quant = (wav + 1.) * (2**bits - 1) / 2\n", + " return mel.astype(np.float32), quant.astype(np.int)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "m, x = convert_file(wav_files[1])" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_spec(m)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "x = 2 * x / (2**bits - 1) - 1" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "librosa.output.write_wav(DATA_PATH + 'test_quant.wav', x, sr=sample_rate)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "QUANT_PATH = DATA_PATH + 'quant/'\n", + "MEL_PATH = DATA_PATH + 'mel/'\n", + "%mkdir -p $QUANT_PATH\n", + "%mkdir -p $MEL_PATH" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'ch18b_211'" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "wav_files[0].split('/')[-1][:-4]" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "def process_wav(path) :\n", + " id = path.split('/')[-1][:-4]\n", + " m, x = convert_file(path)\n", + " np.save(f'{MEL_PATH}{id}.npy', m)\n", + " np.save(f'{QUANT_PATH}{id}.npy', x)\n", + " return id" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing: 10826/10826" + ] + } + ], + "source": [ + "# This will take a while depending on size of dataset\n", + "pool = Pool(processes=cpu_count())\n", + "dataset_ids = []\n", + "for i, id in enumerate(pool.imap_unordered(process_wav, wav_files), 1):\n", + " dataset_ids += [id]\n", + " stream('Processing: %i/%i', (i, len(wav_files)))" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "with open(DATA_PATH + 'dataset_ids.pkl', 'wb') as f:\n", + " pickle.dump(dataset_ids, f)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "10826" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(dataset_ids)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/models/WaveRNNModel/notebooks/NB4b - Alternative Model (Training).ipynb b/models/WaveRNNModel/notebooks/NB4b - Alternative Model (Training).ipynb new file mode 100644 index 0000000000000000000000000000000000000000..043f956a1020c697ad7965658ac9010020a3f461 --- /dev/null +++ b/models/WaveRNNModel/notebooks/NB4b - Alternative Model (Training).ipynb @@ -0,0 +1,1031 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Alternative Model (Training)\n", + "\n", + "I've found WaveRNN quite slow to train so here's an alternative that utilises the optimised rnn kernels in Pytorch. The model below is much much faster to train, it will converge in 48hrs when training on 22.5kHz samples (or 24hrs using 16kHz samples) on a single GTX1080. It also works quite well with predicted GTA features. \n", + "\n", + "The model is simply two residual GRUs in sequence and then three dense layers with a 512 softmax output. This is supplemented with an upsampling network.\n", + "\n", + "Since the Pytorch rnn kernels are 'closed', the options for conditioning sites are greatly reduced. Here's the strategy I went with given that restriction: \n", + "\n", + "1 - Upsampling: Nearest neighbour upsampling followed by 2d convolutions with 'horizontal' kernels to interpolate. Split up into two or three layers depending on the stft hop length.\n", + "\n", + "2 - A 1d resnet with a 5 wide conv input and 1x1 res blocks. Not sure if this is necessary, but the thinking behind it is: the upsampled features give a local view of the conditioning - why not supplement that with a much wider view of conditioning features, including a peek at the future. One thing to note is that the resnet is computed only once and in parallel, so it shouldn't slow down training/generation much. \n", + "\n", + "Train this model to ~500k steps for 8/9bit linear samples or ~1M steps for 10bit linear or 9+bit mu_law. " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import math, pickle, os\n", + "import numpy as np\n", + "import torch\n", + "from torch import optim\n", + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "from torch.utils.data import Dataset, DataLoader\n", + "from utils.display import *\n", + "from utils.dsp import *" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1375" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bits = 9\n", + "pad = 2\n", + "seq_len = hop_length * 5\n", + "seq_len" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "notebook_name = 'nb4'" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "%mkdir -p 'model_checkpoints/'" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "MODEL_PATH = f'model_checkpoints/{notebook_name}.pyt'\n", + "DATA_PATH = f'data/{notebook_name}/'\n", + "STEP_PATH = f'model_checkpoints/{notebook_name}_step.npy'\n", + "GEN_PATH = f'model_outputs/{notebook_name}/'\n", + "%mkdir -p $GEN_PATH" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "with open(f'{DATA_PATH}dataset_ids.pkl', 'rb') as f:\n", + " dataset_ids = pickle.load(f)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "test_ids = dataset_ids[-50:]\n", + "dataset_ids = dataset_ids[:-50]" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "code_folding": [] + }, + "outputs": [], + "source": [ + "class AudiobookDataset(Dataset):\n", + " def __init__(self, ids, path):\n", + " self.path = path\n", + " self.metadata = ids\n", + " \n", + " def __getitem__(self, index):\n", + " file = self.metadata[index]\n", + " m = np.load(f'{self.path}mel/{file}.npy')\n", + " x = np.load(f'{self.path}quant/{file}.npy')\n", + " return m, x\n", + "\n", + " def __len__(self):\n", + " return len(self.metadata)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "def collate(batch) :\n", + " \n", + " mel_win = seq_len // hop_length + 2 * pad\n", + " max_offsets = [x[0].shape[-1] - (mel_win + 2 * pad) for x in batch]\n", + " mel_offsets = [np.random.randint(0, offset) for offset in max_offsets]\n", + " sig_offsets = [(offset + pad) * hop_length for offset in mel_offsets]\n", + " \n", + " mels = [x[0][:, mel_offsets[i]:mel_offsets[i] + mel_win] \\\n", + " for i, x in enumerate(batch)]\n", + " \n", + " coarse = [x[1][sig_offsets[i]:sig_offsets[i] + seq_len + 1] \\\n", + " for i, x in enumerate(batch)]\n", + " \n", + " mels = np.stack(mels).astype(np.float32)\n", + " coarse = np.stack(coarse).astype(np.int64)\n", + " \n", + " mels = torch.FloatTensor(mels)\n", + " coarse = torch.LongTensor(coarse)\n", + " \n", + " x_input = 2 * coarse[:, :seq_len].float() / (2**bits - 1.) - 1.\n", + " \n", + " y_coarse = coarse[:, 1:]\n", + " \n", + " return x_input, mels, y_coarse" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "dataset = AudiobookDataset(dataset_ids, DATA_PATH)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "data_loader = DataLoader(dataset, collate_fn=collate, batch_size=32, \n", + " num_workers=0, shuffle=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "10776" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(dataset)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(torch.Size([32, 1375]), torch.Size([32, 80, 9]), torch.Size([32, 1375]))" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x, m, y = next(iter(data_loader))\n", + "x.shape, m.shape, y.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABBEAAAD8CAYAAAAhbjwkAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4wLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvpW3flQAAIABJREFUeJzt3X2snOV55/Hf9czLmfPmNzCOwTQmDUuWRgVSRNJNN2JDqMg2ClVVIehu5e0ief9oq2S7UqH9Y7eVulIqrdrmr0gWpHW0KS9NgkBRNk3kBnUrdSnmpZsAIQUKwcZgXmxsn7eZeebaP86gdanxuc/zjOee6/j7kVDOjOflJ915Zp65n+u6b3N3AQAAAAAArKXIHQAAAAAAAMTAJAIAAAAAAEjCJAIAAAAAAEjCJAIAAAAAAEjCJAIAAAAAAEjCJAIAAAAAAEjCJAIAAAAAAEhSaxLBzG4ys2fN7Dkzu3NUoQAAAAAAwOQxd6/2RLOGpB9JulHSIUmPSrrN3Z8eXTwAAAAAADApmjWee52k59z9BUkys3sl3SzpPScR2jblHc3WeEsAAAAAADBqy1pQ11dsrcfVmUS4RNLLp90+JOmjZ3tCR7P6qN1Q4y0BAAAAAMCoPeIHkh5XZxIhiZntlbRXkjqaOddvBwAAAAAAzpE6kwiHJV162u1dw/v+CXffJ2mfJG1uXuiNuU013hI5eVnmjgAA4Xi/nzsCKvJuN3cE1FBMT+eOgBpsupM7AqqyNavhMaHsWCPpcXV2Z3hU0uVmdpmZtSXdKumhGq8HAAAAAAAmWOVKBHfvm9lvSPpLSQ1JX3b3p876pKKQzTArHFY5yJ0AOD/1uBoamXWmckdAVc3NuROgjkG1HcgwIQquZgPjl3bc1VoTwd2/JelbdV4DAAAAAADEUKedAQAAAAAAnEfO+e4M/4RLTkk8MH4DFsUMrdXOnQB1UJIL5MF3X2z8ZIiLVqK4PG3sqEQAAAAAAABJmEQAAAAAAABJxtzO4KwyHph12K83rGbanq+YUAXzvZF5v587AqoqKYePzFqt3BFQA5+dgXHaEldiByZDDAAAAAAAkjCJAAAAAAAAkoy1naG3taOjv3TlON8SI9SbZYXxqHpzuRMA568BFdVhGQuMh1as5E6AOmZf4QCMqqQDOqze19MGj0oEAAAAAACQZKyVCOW09NZPs+lrVMUFTOlHtXXTYu4IqKFfMt8bWavJ4nxRFZQihHZikcuhkb1xyWzuCKjIp/i9F1X5v9K+9zgzBQAAAAAASZhEAAAAAAAAScbazqDC5R3KW6JqNBi7qNpN9lqObPvscu4IqGHgLEob1XKfVTEjG0zThhnZ8qZ27gioqChoBQsrceyoRAAAAAAAAEmYRAAAAAAAAEnG285gkrVZpToq2hniKgfMF0a2Uo73oxqjNdWgnSiqmVY3dwTUcGJ5KncE1OA9zl2i8gFtfGEljh1HJwAAAAAASMIkAgAAAAAASLJmjayZfVnSZyQddfcPD+/bJuk+SbslvSjpFnc/tuZrFa4m7QxhNZuMXVSNglaUyGhHiW1lzJ2DAFY1acMMzZqMX1S+3MgdAedYypnpn0m66V333SnpgLtfLunA8DYAAAAAANjA1rw84u5/bWa733X3zZKuH/69X9LDku5Y87X6hfpvddYVEJPj1DyzikAOnRYL80XmzgJTUU01OfYiW+q2ckdADSysGBjfe3F52sOqHp073P3I8O9XJe2o+DoAAAAAACCI2lN87u46y5yFme01s4NmdrA8daru2wEAAAAAgEyqrvb0mpntdPcjZrZT0tH3eqC775O0T5Km3r/L3RJrJDB5upSVRbW0yF7ZkbXmWdQ0spUeJdVRvX1yOncE1NDv0oYZmbE4X1jeZlHMsBI7Uar+KnxI0p7h33skPVjxdQAAAAAAQBBrTiKY2T2S/lbSFWZ2yMxul/QFSTea2T9I+tTwNgAAAAAA2MBSdme47T3+6YZ1v5tJatDOEBbdDEAWvZKSzsicr72wZmdWckdADSutql27mARL7M4QljX54gvrHLczAAAAAACA88x4p2gHxiIpgXmD/bKjKllcKrSFQSd3BNTgJftlR7XEXueheZ/xC63Ptc6w2vxmCItKBAAAAAAAMEpMIgAAAAAAgCTjbWcwSSy0EVeXOaeonJXdQrMG+y1H1pnt5o6AivqUU4fWW2znjoAajHaUsAoW0g8sbez4dgQAAAAAAEmYRAAAAAAAAEnGvDuDZCuUJkVVsEp1WGVBOXxkg2X2Oo9sifGLi3Lq2ApKqkOb7+VOgIpa7M4QlrE7AwAAAAAAGCUmEQAAAAAAQJLx1li6VHQpDYzKW5QFhsXQxcb4hWYrzNdH1TrB2EVmZe4EqKO7heMvql6LNtqoUjd04+gEAAAAAABJxlqJYC4VrLMR1qCgiiQq6zJfGJkzox+az3A5NKrePCctkflyI3cE1NB+g/GLqjvVyh0BVQ3Sfu/xywIAAAAAACRhEgEAAAAAACQZ++bVRlVuWI3l3AlQVdGjFSWy3hbGLzLvMV8flfdZ1TQyK/nsBHJovTX2n5gYEevTzgAAAAAAAEaISQQAAAAAAJBkzVoTM7tU0lck7dDqbuX73P2LZrZN0n2Sdkt6UdIt7n7sbK/lDam7mdLAsArGLipvMHaRFcvM90ZWOCXVUTmHXmwcerExfnFx2rnhpXw99iX9F3e/UtLHJP26mV0p6U5JB9z9ckkHhrcBAAAAAMAGtWYlgrsfkXRk+PdJM3tG0iWSbpZ0/fBh+yU9LOmOs76YOfudB2ZcTYtrmn3qI0vcshcTauZlFpiKasDQhdbdyjlnZL05LmdH1VzkxGWjW1ehnpntlnSNpEck7RhOMEjSq1ptdwAAAAAAABtU8iSCmc1J+rqkz7v7idP/zd1d79H9YmZ7zeygmR0sTy3UCgsAAAAAAPJJKtQzs5ZWJxC+6u7fGN79mpntdPcjZrZT0tEzPdfd90naJ0lTl17qzVONEcRGDnQzxOXdVu4IqIGFMWNb2UZJdVRFly++yFonWBkzskGb776w+Ojc8Nb8dDUzk3S3pGfc/Y9O+6eHJO0Z/r1H0oOjjwcAAAAAACZFSiXCxyX9qqTvm9mTw/t+V9IXJN1vZrdLeknSLecmIgAAAAAAmAQpuzP8jd67KOWGdb2bUZoUmbcYu6i8YOxCoywwtAG9YGENpmlFCY2vvtCcnaXCakz3c0dARd5O+96jWQwAAAAAACRhEgEAAAAAACRJ2p0BkKTWMeacorKScurIevOUVEc26DB+UdmAz87IGguct4TG+IXV38JnZ1iJ33scnQAAAAAAIMnYKxFY4C2uQZtZxagGTa6ERjaYYfxCa/C9F5U3OPYi63POGVr7rUbuCKjIVrhOHRaVCAAAAAAAYJSYRAAAAAAAAEnG285gLm9RWhZV6YxdVO23aUWJrFcw3xsZ33txOa1goZnz3RdZbwvHX1SNbSu5I6CqxO89zkwBAAAAAEASJhEAAAAAAECS8bYzuKlYZt4iKmeF8bBWLqIkMDQOvdj47IyL1f1Dc/HdF1lzvpc7AiraunkhdwRU9GrirkT8ogcAAAAAAEmYRAAAAAAAAEnG284gyZuUBkbFCuNxFXOUBAK5DHrM1wNZ0EoUmhW0o0S13Bv7T0yMyCBxVxvObAAAAAAAQJIxL6woFSvs2RuVLTHnFFXZKXNHQA3GXvWxsVd9WLbQyB0BNbCYd2y9eY6/qGxr7gSoyqlEAAAAAAAAo8QkAgAAAAAASDL+VS8o6wyr7FBSHZV3mS+MzAd8bobGR2dYPksrWGR8dMbWOMW5S1S9aRZWjCr1nHPNo9PMOmb2d2b292b2lJn9/vD+y8zsETN7zszuM7N2zcwAAAAAAGCCpUzxrUj6pLtfJelqSTeZ2cck/aGkP3b3D0o6Jun2cxcTAAAAAADktmatibu7pFPDm63hfy7pk5J+ZXj/fkm/J+lLZ3stc6nRrRoV2Rl1gVENGpQEhtbu506AGmhHAfJwdiYKbeDszhCV9zjvDMvTHpY0wmbWMLMnJR2V9F1Jz0s67u7vnNkeknTJezx3r5kdNLOD5cJCWioAAAAAADBxkla9cPdS0tVmtkXSA5I+lPoG7r5P0j5J6lxyqRuTwmENWrkTAOcpS5wWxkRqzvDFF1V/kcXBIitOMH6RNbpUcUXVm2JF4Y1uXbUm7n5c0vck/aykLWb2zqfzLkmHR5wNAAAAAABMkJTdGbYPKxBkZtOSbpT0jFYnE355+LA9kh48VyEBAAAAAEB+KXVeOyXtN7OGVicd7nf3b5rZ05LuNbM/kPSEpLvXeiFvSN0tlLdE5U1KqqNqbV3JHQE1DAYsUBRZs0U7Q1gzuQOgjsFJ2hkiowU6MDpRNryU3Rn+r6RrznD/C5KuOxehAAAAAADA5OHyFgAAAAAASEKdF9Kx0mpY/S57LUfmJfO9kRm7a4Q1GFCTGxltmLF139df+0GYSEWbXpSwirTPTc5MAQAAAABAEiYRAAAAAABAkvG2MxQun6W8JSpKk+IqGpR0Rtaa7eaOgBqmWpTkRrW00sodATV057lWFtnM/HLuCKhofppdwaI62kxrX+fTFQAAAAAAJBlrJULRHGhu2+I43xIjtLTUzh0BFTWaVJFExpXs2IqCRWmBHCzxihom09bZpdwRUNEHNr+ROwIqer7RS3oclQgAAAAAACAJkwgAAAAAACDJeNsZCtfsFAuERbWyMt51ODE63WUWB4us32/kjoAaBn3m66OanmVxsMhajF9oPzF/LHcEVLS9fSp3BFTUNBZWBAAAAAAAI8QkAgAAAAAASDLW+vRyYDqx2BnnWwLQ6s4oiIty+Ni8y/iFNZs7AOqghTa25ZI22qhe787ljoCK+p52zsKZDQAAAAAASMIkAgAAAAAASDLWOiEfFFpebI/zLTFClOQG5pY7Aeowz50ANRRTZe4IqKgs+d6LrMf4hfbGEiXxUb3dnc4dARV1B2nTA3y6AgAAAACAJONdsWTA1ezIbIW96qPymX7uCKiBhTFj8wGVQFF1l1u5I6CGJp+doXVanLuEVfKbISpPLH5N/kVvZg0ze8LMvjm8fZmZPWJmz5nZfWZGnwIAAAAAABvYesoCPifpmdNu/6GkP3b3D0o6Jun2UQYDAAAAAACTJamdwcx2SfoFSf9d0m+ZmUn6pKRfGT5kv6Tfk/Sls75Q4WpQVh1WyeJ8QBbNNgvzRcbifHGVS+xTH1mvR0l1ZK2CdpSoBvxm2PBSz2z+RNJvS3rnaL5A0nF3f2dG4JCkS870RDPba2YHzexgeXKhVlgAAAAAAJDPmpMIZvYZSUfd/bEqb+Du+9z9Wne/tjE/W+UlAAAAAADABEip0/u4pM+a2b+V1JG0SdIXJW0xs+awGmGXpMNrvlJpKk+w/mJU1qGkOipjherQyj4luUAWReIy1ZhI3QXOOSPrb6YVLCo+OTe+NY9Od/8dd9/l7rsl3Srpr9z930n6nqRfHj5sj6QHz1lKAAAAAACQXZ0Vg+6QdK+Z/YGkJyTdveYzGq5irlfjLZGTsUZKWAWLE4XWo4IrNJvi+Iuq1WEx6NCM66GRsaB3XFMNqpejSj3q1jWJ4O4PS3p4+PcLkq5bVyoAAAAAABAWzUYAAAAAACDJeDdAdtOgx7xFWJSVhVVMU04dWpvxi8wHfHZGNRhwzhJZQUl1aCXHX1jWpBUsrMRTFo5OAAAAAACQhEkEAAAAAACQZLztDOYqWpTlhsUix0AWrBAfW7/byB0BFQ3eZGeUyNoXL+SOgBp2b34rdwRU1C3H+xMTo9OwtN/qVCIAAAAAAIAkTCIAAAAAAIAkY601MZMaTVbKjar/5nTuCKio16AXJbLGfC93BOC8VFy4kjsCapjtdHNHQA1b24u5I6Ci/oA2vqiatDMAAAAAAIBRGnMlgqvVohIhql6TRTHDYp/60JxDLzQvma+PavtFb+eOgBq2dpZyR0ANcw0qgaJqspB+WM2CSgQAAAAAADBCTCIAAAAAAIAkY21naBQDbZ2ltCyq5SX2y46q+VIndwTU0KMdJbYObXxRzbRY1DSymSYLK0Z2xcyruSOgooZoZ4iqY2nfe1QiAAAAAACAJEwiAAAAAACAJOPdnUHpKz5i8hgV1WH15jx3BNTgM/3cEVBHyYcnkMOumeO5I6CGn5o6lDsCKppNLInH5Jkp0nZFoRIBAAAAAAAkYRIBAAAAAAAkSWpnMLMXJZ2UVErqu/u1ZrZN0n2Sdkt6UdIt7n7s7K/jmmpQlhtVeaKVOwIqopg6NlqJgmvSThRVr2zkjoAauoOxdu1ixJad886oes6xF1XpaTUG66lE+DfufrW7Xzu8faekA+5+uaQDw9sAAAAAAGCDqjNNdLOk64d/75f0sKQ7zvaEdlFq1yyL3ET1yvs25Y6AihZOdHJHQB0nuRoTmbdZUDiqmVY3dwTUcLw7nTsCajjc25o7AiqaLfjsjKqvtAq81EoEl/QdM3vMzPYO79vh7keGf78qacf6IgIAAAAAgEhSKxF+zt0Pm9lFkr5rZj88/R/d3c3sjE2fw0mHvZI0+77ZWmEBAAAAAEA+SZMI7n54+L9HzewBSddJes3Mdrr7ETPbKenoezx3n6R9krT1Q9v9ZH9qNMkxdnOdtH1DMXm6XRa4iaxkYb7QBj02Qoqq3ShzR0ANzYLxi+ytci53BFT0FodeWF0fUTuDmc2a2fw7f0v6eUk/kPSQpD3Dh+2R9GClpAAAAAAAIISUy5M7JD1gq3uMNSX9ubt/28welXS/md0u6SVJt5y7mAAAAAAAILc1JxHc/QVJV53h/jcl3bCeNxuo0GK/vZ6nYII0zrzsBQIYlJRTR/YeS84gCGuyO0NUS312RolspkkrX2QrA46/qErnvDOqQeLYMcIAAAAAACDJWKdoTa520R/nW2KEZtkvO6y52eXcEVBDq8kKRZGt9LgaGtXALXcE1MD4xcbVbGBycXQCAAAAAIAkTCIAAAAAAIAkY25nkAoWCAvrRHcqdwRUNNWijSgyyuFjo6Q6rnLAtZbITnQ7uSOghoH47IyqZbRhRmVK+63OtyMAAAAAAEjCJAIAAAAAAEgy1hrZhg20ucUq8VH9eLA1dwRU1G5QVhZZlzaw0BYXaAWLatM05yyRbWnQygfksDho546AilLbiKhEAAAAAAAASZhEAAAAAAAAScbaztAbNHRkadM43xIj5KwwHtbRY/O5I6AGjr3YBiuN3BFQUasY5I6AGroDjr3IisRV4jF5tjYXckdARQ1L+96jEgEAAAAAACQZayWCa7UaATGdWmJxsKi4kh1bf3GsH9UYsaLDwqZRtViUNrRtU4u5I6CGt8vp3BFQUc/5vRdV6Wk1BlQiAAAAAACAJEwiAAAAAACAJGOtkS3MNd9iz+WoVhZbuSOgIitYnCg0pntD8wHtRFENaAUL7VSPNszI5uf4zRDVXIOxi4qFFQEAAAAAwEgxiQAAAAAAAJIktTOY2RZJd0n6sFY3WfiPkp6VdJ+k3ZJelHSLux876+totaUBMc1uojQpqoUTndwRUEefkurIfJndNaLqlawwHlm7088dATW8tHRB7gioaMfUidwRUFE/cWeN1EqEL0r6trt/SNJVkp6RdKekA+5+uaQDw9sAAAAAAGCDWvPyiJltlvQJSf9Bkty9K6lrZjdLun74sP2SHpZ0x9leyyV1B1yRicqoIgmr0UpbJAWTqd/lamhobY6/qBoFYxfZYr+dOwJquGjqVO4IAN5DSiXCZZJel/SnZvaEmd1lZrOSdrj7keFjXpW041yFBAAAAAAA+aVMIjQlfUTSl9z9GkkLelfrgru7VgsN/hkz22tmB83sYPf4Ut28AAAAAAAgk5TegkOSDrn7I8PbX9PqJMJrZrbT3Y+Y2U5JR8/0ZHffJ2mfJF105QX+EzNnXXsRE+zwiU25I6CicqqXOwJqKBqUVEfWXaCkOioWg45te4dy+Mg2Nbn4GNWOFgsrRtWyMulxa1YiuPurkl42syuGd90g6WlJD0naM7xvj6QH1x8TAAAAAABEkbrK4W9K+qqZtSW9IOnXtDoBcb+Z3S7pJUm3nJuIAAAAAABgEiRNIrj7k5KuPcM/3bCeNyu90PHe9HqeggnSabHfclTL3VbuCKiB3RliM9pRwjq+1MkdATW0CtowIyvdckdARRe2aCWKypV23KUsrAgAAAAAAMAkAgAAAAAASJO6JsJILJdNPf/2BeN8S4zQwgorjEc12+nmjoAaypL53sh6r8zmjoCKVuZpBYtsrrWSOwJq+Km5I7kjoKLUFf4xeUxpuxJxZgoAAAAAAJKMtRKhVZTaMcNCG1EdLjfnjoCKygGLE0W2ZY69siN78yIWxoxqaYEKvMhObmZhzMh6zmdnVDMFVUBRFVQiAAAAAACAUWISAQAAAAAAJBlrO0NhrpkmC7xFtX2WVpSoXjs1lzsCajh2ciZ3BNTQaLLAVFRll3aGyK7edih3BNRw2dTruSOgIlpRIqOdAQAAAAAAjBCTCAAAAAAAIMlY2xlKL3Six0q5Ua2UY/2/C0aoV1JWFlnZZ/wi87TKQEygrReczB0BNcw3lnNHQA27W7QzRPWB5mLuCKjoi4k7a1CJAAAAAAAAkjCJAAAAAAAAkoy1Pr1T9PTBeUqTonplaXPuCKhopU8rSmQz7V7uCAAQzoVN2lEiu7hBSXxUO5vsChZVy44lPY5KBAAAAAAAkGSslyenir5+skMlQlTdAVezo1rss9d5ZK+c2JQ7Ampwt9wRUJEZq2JG9qGpI7kjoIbLWlzNBiYVlQgAAAAAACAJkwgAAAAAACDJmvXpZnaFpPtOu+sDkv6rpK8M798t6UVJt7j7WVdi6HpTh7pbq2ZFZqcoiQ9r5/SJ3BFQw5b2Uu4IqOGZNy/KHQEVnVrs5I6AGmYS9zvHpGrlDgDgPaxZieDuz7r71e5+taSfkbQo6QFJd0o64O6XSzowvA0AAAAAADao9bYz3CDpeXd/SdLNkvYP798v6RdHGQwAAAAAAEyW9S63f6uke4Z/73D3d5a9fVXSjrWePFOs6Gdm/3Gdb4lJ8c3lq3JHQEWFDXJHQA2bWsu5I6CGnfPsVR9Vb4Z96iPb3ezmjoBaaGcAJlVyJYKZtSV9VtJfvPvf3N0lnXEfJDPba2YHzezgybf6lYMCAAAAAIC81lOJ8GlJj7v7a8Pbr5nZTnc/YmY7JR0905PcfZ+kfZJ09VVtv3GaPXuj2rKdKzJRLTuz+ZE9tnhZ7gio4cVT23JHQEX/csuruSMAADBx1rMmwm36/60MkvSQpD3Dv/dIenBUoQAAAAAAwORJmkQws1lJN0r6xml3f0HSjWb2D5I+NbwNAAAAAAA2qKR2BndfkHTBu+57U6u7NSRryDRXTK3nKZggs+y3HNYWoxUlsn/RoaQ6sp07jueOgIreLmdyR0ANr5fr3YQMk+T4YCF3BFR0ckAbbVQLfsZlDv8ZPl0BAAAAAEASJhEAAAAAAECS9ezOUNuSu57qss1jVC/33pc7Aip6s5zLHQE1bGnQjhLZxa1juSOgopaVuSOghuMDWmgju6rdzR0BFb1ljF1ULQ2SHkclAgAAAAAASMIkAgAAAAAASDLWdoaWXDsavXG+JUao2z6aOwIqKnpppUmYTB3jczOyNiXxYTWMz87Iej7W01yM2LM9WqCjmjGuU0dVypIexwgDAAAAAIAk461EsIZ2NlngLar5Yjl3BFT0geYruSOghkbirDAm00v9Ru4IqOji5tu5IwDnre0FlQhRvT6gCigqT3wclQgAAAAAACAJkwgAAAAAACDJWGtNln2gH/UWxvmWGKFX+vO5I6CiH/e25Y6AGn6SRU1D6xgluVF1nWstkV1QrOSOgBpogY5rZ+4AqCx1UUy+HQEAAAAAQBImEQAAAAAAQJKxtjM0TdrGtEVYO6ZoRYlqW2MxdwTU8OTyrtwRgPPS4mAqdwTU8K9nnssdATU8ttLNHQE47yx42v4M/KQHAAAAAABJmEQAAAAAAABJxtvOoEIXNmbH+ZYAJP10O3cC1PH+5su5I6CGFR/kjoCKXi+51hLZrrGe5WLUNhecvES1OKAVJappS3sc344AAAAAACDJWOdoXy9b2vf2xeN8S4xQQ1xNi+qS1rHcEVBDyxq5I6CGnnM5NKqW9XNHQA2lWBA6sktZFDqsntIW58PkKRPHjkoEAAAAAACQhEkEAAAAAACQxDxxL8iRvJnZ65JeGtsbjt+Fkt7IHQKVMHaxMX5xMXaxMX6xMX5xMXaxMX5xbfSxe7+7b1/rQWOdRNjozOygu1+bOwfWj7GLjfGLi7GLjfGLjfGLi7GLjfGLi7FbRTsDAAAAAABIwiQCAAAAAABIwiTCaO3LHQCVMXaxMX5xMXaxMX6xMX5xMXaxMX5xMXZiTQQAAAAAAJCISgQAAAAAAJCESYQRMLObzOxZM3vOzO7MnQfpzOzLZnbUzH6QOwvWx8wuNbPvmdnTZvaUmX0udyakM7OOmf2dmf39cPx+P3cmrI+ZNczsCTP7Zu4sWB8ze9HMvm9mT5rZwdx5sD5mtsXMvmZmPzSzZ8zsZ3NnwtrM7IrhMffOfyfM7PO5cyGdmf3n4TnLD8zsHjPr5M6UC+0MNZlZQ9KPJN0o6ZCkRyXd5u5PZw2GJGb2CUmnJH3F3T+cOw/SmdlOSTvd/XEzm5f0mKRf5NiLwcxM0qy7nzKzlqS/kfQ5d/8/maMhkZn9lqRrJW1y98/kzoN0ZvaipGvdfSPvdb5hmdl+Sf/b3e8ys7akGXc/njsX0g1/PxyW9FF3fyl3HqzNzC7R6rnKle6+ZGb3S/qWu/9Z3mR5UIlQ33WSnnP3F9y9K+leSTdnzoRE7v7Xkt7KnQPr5+5H3P3x4d8nJT0j6ZK8qZDKV50a3mwN/2NWOwgz2yXpFyTdlTsLcD4xs82SPiHpbkly9y4TCCHdIOl5JhDCaUqaNrOmpBlJr2TOkw2TCPVdIunl024fEj9kgLEys92SrpH0SN4kWI9hOfyTko5K+q67M35x/Imk35Y0yB0Elbik75jZY2a2N3cYrMtlkl6X9KfDdqK7zGw2dyis261ZQDfOAAACT0lEQVSS7skdAunc/bCk/yHpx5KOSHrb3b+TN1U+TCIACM3M5iR9XdLn3f1E7jxI5+6lu18taZek68yMlqIAzOwzko66+2O5s6Cyn3P3j0j6tKRfH7b2IYampI9I+pK7XyNpQRLrcQUybEH5rKS/yJ0F6cxsq1arzS+TdLGkWTP793lT5cMkQn2HJV162u1dw/sAnGPDXvqvS/qqu38jdx5UMyzF/Z6km3JnQZKPS/rssK/+XkmfNLP/mTcS1mN4RU3uflTSA1ptzUQMhyQdOq1y62tanVRAHJ+W9Li7v5Y7CNblU5L+0d1fd/eepG9I+leZM2XDJEJ9j0q63MwuG84s3irpocyZgA1vuDDf3ZKecfc/yp0H62Nm281sy/Dvaa0uTvvDvKmQwt1/x913ufturX7n/ZW7n7dXY6Ixs9nhYrQalsH/vCR2KArC3V+V9LKZXTG86wZJLCgcy22ilSGiH0v6mJnNDM9Bb9DqelznpWbuANG5e9/MfkPSX0pqSPqyuz+VORYSmdk9kq6XdKGZHZL039z97rypkOjjkn5V0veHffWS9Lvu/q2MmZBup6T9wxWqC0n3uztbBQLn3g5JD6yeA6sp6c/d/dt5I2GdflPSV4cXr16Q9GuZ8yDRcOLuRkn/KXcWrI+7P2JmX5P0uKS+pCck7cubKh+2eAQAAAAAAEloZwAAAAAAAEmYRAAAAAAAAEmYRAAAAAAAAEmYRAAAAAAAAEmYRAAAAAAAAEmYRAAAAAAAAEmYRAAAAAAAAEmYRAAAAAAAAEn+H4L6KmdANU8iAAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot(x.numpy()[0]) \n", + "plot(y.numpy()[0])\n", + "plot_spec(m.numpy()[0])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Define Model Classes" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "class ResBlock(nn.Module) :\n", + " def __init__(self, dims) :\n", + " super().__init__()\n", + " self.conv1 = nn.Conv1d(dims, dims, kernel_size=1, bias=False)\n", + " self.conv2 = nn.Conv1d(dims, dims, kernel_size=1, bias=False)\n", + " self.batch_norm1 = nn.BatchNorm1d(dims)\n", + " self.batch_norm2 = nn.BatchNorm1d(dims)\n", + " \n", + " def forward(self, x) :\n", + " residual = x\n", + " x = self.conv1(x)\n", + " x = self.batch_norm1(x)\n", + " x = F.relu(x)\n", + " x = self.conv2(x)\n", + " x = self.batch_norm2(x)\n", + " return x + residual" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "class MelResNet(nn.Module) :\n", + " def __init__(self, res_blocks, in_dims, compute_dims, res_out_dims) :\n", + " super().__init__()\n", + " k_size = pad * 2 + 1\n", + " self.conv_in = nn.Conv1d(in_dims, compute_dims, kernel_size=k_size, bias=False)\n", + " self.batch_norm = nn.BatchNorm1d(compute_dims)\n", + " self.layers = nn.ModuleList()\n", + " for i in range(res_blocks) :\n", + " self.layers.append(ResBlock(compute_dims))\n", + " self.conv_out = nn.Conv1d(compute_dims, res_out_dims, kernel_size=1)\n", + " \n", + " def forward(self, x) :\n", + " x = self.conv_in(x)\n", + " x = self.batch_norm(x)\n", + " x = F.relu(x)\n", + " for f in self.layers : x = f(x)\n", + " x = self.conv_out(x)\n", + " return x " + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "class Stretch2d(nn.Module) :\n", + " def __init__(self, x_scale, y_scale) :\n", + " super().__init__()\n", + " self.x_scale = x_scale\n", + " self.y_scale = y_scale\n", + " \n", + " def forward(self, x) :\n", + " b, c, h, w = x.size()\n", + " x = x.unsqueeze(-1).unsqueeze(3)\n", + " x = x.repeat(1, 1, 1, self.y_scale, 1, self.x_scale)\n", + " return x.view(b, c, h * self.y_scale, w * self.x_scale)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "class UpsampleNetwork(nn.Module) :\n", + " def __init__(self, feat_dims, upsample_scales, compute_dims, \n", + " res_blocks, res_out_dims, pad) :\n", + " super().__init__()\n", + " total_scale = np.cumproduct(upsample_scales)[-1]\n", + " self.indent = pad * total_scale\n", + " self.resnet = MelResNet(res_blocks, feat_dims, compute_dims, res_out_dims)\n", + " self.resnet_stretch = Stretch2d(total_scale, 1)\n", + " self.up_layers = nn.ModuleList()\n", + " for scale in upsample_scales :\n", + " k_size = (1, scale * 2 + 1)\n", + " padding = (0, scale)\n", + " stretch = Stretch2d(scale, 1)\n", + " conv = nn.Conv2d(1, 1, kernel_size=k_size, padding=padding, bias=False)\n", + " conv.weight.data.fill_(1. / k_size[1])\n", + " self.up_layers.append(stretch)\n", + " self.up_layers.append(conv)\n", + " \n", + " def forward(self, m) :\n", + " aux = self.resnet(m).unsqueeze(1)\n", + " aux = self.resnet_stretch(aux)\n", + " aux = aux.squeeze(1)\n", + " m = m.unsqueeze(1)\n", + " for f in self.up_layers : m = f(m)\n", + " m = m.squeeze(1)[:, :, self.indent:-self.indent]\n", + " return m.transpose(1, 2), aux.transpose(1, 2)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "code_folding": [] + }, + "outputs": [], + "source": [ + "class Model(nn.Module) :\n", + " def __init__(self, rnn_dims, fc_dims, bits, pad, upsample_factors,\n", + " feat_dims, compute_dims, res_out_dims, res_blocks,\n", + " hop_length, sample_rate):\n", + " super().__init__()\n", + " self.pad = pad\n", + " self.n_classes = 2**bits\n", + " self.rnn_dims = rnn_dims\n", + " self.aux_dims = res_out_dims // 4\n", + " self.hop_length = hop_length\n", + " self.sample_rate = sample_rate\n", + " self.upsample = UpsampleNetwork(feat_dims, upsample_factors, compute_dims, \n", + " res_blocks, res_out_dims, pad)\n", + " self.I = nn.Linear(feat_dims + self.aux_dims + 1, rnn_dims)\n", + " self.rnn1 = nn.GRU(rnn_dims, rnn_dims, batch_first=True)\n", + " self.rnn2 = nn.GRU(rnn_dims + self.aux_dims, rnn_dims, batch_first=True)\n", + " self.fc1 = nn.Linear(rnn_dims + self.aux_dims, fc_dims)\n", + " self.fc2 = nn.Linear(fc_dims + self.aux_dims, fc_dims)\n", + " self.fc3 = nn.Linear(fc_dims, self.n_classes)\n", + " num_params(self)\n", + " \n", + " \n", + " def forward(self, x, mels) :\n", + " bsize = x.size(0)\n", + " h1 = torch.zeros(1, bsize, self.rnn_dims).cuda()\n", + " h2 = torch.zeros(1, bsize, self.rnn_dims).cuda()\n", + " mels, aux = self.upsample(mels)\n", + " \n", + " aux_idx = [self.aux_dims * i for i in range(5)]\n", + " a1 = aux[:, :, aux_idx[0]:aux_idx[1]]\n", + " a2 = aux[:, :, aux_idx[1]:aux_idx[2]]\n", + " a3 = aux[:, :, aux_idx[2]:aux_idx[3]]\n", + " a4 = aux[:, :, aux_idx[3]:aux_idx[4]]\n", + " \n", + " x = torch.cat([x.unsqueeze(-1), mels, a1], dim=2)\n", + " x = self.I(x)\n", + " res = x\n", + " x, _ = self.rnn1(x, h1)\n", + " \n", + " x = x + res\n", + " res = x\n", + " x = torch.cat([x, a2], dim=2)\n", + " x, _ = self.rnn2(x, h2)\n", + " \n", + " x = x + res\n", + " x = torch.cat([x, a3], dim=2)\n", + " x = F.relu(self.fc1(x))\n", + " \n", + " x = torch.cat([x, a4], dim=2)\n", + " x = F.relu(self.fc2(x))\n", + " return F.log_softmax(self.fc3(x), dim=-1)\n", + " \n", + " \n", + " def generate(self, mels, save_path, batched, target, overlap) :\n", + " \n", + " self.eval()\n", + " output = []\n", + " start = time.time()\n", + " rnn1 = self.get_gru_cell(self.rnn1)\n", + " rnn2 = self.get_gru_cell(self.rnn2)\n", + " \n", + " with torch.no_grad() :\n", + " \n", + " mels = torch.FloatTensor(mels).cuda().unsqueeze(0)\n", + " mels = self.pad_tensor(mels.transpose(1, 2), pad=self.pad, side='both')\n", + " mels, aux = self.upsample(mels.transpose(1, 2))\n", + " \n", + " if batched :\n", + " mels = self.fold_with_overlap(mels, target, overlap)\n", + " aux = self.fold_with_overlap(aux, target, overlap)\n", + "\n", + " b_size, seq_len, _ = mels.size()\n", + " \n", + " h1 = torch.zeros(b_size, self.rnn_dims).cuda()\n", + " h2 = torch.zeros(b_size, self.rnn_dims).cuda()\n", + " x = torch.zeros(b_size, 1).cuda()\n", + " \n", + " d = self.aux_dims\n", + " aux_split = [aux[:, :, d*i:d*(i+1)] for i in range(4)]\n", + " \n", + " for i in range(seq_len) :\n", + "\n", + " m_t = mels[:, i, :]\n", + " \n", + " a1_t, a2_t, a3_t, a4_t = \\\n", + " (a[:, i, :] for a in aux_split)\n", + " \n", + " x = torch.cat([x, m_t, a1_t], dim=1)\n", + " x = self.I(x)\n", + " h1 = rnn1(x, h1)\n", + " \n", + " x = x + h1\n", + " inp = torch.cat([x, a2_t], dim=1)\n", + " h2 = rnn2(inp, h2)\n", + " \n", + " x = x + h2\n", + " x = torch.cat([x, a3_t], dim=1)\n", + " x = F.relu(self.fc1(x))\n", + " \n", + " x = torch.cat([x, a4_t], dim=1)\n", + " x = F.relu(self.fc2(x))\n", + " \n", + " logits = self.fc3(x)\n", + " posterior = F.softmax(logits, dim=1)\n", + " distrib = torch.distributions.Categorical(posterior)\n", + " \n", + " sample = 2 * distrib.sample().float() / (self.n_classes - 1.) - 1.\n", + " output.append(sample)\n", + " x = sample.unsqueeze(-1)\n", + " \n", + " if i % 100 == 0 : self.gen_display(i, seq_len, b_size, start)\n", + " \n", + " \n", + " output = torch.stack(output).transpose(0, 1)\n", + " output = output.cpu().numpy()\n", + " output = output.astype(np.float64)\n", + " \n", + " if batched :\n", + " output = self.xfade_and_unfold(output, target, overlap)\n", + " else :\n", + " output = output[0]\n", + " \n", + " librosa.output.write_wav(save_path, output.astype(np.float32), self.sample_rate)\n", + " \n", + " self.train()\n", + " \n", + " return output\n", + " \n", + " def gen_display(self, i, seq_len, b_size, start) :\n", + " gen_rate = (i + 1) / (time.time() - start) * b_size / 1000 \n", + " realtime_ratio = gen_rate * 1000 / self.sample_rate\n", + " stream('%i/%i -- batch_size: %i -- gen_rate: %.1f kHz -- x_realtime: %.1f ', \n", + " (i * b_size, seq_len * b_size, b_size, gen_rate, realtime_ratio))\n", + " \n", + " def get_gru_cell(self, gru) :\n", + " gru_cell = nn.GRUCell(gru.input_size, gru.hidden_size)\n", + " gru_cell.weight_hh.data = gru.weight_hh_l0.data\n", + " gru_cell.weight_ih.data = gru.weight_ih_l0.data\n", + " gru_cell.bias_hh.data = gru.bias_hh_l0.data\n", + " gru_cell.bias_ih.data = gru.bias_ih_l0.data\n", + " return gru_cell\n", + " \n", + " \n", + " def pad_tensor(self, x, pad, side='both') :\n", + " # NB - this is just a quick method i need right now\n", + " # i.e., it won't generalise to other shapes/dims\n", + " b, t, c = x.size()\n", + " total = t + 2 * pad if side == 'both' else t + pad\n", + " padded = torch.zeros(b, total, c).cuda()\n", + " if side == 'before' or side == 'both' :\n", + " padded[:, pad:pad+t, :] = x\n", + " elif side == 'after' :\n", + " padded[:, :t, :] = x \n", + " return padded\n", + "\n", + " \n", + " def fold_with_overlap(self, x, target, overlap) :\n", + " \n", + " ''' Fold the tensor with overlap for quick batched inference.\n", + " Overlap will be used for crossfading in xfade_and_unfold()\n", + "\n", + " Args:\n", + " x (tensor) : Upsampled conditioning features. \n", + " shape=(1, timesteps, features)\n", + " target (int) : Target timesteps for each index of batch\n", + " overlap (int) : Timesteps for both xfade and rnn warmup\n", + "\n", + " Return:\n", + " (tensor) : shape=(num_folds, target + 2 * overlap, features)\n", + " \n", + " Details: \n", + " x = [[h1, h2, ... hn]] \n", + "\n", + " Where each h is a vector of conditioning features\n", + "\n", + " Eg: target=2, overlap=1 with x.size(1)=10 \n", + "\n", + " folded = [[h1, h2, h3, h4],\n", + " [h4, h5, h6, h7],\n", + " [h7, h8, h9, h10]]\n", + " '''\n", + "\n", + " _, total_len, features = x.size()\n", + " \n", + " # Calculate variables needed\n", + " num_folds = (total_len - overlap) // (target + overlap)\n", + " extended_len = num_folds * (overlap + target) + overlap\n", + " remaining = total_len - extended_len\n", + " \n", + " # Pad if some time steps poking out\n", + " if remaining != 0 :\n", + " num_folds += 1\n", + " padding = target + 2 * overlap - remaining \n", + " x = self.pad_tensor(x, padding, side='after')\n", + "\n", + " folded = torch.zeros(num_folds, target + 2 * overlap, features).cuda()\n", + " \n", + " # Get the values for the folded tensor\n", + " for i in range(num_folds) :\n", + " start = i * (target + overlap)\n", + " end = start + target + 2 * overlap\n", + " folded[i] = x[:, start:end, :]\n", + "\n", + " return folded\n", + " \n", + " \n", + " def xfade_and_unfold(self, y, target, overlap) :\n", + " \n", + " ''' Applies a crossfade and unfolds into a 1d array.\n", + " \n", + " Args:\n", + " y (ndarry) : Batched sequences of audio samples\n", + " shape=(num_folds, target + 2 * overlap)\n", + " dtype=np.float64\n", + " overlap (int) : Timesteps for both xfade and rnn warmup\n", + "\n", + " Return:\n", + " (ndarry) : audio samples in a 1d array \n", + " shape=(total_len)\n", + " dtype=np.float64\n", + " \n", + " Details: \n", + " y = [[seq1], \n", + " [seq2], \n", + " [seq3]] \n", + " \n", + " Apply a gain envelope at both ends of the sequences\n", + " \n", + " y = [[seq1_in, seq1_target, seq1_out],\n", + " [seq2_in, seq2_target, seq2_out],\n", + " [seq3_in, seq3_target, seq3_out]]\n", + "\n", + " Stagger and add up the groups of samples:\n", + "\n", + " [seq1_in, seq1_target, (seq1_out + seq2_in), seq2_target, ...]\n", + " \n", + " '''\n", + " \n", + " num_folds, length = y.shape\n", + " target = length - 2 * overlap\n", + " total_len = num_folds * (target + overlap) + overlap\n", + " \n", + " # Need some silence for the rnn warmup\n", + " silence_len = overlap // 2\n", + " fade_len = overlap - silence_len\n", + " silence = np.zeros((silence_len), dtype=np.float64)\n", + " \n", + " # Equal power crossfade\n", + " t = np.linspace(-1, 1, fade_len, dtype=np.float64)\n", + " fade_in = np.sqrt(0.5 * (1 + t))\n", + " fade_out = np.sqrt(0.5 * (1 - t))\n", + " \n", + " # Concat the silence to the fades\n", + " fade_in = np.concatenate([silence, fade_in])\n", + " fade_out = np.concatenate([fade_out, silence])\n", + " \n", + " # Apply the gain to the overlap samples\n", + " y[:, :overlap] *= fade_in\n", + " y[:, -overlap:] *= fade_out\n", + " \n", + " unfolded = np.zeros((total_len), dtype=np.float64)\n", + " \n", + " # Loop to add up all the samples\n", + " for i in range(num_folds ) :\n", + " start = i * (target + overlap)\n", + " end = start + target + 2 * overlap\n", + " unfolded[start:end] += y[i]\n", + "\n", + " return unfolded" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Instantiate and Check Upsampling" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Trainable Parameters: 4.481 million\n" + ] + } + ], + "source": [ + "model = Model(rnn_dims=512, \n", + " fc_dims=512, \n", + " bits=bits,\n", + " pad=pad,\n", + " upsample_factors=(5, 5, 11), \n", + " feat_dims=80,\n", + " compute_dims=128, \n", + " res_out_dims=128, \n", + " res_blocks=10,\n", + " hop_length=hop_length,\n", + " sample_rate=sample_rate).cuda()" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "if not os.path.exists(MODEL_PATH):\n", + " torch.save(model.state_dict(), MODEL_PATH) \n", + "model.load_state_dict(torch.load(MODEL_PATH)) " + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "mels, aux = model.upsample(m.cuda())" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABBEAAAD8CAYAAAAhbjwkAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4wLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvpW3flQAAIABJREFUeJzt3X2snOV55/Hf9czLmfPmNzCOwTQmDUuWRgVSRNJNN2JDqMg2ClVVIehu5e0ief9oq2S7UqH9Y7eVulIqrdrmr0gWpHW0KS9NgkBRNk3kBnUrdSnmpZsAIQUKwcZgXmxsn7eZeebaP86gdanxuc/zjOee6/j7kVDOjOflJ915Zp65n+u6b3N3AQAAAAAArKXIHQAAAAAAAMTAJAIAAAAAAEjCJAIAAAAAAEjCJAIAAAAAAEjCJAIAAAAAAEjCJAIAAAAAAEjCJAIAAAAAAEhSaxLBzG4ys2fN7Dkzu3NUoQAAAAAAwOQxd6/2RLOGpB9JulHSIUmPSrrN3Z8eXTwAAAAAADApmjWee52k59z9BUkys3sl3SzpPScR2jblHc3WeEsAAAAAADBqy1pQ11dsrcfVmUS4RNLLp90+JOmjZ3tCR7P6qN1Q4y0BAAAAAMCoPeIHkh5XZxIhiZntlbRXkjqaOddvBwAAAAAAzpE6kwiHJV162u1dw/v+CXffJ2mfJG1uXuiNuU013hI5eVnmjgAA4Xi/nzsCKvJuN3cE1FBMT+eOgBpsupM7AqqyNavhMaHsWCPpcXV2Z3hU0uVmdpmZtSXdKumhGq8HAAAAAAAmWOVKBHfvm9lvSPpLSQ1JX3b3p876pKKQzTArHFY5yJ0AOD/1uBoamXWmckdAVc3NuROgjkG1HcgwIQquZgPjl3bc1VoTwd2/JelbdV4DAAAAAADEUKedAQAAAAAAnEfO+e4M/4RLTkk8MH4DFsUMrdXOnQB1UJIL5MF3X2z8ZIiLVqK4PG3sqEQAAAAAAABJmEQAAAAAAABJxtzO4KwyHph12K83rGbanq+YUAXzvZF5v587AqoqKYePzFqt3BFQA5+dgXHaEldiByZDDAAAAAAAkjCJAAAAAAAAkoy1naG3taOjv3TlON8SI9SbZYXxqHpzuRMA568BFdVhGQuMh1as5E6AOmZf4QCMqqQDOqze19MGj0oEAAAAAACQZKyVCOW09NZPs+lrVMUFTOlHtXXTYu4IqKFfMt8bWavJ4nxRFZQihHZikcuhkb1xyWzuCKjIp/i9F1X5v9K+9zgzBQAAAAAASZhEAAAAAAAAScbazqDC5R3KW6JqNBi7qNpN9lqObPvscu4IqGHgLEob1XKfVTEjG0zThhnZ8qZ27gioqChoBQsrceyoRAAAAAAAAEmYRAAAAAAAAEnG285gkrVZpToq2hniKgfMF0a2Uo73oxqjNdWgnSiqmVY3dwTUcGJ5KncE1OA9zl2i8gFtfGEljh1HJwAAAAAASMIkAgAAAAAASLJmjayZfVnSZyQddfcPD+/bJuk+SbslvSjpFnc/tuZrFa4m7QxhNZuMXVSNglaUyGhHiW1lzJ2DAFY1acMMzZqMX1S+3MgdAedYypnpn0m66V333SnpgLtfLunA8DYAAAAAANjA1rw84u5/bWa733X3zZKuH/69X9LDku5Y87X6hfpvddYVEJPj1DyzikAOnRYL80XmzgJTUU01OfYiW+q2ckdADSysGBjfe3F52sOqHp073P3I8O9XJe2o+DoAAAAAACCI2lN87u46y5yFme01s4NmdrA8daru2wEAAAAAgEyqrvb0mpntdPcjZrZT0tH3eqC775O0T5Km3r/L3RJrJDB5upSVRbW0yF7ZkbXmWdQ0spUeJdVRvX1yOncE1NDv0oYZmbE4X1jeZlHMsBI7Uar+KnxI0p7h33skPVjxdQAAAAAAQBBrTiKY2T2S/lbSFWZ2yMxul/QFSTea2T9I+tTwNgAAAAAA2MBSdme47T3+6YZ1v5tJatDOEBbdDEAWvZKSzsicr72wZmdWckdADSutql27mARL7M4QljX54gvrHLczAAAAAACA88x4p2gHxiIpgXmD/bKjKllcKrSFQSd3BNTgJftlR7XEXueheZ/xC63Ptc6w2vxmCItKBAAAAAAAMEpMIgAAAAAAgCTjbWcwSSy0EVeXOaeonJXdQrMG+y1H1pnt5o6AivqUU4fWW2znjoAajHaUsAoW0g8sbez4dgQAAAAAAEmYRAAAAAAAAEnGvDuDZCuUJkVVsEp1WGVBOXxkg2X2Oo9sifGLi3Lq2ApKqkOb7+VOgIpa7M4QlrE7AwAAAAAAGCUmEQAAAAAAQJLx1li6VHQpDYzKW5QFhsXQxcb4hWYrzNdH1TrB2EVmZe4EqKO7heMvql6LNtqoUjd04+gEAAAAAABJxlqJYC4VrLMR1qCgiiQq6zJfGJkzox+az3A5NKrePCctkflyI3cE1NB+g/GLqjvVyh0BVQ3Sfu/xywIAAAAAACRhEgEAAAAAACQZ++bVRlVuWI3l3AlQVdGjFSWy3hbGLzLvMV8flfdZ1TQyK/nsBHJovTX2n5gYEevTzgAAAAAAAEaISQQAAAAAAJBkzVoTM7tU0lck7dDqbuX73P2LZrZN0n2Sdkt6UdIt7n7sbK/lDam7mdLAsArGLipvMHaRFcvM90ZWOCXVUTmHXmwcerExfnFx2rnhpXw99iX9F3e/UtLHJP26mV0p6U5JB9z9ckkHhrcBAAAAAMAGtWYlgrsfkXRk+PdJM3tG0iWSbpZ0/fBh+yU9LOmOs76YOfudB2ZcTYtrmn3qI0vcshcTauZlFpiKasDQhdbdyjlnZL05LmdH1VzkxGWjW1ehnpntlnSNpEck7RhOMEjSq1ptdwAAAAAAABtU8iSCmc1J+rqkz7v7idP/zd1d79H9YmZ7zeygmR0sTy3UCgsAAAAAAPJJKtQzs5ZWJxC+6u7fGN79mpntdPcjZrZT0tEzPdfd90naJ0lTl17qzVONEcRGDnQzxOXdVu4IqIGFMWNb2UZJdVRFly++yFonWBkzskGb776w+Ojc8Nb8dDUzk3S3pGfc/Y9O+6eHJO0Z/r1H0oOjjwcAAAAAACZFSiXCxyX9qqTvm9mTw/t+V9IXJN1vZrdLeknSLecmIgAAAAAAmAQpuzP8jd67KOWGdb2bUZoUmbcYu6i8YOxCoywwtAG9YGENpmlFCY2vvtCcnaXCakz3c0dARd5O+96jWQwAAAAAACRhEgEAAAAAACRJ2p0BkKTWMeacorKScurIevOUVEc26DB+UdmAz87IGguct4TG+IXV38JnZ1iJ33scnQAAAAAAIMnYKxFY4C2uQZtZxagGTa6ERjaYYfxCa/C9F5U3OPYi63POGVr7rUbuCKjIVrhOHRaVCAAAAAAAYJSYRAAAAAAAAEnG285gLm9RWhZV6YxdVO23aUWJrFcw3xsZ33txOa1goZnz3RdZbwvHX1SNbSu5I6CqxO89zkwBAAAAAEASJhEAAAAAAECS8bYzuKlYZt4iKmeF8bBWLqIkMDQOvdj47IyL1f1Dc/HdF1lzvpc7AiraunkhdwRU9GrirkT8ogcAAAAAAEmYRAAAAAAAAEnG284gyZuUBkbFCuNxFXOUBAK5DHrM1wNZ0EoUmhW0o0S13Bv7T0yMyCBxVxvObAAAAAAAQJIxL6woFSvs2RuVLTHnFFXZKXNHQA3GXvWxsVd9WLbQyB0BNbCYd2y9eY6/qGxr7gSoyqlEAAAAAAAAo8QkAgAAAAAASDL+VS8o6wyr7FBSHZV3mS+MzAd8bobGR2dYPksrWGR8dMbWOMW5S1S9aRZWjCr1nHPNo9PMOmb2d2b292b2lJn9/vD+y8zsETN7zszuM7N2zcwAAAAAAGCCpUzxrUj6pLtfJelqSTeZ2cck/aGkP3b3D0o6Jun2cxcTAAAAAADktmatibu7pFPDm63hfy7pk5J+ZXj/fkm/J+lLZ3stc6nRrRoV2Rl1gVENGpQEhtbu506AGmhHAfJwdiYKbeDszhCV9zjvDMvTHpY0wmbWMLMnJR2V9F1Jz0s67u7vnNkeknTJezx3r5kdNLOD5cJCWioAAAAAADBxkla9cPdS0tVmtkXSA5I+lPoG7r5P0j5J6lxyqRuTwmENWrkTAOcpS5wWxkRqzvDFF1V/kcXBIitOMH6RNbpUcUXVm2JF4Y1uXbUm7n5c0vck/aykLWb2zqfzLkmHR5wNAAAAAABMkJTdGbYPKxBkZtOSbpT0jFYnE355+LA9kh48VyEBAAAAAEB+KXVeOyXtN7OGVicd7nf3b5rZ05LuNbM/kPSEpLvXeiFvSN0tlLdE5U1KqqNqbV3JHQE1DAYsUBRZs0U7Q1gzuQOgjsFJ2hkiowU6MDpRNryU3Rn+r6RrznD/C5KuOxehAAAAAADA5OHyFgAAAAAASEKdF9Kx0mpY/S57LUfmJfO9kRm7a4Q1GFCTGxltmLF139df+0GYSEWbXpSwirTPTc5MAQAAAABAEiYRAAAAAABAkvG2MxQun6W8JSpKk+IqGpR0Rtaa7eaOgBqmWpTkRrW00sodATV057lWFtnM/HLuCKhofppdwaI62kxrX+fTFQAAAAAAJBlrJULRHGhu2+I43xIjtLTUzh0BFTWaVJFExpXs2IqCRWmBHCzxihom09bZpdwRUNEHNr+ROwIqer7RS3oclQgAAAAAACAJkwgAAAAAACDJeNsZCtfsFAuERbWyMt51ODE63WUWB4us32/kjoAaBn3m66OanmVxsMhajF9oPzF/LHcEVLS9fSp3BFTUNBZWBAAAAAAAI8QkAgAAAAAASDLW+vRyYDqx2BnnWwLQ6s4oiIty+Ni8y/iFNZs7AOqghTa25ZI22qhe787ljoCK+p52zsKZDQAAAAAASMIkAgAAAAAASDLWOiEfFFpebI/zLTFClOQG5pY7Aeowz50ANRRTZe4IqKgs+d6LrMf4hfbGEiXxUb3dnc4dARV1B2nTA3y6AgAAAACAJONdsWTA1ezIbIW96qPymX7uCKiBhTFj8wGVQFF1l1u5I6CGJp+doXVanLuEVfKbISpPLH5N/kVvZg0ze8LMvjm8fZmZPWJmz5nZfWZGnwIAAAAAABvYesoCPifpmdNu/6GkP3b3D0o6Jun2UQYDAAAAAACTJamdwcx2SfoFSf9d0m+ZmUn6pKRfGT5kv6Tfk/Sls75Q4WpQVh1WyeJ8QBbNNgvzRcbifHGVS+xTH1mvR0l1ZK2CdpSoBvxm2PBSz2z+RNJvS3rnaL5A0nF3f2dG4JCkS870RDPba2YHzexgeXKhVlgAAAAAAJDPmpMIZvYZSUfd/bEqb+Du+9z9Wne/tjE/W+UlAAAAAADABEip0/u4pM+a2b+V1JG0SdIXJW0xs+awGmGXpMNrvlJpKk+w/mJU1qGkOipjherQyj4luUAWReIy1ZhI3QXOOSPrb6YVLCo+OTe+NY9Od/8dd9/l7rsl3Srpr9z930n6nqRfHj5sj6QHz1lKAAAAAACQXZ0Vg+6QdK+Z/YGkJyTdveYzGq5irlfjLZGTsUZKWAWLE4XWo4IrNJvi+Iuq1WEx6NCM66GRsaB3XFMNqpejSj3q1jWJ4O4PS3p4+PcLkq5bVyoAAAAAABAWzUYAAAAAACDJeDdAdtOgx7xFWJSVhVVMU04dWpvxi8wHfHZGNRhwzhJZQUl1aCXHX1jWpBUsrMRTFo5OAAAAAACQhEkEAAAAAACQZLztDOYqWpTlhsUix0AWrBAfW7/byB0BFQ3eZGeUyNoXL+SOgBp2b34rdwRU1C3H+xMTo9OwtN/qVCIAAAAAAIAkTCIAAAAAAIAkY601MZMaTVbKjar/5nTuCKio16AXJbLGfC93BOC8VFy4kjsCapjtdHNHQA1b24u5I6Ci/oA2vqiatDMAAAAAAIBRGnMlgqvVohIhql6TRTHDYp/60JxDLzQvma+PavtFb+eOgBq2dpZyR0ANcw0qgaJqspB+WM2CSgQAAAAAADBCTCIAAAAAAIAkY21naBQDbZ2ltCyq5SX2y46q+VIndwTU0KMdJbYObXxRzbRY1DSymSYLK0Z2xcyruSOgooZoZ4iqY2nfe1QiAAAAAACAJEwiAAAAAACAJOPdnUHpKz5i8hgV1WH15jx3BNTgM/3cEVBHyYcnkMOumeO5I6CGn5o6lDsCKppNLInH5Jkp0nZFoRIBAAAAAAAkYRIBAAAAAAAkSWpnMLMXJZ2UVErqu/u1ZrZN0n2Sdkt6UdIt7n7s7K/jmmpQlhtVeaKVOwIqopg6NlqJgmvSThRVr2zkjoAauoOxdu1ixJad886oes6xF1XpaTUG66lE+DfufrW7Xzu8faekA+5+uaQDw9sAAAAAAGCDqjNNdLOk64d/75f0sKQ7zvaEdlFq1yyL3ET1yvs25Y6AihZOdHJHQB0nuRoTmbdZUDiqmVY3dwTUcLw7nTsCajjc25o7AiqaLfjsjKqvtAq81EoEl/QdM3vMzPYO79vh7keGf78qacf6IgIAAAAAgEhSKxF+zt0Pm9lFkr5rZj88/R/d3c3sjE2fw0mHvZI0+77ZWmEBAAAAAEA+SZMI7n54+L9HzewBSddJes3Mdrr7ETPbKenoezx3n6R9krT1Q9v9ZH9qNMkxdnOdtH1DMXm6XRa4iaxkYb7QBj02Qoqq3ShzR0ANzYLxi+ytci53BFT0FodeWF0fUTuDmc2a2fw7f0v6eUk/kPSQpD3Dh+2R9GClpAAAAAAAIISUy5M7JD1gq3uMNSX9ubt/28welXS/md0u6SVJt5y7mAAAAAAAILc1JxHc/QVJV53h/jcl3bCeNxuo0GK/vZ6nYII0zrzsBQIYlJRTR/YeS84gCGuyO0NUS312RolspkkrX2QrA46/qErnvDOqQeLYMcIAAAAAACDJWKdoTa520R/nW2KEZtkvO6y52eXcEVBDq8kKRZGt9LgaGtXALXcE1MD4xcbVbGBycXQCAAAAAIAkTCIAAAAAAIAkY25nkAoWCAvrRHcqdwRUNNWijSgyyuFjo6Q6rnLAtZbITnQ7uSOghoH47IyqZbRhRmVK+63OtyMAAAAAAEjCJAIAAAAAAEgy1hrZhg20ucUq8VH9eLA1dwRU1G5QVhZZlzaw0BYXaAWLatM05yyRbWnQygfksDho546AilLbiKhEAAAAAAAASZhEAAAAAAAAScbaztAbNHRkadM43xIj5KwwHtbRY/O5I6AGjr3YBiuN3BFQUasY5I6AGroDjr3IisRV4jF5tjYXckdARQ1L+96jEgEAAAAAACQZayWCa7UaATGdWmJxsKi4kh1bf3GsH9UYsaLDwqZRtViUNrRtU4u5I6CGt8vp3BFQUc/5vRdV6Wk1BlQiAAAAAACAJEwiAAAAAACAJGOtkS3MNd9iz+WoVhZbuSOgIitYnCg0pntD8wHtRFENaAUL7VSPNszI5uf4zRDVXIOxi4qFFQEAAAAAwEgxiQAAAAAAAJIktTOY2RZJd0n6sFY3WfiPkp6VdJ+k3ZJelHSLux876+totaUBMc1uojQpqoUTndwRUEefkurIfJndNaLqlawwHlm7088dATW8tHRB7gioaMfUidwRUFE/cWeN1EqEL0r6trt/SNJVkp6RdKekA+5+uaQDw9sAAAAAAGCDWvPyiJltlvQJSf9Bkty9K6lrZjdLun74sP2SHpZ0x9leyyV1B1yRicqoIgmr0UpbJAWTqd/lamhobY6/qBoFYxfZYr+dOwJquGjqVO4IAN5DSiXCZZJel/SnZvaEmd1lZrOSdrj7keFjXpW041yFBAAAAAAA+aVMIjQlfUTSl9z9GkkLelfrgru7VgsN/hkz22tmB83sYPf4Ut28AAAAAAAgk5TegkOSDrn7I8PbX9PqJMJrZrbT3Y+Y2U5JR8/0ZHffJ2mfJF105QX+EzNnXXsRE+zwiU25I6CicqqXOwJqKBqUVEfWXaCkOioWg45te4dy+Mg2Nbn4GNWOFgsrRtWyMulxa1YiuPurkl42syuGd90g6WlJD0naM7xvj6QH1x8TAAAAAABEkbrK4W9K+qqZtSW9IOnXtDoBcb+Z3S7pJUm3nJuIAAAAAABgEiRNIrj7k5KuPcM/3bCeNyu90PHe9HqeggnSabHfclTL3VbuCKiB3RliM9pRwjq+1MkdATW0CtowIyvdckdARRe2aCWKypV23KUsrAgAAAAAAMAkAgAAAAAASJO6JsJILJdNPf/2BeN8S4zQwgorjEc12+nmjoAaypL53sh6r8zmjoCKVuZpBYtsrrWSOwJq+Km5I7kjoKLUFf4xeUxpuxJxZgoAAAAAAJKMtRKhVZTaMcNCG1EdLjfnjoCKygGLE0W2ZY69siN78yIWxoxqaYEKvMhObmZhzMh6zmdnVDMFVUBRFVQiAAAAAACAUWISAQAAAAAAJBlrO0NhrpkmC7xFtX2WVpSoXjs1lzsCajh2ciZ3BNTQaLLAVFRll3aGyK7edih3BNRw2dTruSOgIlpRIqOdAQAAAAAAjBCTCAAAAAAAIMlY2xlKL3Six0q5Ua2UY/2/C0aoV1JWFlnZZ/wi87TKQEygrReczB0BNcw3lnNHQA27W7QzRPWB5mLuCKjoi4k7a1CJAAAAAAAAkjCJAAAAAAAAkoy1Pr1T9PTBeUqTonplaXPuCKhopU8rSmQz7V7uCAAQzoVN2lEiu7hBSXxUO5vsChZVy44lPY5KBAAAAAAAkGSslyenir5+skMlQlTdAVezo1rss9d5ZK+c2JQ7Ampwt9wRUJEZq2JG9qGpI7kjoIbLWlzNBiYVlQgAAAAAACAJkwgAAAAAACDJmvXpZnaFpPtOu+sDkv6rpK8M798t6UVJt7j7WVdi6HpTh7pbq2ZFZqcoiQ9r5/SJ3BFQw5b2Uu4IqOGZNy/KHQEVnVrs5I6AGmYS9zvHpGrlDgDgPaxZieDuz7r71e5+taSfkbQo6QFJd0o64O6XSzowvA0AAAAAADao9bYz3CDpeXd/SdLNkvYP798v6RdHGQwAAAAAAEyW9S63f6uke4Z/73D3d5a9fVXSjrWePFOs6Gdm/3Gdb4lJ8c3lq3JHQEWFDXJHQA2bWsu5I6CGnfPsVR9Vb4Z96iPb3ezmjoBaaGcAJlVyJYKZtSV9VtJfvPvf3N0lnXEfJDPba2YHzezgybf6lYMCAAAAAIC81lOJ8GlJj7v7a8Pbr5nZTnc/YmY7JR0905PcfZ+kfZJ09VVtv3GaPXuj2rKdKzJRLTuz+ZE9tnhZ7gio4cVT23JHQEX/csuruSMAADBx1rMmwm36/60MkvSQpD3Dv/dIenBUoQAAAAAAwORJmkQws1lJN0r6xml3f0HSjWb2D5I+NbwNAAAAAAA2qKR2BndfkHTBu+57U6u7NSRryDRXTK3nKZggs+y3HNYWoxUlsn/RoaQ6sp07jueOgIreLmdyR0ANr5fr3YQMk+T4YCF3BFR0ckAbbVQLfsZlDv8ZPl0BAAAAAEASJhEAAAAAAECS9ezOUNuSu57qss1jVC/33pc7Aip6s5zLHQE1bGnQjhLZxa1juSOgopaVuSOghuMDWmgju6rdzR0BFb1ljF1ULQ2SHkclAgAAAAAASMIkAgAAAAAASDLWdoaWXDsavXG+JUao2z6aOwIqKnpppUmYTB3jczOyNiXxYTWMz87Iej7W01yM2LM9WqCjmjGuU0dVypIexwgDAAAAAIAk461EsIZ2NlngLar5Yjl3BFT0geYruSOghkbirDAm00v9Ru4IqOji5tu5IwDnre0FlQhRvT6gCigqT3wclQgAAAAAACAJkwgAAAAAACDJWGtNln2gH/UWxvmWGKFX+vO5I6CiH/e25Y6AGn6SRU1D6xgluVF1nWstkV1QrOSOgBpogY5rZ+4AqCx1UUy+HQEAAAAAQBImEQAAAAAAQJKxtjM0TdrGtEVYO6ZoRYlqW2MxdwTU8OTyrtwRgPPS4mAqdwTU8K9nnssdATU8ttLNHQE47yx42v4M/KQHAAAAAABJmEQAAAAAAABJxtvOoEIXNmbH+ZYAJP10O3cC1PH+5su5I6CGFR/kjoCKXi+51hLZrrGe5WLUNhecvES1OKAVJappS3sc344AAAAAACDJWOdoXy9b2vf2xeN8S4xQQ1xNi+qS1rHcEVBDyxq5I6CGnnM5NKqW9XNHQA2lWBA6sktZFDqsntIW58PkKRPHjkoEAAAAAACQhEkEAAAAAACQxDxxL8iRvJnZ65JeGtsbjt+Fkt7IHQKVMHaxMX5xMXaxMX6xMX5xMXaxMX5xbfSxe7+7b1/rQWOdRNjozOygu1+bOwfWj7GLjfGLi7GLjfGLjfGLi7GLjfGLi7FbRTsDAAAAAABIwiQCAAAAAABIwiTCaO3LHQCVMXaxMX5xMXaxMX6xMX5xMXaxMX5xMXZiTQQAAAAAAJCISgQAAAAAAJCESYQRMLObzOxZM3vOzO7MnQfpzOzLZnbUzH6QOwvWx8wuNbPvmdnTZvaUmX0udyakM7OOmf2dmf39cPx+P3cmrI+ZNczsCTP7Zu4sWB8ze9HMvm9mT5rZwdx5sD5mtsXMvmZmPzSzZ8zsZ3NnwtrM7IrhMffOfyfM7PO5cyGdmf3n4TnLD8zsHjPr5M6UC+0MNZlZQ9KPJN0o6ZCkRyXd5u5PZw2GJGb2CUmnJH3F3T+cOw/SmdlOSTvd/XEzm5f0mKRf5NiLwcxM0qy7nzKzlqS/kfQ5d/8/maMhkZn9lqRrJW1y98/kzoN0ZvaipGvdfSPvdb5hmdl+Sf/b3e8ys7akGXc/njsX0g1/PxyW9FF3fyl3HqzNzC7R6rnKle6+ZGb3S/qWu/9Z3mR5UIlQ33WSnnP3F9y9K+leSTdnzoRE7v7Xkt7KnQPr5+5H3P3x4d8nJT0j6ZK8qZDKV50a3mwN/2NWOwgz2yXpFyTdlTsLcD4xs82SPiHpbkly9y4TCCHdIOl5JhDCaUqaNrOmpBlJr2TOkw2TCPVdIunl024fEj9kgLEys92SrpH0SN4kWI9hOfyTko5K+q67M35x/Imk35Y0yB0Elbik75jZY2a2N3cYrMtlkl6X9KfDdqK7zGw2dyis261ZQDfOAAACT0lEQVSS7skdAunc/bCk/yHpx5KOSHrb3b+TN1U+TCIACM3M5iR9XdLn3f1E7jxI5+6lu18taZek68yMlqIAzOwzko66+2O5s6Cyn3P3j0j6tKRfH7b2IYampI9I+pK7XyNpQRLrcQUybEH5rKS/yJ0F6cxsq1arzS+TdLGkWTP793lT5cMkQn2HJV162u1dw/sAnGPDXvqvS/qqu38jdx5UMyzF/Z6km3JnQZKPS/rssK/+XkmfNLP/mTcS1mN4RU3uflTSA1ptzUQMhyQdOq1y62tanVRAHJ+W9Li7v5Y7CNblU5L+0d1fd/eepG9I+leZM2XDJEJ9j0q63MwuG84s3irpocyZgA1vuDDf3ZKecfc/yp0H62Nm281sy/Dvaa0uTvvDvKmQwt1/x913ufturX7n/ZW7n7dXY6Ixs9nhYrQalsH/vCR2KArC3V+V9LKZXTG86wZJLCgcy22ilSGiH0v6mJnNDM9Bb9DqelznpWbuANG5e9/MfkPSX0pqSPqyuz+VORYSmdk9kq6XdKGZHZL039z97rypkOjjkn5V0veHffWS9Lvu/q2MmZBup6T9wxWqC0n3uztbBQLn3g5JD6yeA6sp6c/d/dt5I2GdflPSV4cXr16Q9GuZ8yDRcOLuRkn/KXcWrI+7P2JmX5P0uKS+pCck7cubKh+2eAQAAAAAAEloZwAAAAAAAEmYRAAAAAAAAEmYRAAAAAAAAEmYRAAAAAAAAEmYRAAAAAAAAEmYRAAAAAAAAEmYRAAAAAAAAEmYRAAAAAAAAEn+H4L6KmdANU8iAAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_spec(m[0].numpy())\n", + "plot_spec(mels[0].cpu().detach().numpy().T)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "global step\n", + "step = 0" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array(0)" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "if not os.path.exists(STEP_PATH):\n", + " np.save(STEP_PATH, step)\n", + "step = np.load(STEP_PATH)\n", + "step" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "def train(model, optimiser, epochs, batch_size, classes, seq_len, step, lr=1e-4) :\n", + " \n", + " for p in optimiser.param_groups : p['lr'] = lr\n", + " criterion = nn.NLLLoss().cuda()\n", + " \n", + " for e in range(epochs) :\n", + "\n", + " trn_loader = DataLoader(dataset, collate_fn=collate, batch_size=batch_size, \n", + " num_workers=2, shuffle=True, pin_memory=True)\n", + " \n", + " running_loss = 0.\n", + " val_loss = 0.\n", + " start = time.time()\n", + " running_loss = 0.\n", + "\n", + " iters = len(trn_loader)\n", + "\n", + " for i, (x, m, y) in enumerate(trn_loader) :\n", + " \n", + " x, m, y = x.cuda(), m.cuda(), y.cuda()\n", + "\n", + " y_hat = model(x, m)\n", + " y_hat = y_hat.transpose(1, 2).unsqueeze(-1)\n", + " y = y.unsqueeze(-1)\n", + " loss = criterion(y_hat, y)\n", + " \n", + " optimiser.zero_grad()\n", + " loss.backward()\n", + " optimiser.step()\n", + " running_loss += loss.item()\n", + " \n", + " speed = (i + 1) / (time.time() - start)\n", + " avg_loss = running_loss / (i + 1)\n", + " \n", + " step += 1\n", + " k = step // 1000\n", + " stream('Epoch: %i/%i -- Batch: %i/%i -- Loss: %.3f -- %.2f steps/sec -- Step: %ik ', \n", + " (e + 1, epochs, i + 1, iters, avg_loss, speed, k))\n", + " \n", + " torch.save(model.state_dict(), MODEL_PATH)\n", + " np.save(STEP_PATH, step)\n", + " print(' ')" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "optimiser = optim.Adam(model.parameters())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 1/1000 -- Batch: 22/674 -- Loss: 5.533 -- 3.58 steps/sec -- Step: 0k " + ] + } + ], + "source": [ + "train(model, optimiser, epochs=1000, batch_size=16, classes=2**bits, \n", + " seq_len=seq_len, step=step, lr=1e-4)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Generate Samples" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": { + "code_folding": [] + }, + "outputs": [], + "source": [ + "def generate(samples=3, batched=True, target=11_000, overlap=550) :\n", + " outputs = []\n", + " k = step // 1000\n", + " test_mels = [np.load(f'{DATA_PATH}mel/{id}.npy') for id in test_ids[:samples]]\n", + " ground_truth = [np.load(f'{DATA_PATH}quant/{id}.npy') for id in test_ids[:samples]]\n", + " for i, (gt, mel) in enumerate(zip(ground_truth, test_mels)) :\n", + " print('\\nGenerating: %i/%i' % (i+1, samples))\n", + " gt = 2 * gt.astype(np.float32) / (2**bits - 1.) - 1.\n", + " librosa.output.write_wav(f'{GEN_PATH}{k}k_steps_{i}_target.wav', gt, sr=sample_rate)\n", + " if batched :\n", + " save_str = f'{GEN_PATH}{k}k_steps_{i}_gen_batched_target{target}_overlap{overlap}.wav'\n", + " else : \n", + " save_str = f'{GEN_PATH}{k}k_steps_{i}_gen_not_batched.wav'\n", + " outputs.append(model.generate(mel, save_str, batched, target, overlap))\n", + " \n", + " for output in outputs:\n", + " plot(output)" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Generating: 1/3\n", + "157500/157575 -- batch_size: 1 -- gen_rate: 2.3 kHz -- x_realtime: 0.1 \n", + "Generating: 2/3\n", + "61300/61325 -- batch_size: 1 -- gen_rate: 2.4 kHz -- x_realtime: 0.1 \n", + "Generating: 3/3\n", + "162500/162525 -- batch_size: 1 -- gen_rate: 2.4 kHz -- x_realtime: 0.1 " + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "generate(batched=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Generating: 1/3\n", + "168000/169400 -- batch_size: 14 -- gen_rate: 33.0 kHz -- x_realtime: 1.5 \n", + "Generating: 2/3\n", + "72000/72600 -- batch_size: 6 -- gen_rate: 14.5 kHz -- x_realtime: 0.7 \n", + "Generating: 3/3\n", + "180000/181500 -- batch_size: 15 -- gen_rate: 35.7 kHz -- x_realtime: 1.6 " + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "generate(batched=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/models/WaveRNNModel/notebooks/Pruning - Scratchpad.ipynb b/models/WaveRNNModel/notebooks/Pruning - Scratchpad.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..0fa30957e07a87fcd1d11b1c8d4bbf4936402808 --- /dev/null +++ b/models/WaveRNNModel/notebooks/Pruning - Scratchpad.ipynb @@ -0,0 +1,691 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "from utils.display import *" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def np_now(tensor) : return tensor.detach().cpu().numpy()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def clamp(x, lo=0, hi=1) : return max(lo, min(hi, x))" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "code_folding": [] + }, + "outputs": [], + "source": [ + "class PruneMask() :\n", + " def __init__(self, layer, prune_rnn_input) :\n", + " self.mask = []\n", + " self.p_idx = [0]\n", + " self.total_params = 0\n", + " self.pruned_params = 0\n", + " self.split_size = 0\n", + " self.init_mask(layer, prune_rnn_input)\n", + " \n", + " \n", + " def init_mask(self, layer, prune_rnn_input) :\n", + " # Determine the layer type and \n", + " # num matrix splits if rnn \n", + " layer_type = str(layer).split('(')[0]\n", + " splits = {'Linear': 1, 'GRU': 3, 'LSTM': 4}\n", + " \n", + " # Organise the num and indices of layer parameters\n", + " # Dense will have one index and rnns two (if pruning input)\n", + " if layer_type != 'Linear' : \n", + " self.p_idx = [0, 1] if prune_rnn_input else [1]\n", + " \n", + " # Get list of parameters from layers\n", + " params = self.get_params(layer)\n", + " \n", + " # For each param matrix in this layer, create a mask\n", + " for W in params :\n", + " self.mask += [torch.ones_like(W)]\n", + " self.total_params += W.size(0) * W.size(1)\n", + " \n", + " # Need a split size for mask_from_matrix() later on\n", + " self.split_size = self.mask[0].size(0) // splits[layer_type]\n", + "\n", + " \n", + " def get_params(self, layer) :\n", + " params = []\n", + " for idx in self.p_idx : \n", + " params += [list(layer.parameters())[idx].data]\n", + " return params\n", + " \n", + " \n", + " def update_mask(self, layer, z) :\n", + " params = self.get_params(layer)\n", + " for i, W in enumerate(params) :\n", + " self.mask[i] = self.mask_from_matrix(W, z)\n", + " self.update_prune_count()\n", + " \n", + " \n", + " def apply_mask(self, layer) :\n", + " params = self.get_params(layer)\n", + " for M, W in zip(self.mask, params) : W *= M\n", + "\n", + " \n", + " def mask_from_matrix(self, W, z) : \n", + " # Split into gate matrices (or not)\n", + " W_split = torch.split(W, self.split_size)\n", + " \n", + " M = []\n", + " # Loop through splits \n", + " for W in W_split :\n", + " # Sort the magnitudes\n", + " W_abs = torch.abs(W)\n", + " sorted_abs, _ = torch.sort(W_abs.view(-1))\n", + "\n", + " # Pick k (num weights to zero) \n", + " k = int(W.size(0) * W.size(1) * z) \n", + " threshold = sorted_abs[k]\n", + " \n", + " # Create the mask\n", + " M += [(W_abs >= threshold).float()]\n", + "\n", + " return torch.cat(M)\n", + " \n", + " \n", + " def update_prune_count(self) :\n", + " self.pruned_params = 0\n", + " for M in self.mask :\n", + " self.pruned_params += int(np_now((M - 1).sum() * -1))" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "code_folding": [] + }, + "outputs": [], + "source": [ + "class Pruner() :\n", + " def __init__(self, layers, start_prune, prune_steps, target_sparsity, \n", + " prune_rnn_input=True, prune_every=500) :\n", + " self.z = 0 # Objects sparsity @ time t\n", + " self.t_0 = start_prune\n", + " self.S = prune_steps\n", + " self.Z = target_sparsity\n", + " self.prune_every = prune_every\n", + " self.num_pruned = 0\n", + " self.total_params = 0\n", + " self.masks = []\n", + " for layer in layers : \n", + " self.masks += [PruneMask(layer, prune_rnn_input)]\n", + " self.count_total_params()\n", + " \n", + " \n", + " def update_sparsity(self, t) :\n", + " t = np_now(t)[0]\n", + " z = self.Z * (1 - (1 - (t - self.t_0) / self.S)**3)\n", + " self.z = clamp(z, 0, self.Z)\n", + " return t \n", + " \n", + " \n", + " def prune(self, layers, t) :\n", + " \n", + " t = self.update_sparsity(t)\n", + " \n", + " for (l, m) in zip(layers, self.masks) :\n", + " if self.prune_or_not(t) : m.update_mask(l, self.z)\n", + " if self.apply_or_not(t) : m.apply_mask(l)\n", + " self.count_num_pruned()\n", + " \n", + " \n", + " def prune_or_not(self, t) :\n", + " return True if t % self.prune_every == 0 and t > self.t_0 else False\n", + " \n", + " \n", + " def apply_or_not(self, t) :\n", + " return True if t >= self.t_0 else False\n", + " \n", + " \n", + " def restart(self, layers, t) :\n", + " # In case training is stopped\n", + " _ = self.update_sparsity(t)\n", + " for (l, m) in zip(layers, self.masks) :\n", + " m.update_mask(l, self.z)\n", + " \n", + " \n", + " def count_num_pruned(self) :\n", + " self.num_pruned = 0\n", + " for m in self.masks : \n", + " self.num_pruned += m.pruned_params\n", + " \n", + " \n", + " def count_total_params(self) :\n", + " for m in self.masks : \n", + " self.total_params += m.total_params" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "code_folding": [] + }, + "outputs": [], + "source": [ + "class Model(nn.Module) :\n", + " def __init__(self, in_size, model_size, start_prune=1000, prune_steps=200_000, \n", + " sparsity_target=0.98) :\n", + " super().__init__()\n", + " # Model Layers\n", + " self.rnn = nn.GRU(in_size, model_size)\n", + " self.fc = nn.Linear(model_size, model_size)\n", + " self.t = nn.Parameter(torch.zeros(1), requires_grad=False)\n", + " # Model Pruner\n", + " self.layers2prune = [self.rnn, self.fc]\n", + " self.pruner = Pruner(self.layers2prune, start_prune, \n", + " prune_steps, sparsity_target )\n", + " num_params(self)\n", + " \n", + " def forward(self) :\n", + " \n", + "# h = torch.ones(1, 2)\n", + "# x = self.rnn(x, h)\n", + "# x = self.fc(x)\n", + " \n", + " self.prune()\n", + " self.step()\n", + " \n", + " return True \n", + " \n", + " def step(self) :\n", + " self.t += 1\n", + " \n", + " def prune(self) :\n", + " self.pruner.prune(self.layers2prune, self.t)\n", + " \n", + " def restart_pruner(self) :\n", + " self.pruner.restart(self.layer2prune, self.t)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Trainable Parameters: 1.249 million\n" + ] + } + ], + "source": [ + "in_size = 128\n", + "model_size = 512\n", + "start_prune = 10\n", + "prune_steps = 20000\n", + "sparsity_target = 0.9375\n", + "model = Model(in_size, model_size, start_prune, prune_steps, sparsity_target)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "196608 torch.Size([1536, 128])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "786432 torch.Size([1536, 512])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "262144 torch.Size([512, 512])\n" + ] + } + ], + "source": [ + "param_idx = [1, 2, 5]\n", + "for idx in param_idx :\n", + " W = list(model.parameters())[idx].data\n", + " plot_spec(W)\n", + " print(W.size(0) * W.size(1), W.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "21000/21010" + ] + } + ], + "source": [ + "sparsity = []\n", + "pruned_params = []\n", + "num_steps = start_prune + prune_steps + 1000\n", + "for step in range(num_steps) :\n", + " model()\n", + " sparsity += [model.pruner.z]\n", + " pruned_params += [model.pruner.num_pruned]\n", + " if step % 100 == 0 : stream('%i/%i', (step, num_steps))" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot(sparsity)\n", + "plot(pruned_params)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "196608 torch.Size([1536, 128])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "786432 torch.Size([1536, 512])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "262144 torch.Size([512, 512])\n" + ] + } + ], + "source": [ + "param_idx = [1, 2, 5]\n", + "for idx in param_idx :\n", + " W = list(model.parameters())[idx].data\n", + " plot_spec(torch.abs(W))\n", + " print(W.size(0) * W.size(1), W.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.9375, 0.9375)" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.pruner.Z, model.pruner.z" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(1167360, 1245184)" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.pruner.num_pruned, model.pruner.total_params, " + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.9375" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.pruner.num_pruned / model.pruner.total_params" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "77824" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.pruner.total_params - model.pruner.num_pruned" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Trainable Parameters: 0.000 million\n" + ] + }, + { + "data": { + "text/plain": [ + "OrderedDict([('t', tensor([44000.])), ('rnn.weight_ih_l0', tensor([[ 0.5376],\n", + " [-0.2343],\n", + " [-0.5191],\n", + " [-0.4536],\n", + " [-0.6217],\n", + " [ 0.2389]])), ('rnn.weight_hh_l0',\n", + " tensor([[-0.0653, -0.0993],\n", + " [ 0.4324, -0.4442],\n", + " [ 0.2594, 0.0243],\n", + " [-0.5932, 0.1905],\n", + " [-0.2087, 0.0661],\n", + " [-0.4895, 0.2997]])), ('rnn.bias_ih_l0',\n", + " tensor([-0.0783, -0.6947, 0.3538, -0.4331, 0.3925, -0.3648])), ('rnn.bias_hh_l0',\n", + " tensor([ 0.0118, -0.3718, -0.5706, 0.3553, -0.4856, -0.6507])), ('fc.weight',\n", + " tensor([[-0.5647, -0.1977],\n", + " [ 0.4500, 0.6082]])), ('fc.bias',\n", + " tensor([-0.6405, -0.0204]))])" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model = Model(in_size=1, model_size=2)\n", + "model.t += 44_000\n", + "model.state_dict()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.5059381075" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.prune()\n", + "model.pruner.z" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "OrderedDict([('t', tensor([44000.])), ('rnn.weight_ih_l0', tensor([[ 0.5376],\n", + " [-0.0000],\n", + " [-0.5191],\n", + " [-0.0000],\n", + " [-0.6217],\n", + " [ 0.0000]])), ('rnn.weight_hh_l0',\n", + " tensor([[-0.0000, -0.0000],\n", + " [ 0.4324, -0.4442],\n", + " [ 0.2594, 0.0000],\n", + " [-0.5932, 0.0000],\n", + " [-0.0000, 0.0000],\n", + " [-0.4895, 0.2997]])), ('rnn.bias_ih_l0',\n", + " tensor([-0.0783, -0.6947, 0.3538, -0.4331, 0.3925, -0.3648])), ('rnn.bias_hh_l0',\n", + " tensor([ 0.0118, -0.3718, -0.5706, 0.3553, -0.4856, -0.6507])), ('fc.weight',\n", + " tensor([[-0.5647, -0.0000],\n", + " [ 0.0000, 0.6082]])), ('fc.bias',\n", + " tensor([-0.6405, -0.0204]))])" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.state_dict()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/models/WaveRNNModel/notebooks/__init__.py b/models/WaveRNNModel/notebooks/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/models/WaveRNNModel/notebooks/models/wavernn.py b/models/WaveRNNModel/notebooks/models/wavernn.py new file mode 100644 index 0000000000000000000000000000000000000000..c27bc74609cb2844ba35915b42f888add1e2c48e --- /dev/null +++ b/models/WaveRNNModel/notebooks/models/wavernn.py @@ -0,0 +1,172 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F + + +class WaveRNN(nn.Module) : + def __init__(self, hidden_size=896, quantisation=256) : + super(WaveRNN, self).__init__() + + self.hidden_size = hidden_size + self.split_size = hidden_size // 2 + + # The main matmul + self.R = nn.Linear(self.hidden_size, 3 * self.hidden_size, bias=False) + + # Output fc layers + self.O1 = nn.Linear(self.split_size, self.split_size) + self.O2 = nn.Linear(self.split_size, quantisation) + self.O3 = nn.Linear(self.split_size, self.split_size) + self.O4 = nn.Linear(self.split_size, quantisation) + + # Input fc layers + self.I_coarse = nn.Linear(2, 3 * self.split_size, bias=False) + self.I_fine = nn.Linear(3, 3 * self.split_size, bias=False) + + # biases for the gates + self.bias_u = nn.Parameter(torch.zeros(self.hidden_size)) + self.bias_r = nn.Parameter(torch.zeros(self.hidden_size)) + self.bias_e = nn.Parameter(torch.zeros(self.hidden_size)) + + # display num params + self.num_params() + + + def forward(self, prev_y, prev_hidden, current_coarse) : + + # Main matmul - the projection is split 3 ways + R_hidden = self.R(prev_hidden) + R_u, R_r, R_e, = torch.split(R_hidden, self.hidden_size, dim=1) + + # Project the prev input + coarse_input_proj = self.I_coarse(prev_y) + I_coarse_u, I_coarse_r, I_coarse_e = \ + torch.split(coarse_input_proj, self.split_size, dim=1) + + # Project the prev input and current coarse sample + fine_input = torch.cat([prev_y, current_coarse], dim=1) + fine_input_proj = self.I_fine(fine_input) + I_fine_u, I_fine_r, I_fine_e = \ + torch.split(fine_input_proj, self.split_size, dim=1) + + # concatenate for the gates + I_u = torch.cat([I_coarse_u, I_fine_u], dim=1) + I_r = torch.cat([I_coarse_r, I_fine_r], dim=1) + I_e = torch.cat([I_coarse_e, I_fine_e], dim=1) + + # Compute all gates for coarse and fine + u = F.sigmoid(R_u + I_u + self.bias_u) + r = F.sigmoid(R_r + I_r + self.bias_r) + e = F.tanh(r * R_e + I_e + self.bias_e) + hidden = u * prev_hidden + (1. - u) * e + + # Split the hidden state + hidden_coarse, hidden_fine = torch.split(hidden, self.split_size, dim=1) + + # Compute outputs + out_coarse = self.O2(F.relu(self.O1(hidden_coarse))) + out_fine = self.O4(F.relu(self.O3(hidden_fine))) + + return out_coarse, out_fine, hidden + + + def generate(self, seq_len) : + + with torch.no_grad() : + + # First split up the biases for the gates + b_coarse_u, b_fine_u = torch.split(self.bias_u, self.split_size) + b_coarse_r, b_fine_r = torch.split(self.bias_r, self.split_size) + b_coarse_e, b_fine_e = torch.split(self.bias_e, self.split_size) + + # Lists for the two output seqs + c_outputs, f_outputs = [], [] + + # Some initial inputs + out_coarse = torch.LongTensor([0]).cuda() + out_fine = torch.LongTensor([0]).cuda() + + # We'll meed a hidden state + hidden = self.init_hidden() + + # Need a clock for display + start = time.time() + + # Loop for generation + for i in range(seq_len) : + + # Split into two hidden states + hidden_coarse, hidden_fine = \ + torch.split(hidden, self.split_size, dim=1) + + # Scale and concat previous predictions + out_coarse = out_coarse.unsqueeze(0).float() / 127.5 - 1. + out_fine = out_fine.unsqueeze(0).float() / 127.5 - 1. + prev_outputs = torch.cat([out_coarse, out_fine], dim=1) + + # Project input + coarse_input_proj = self.I_coarse(prev_outputs) + I_coarse_u, I_coarse_r, I_coarse_e = \ + torch.split(coarse_input_proj, self.split_size, dim=1) + + # Project hidden state and split 6 ways + R_hidden = self.R(hidden) + R_coarse_u , R_fine_u, \ + R_coarse_r, R_fine_r, \ + R_coarse_e, R_fine_e = torch.split(R_hidden, self.split_size, dim=1) + + # Compute the coarse gates + u = F.sigmoid(R_coarse_u + I_coarse_u + b_coarse_u) + r = F.sigmoid(R_coarse_r + I_coarse_r + b_coarse_r) + e = F.tanh(r * R_coarse_e + I_coarse_e + b_coarse_e) + hidden_coarse = u * hidden_coarse + (1. - u) * e + + # Compute the coarse output + out_coarse = self.O2(F.relu(self.O1(hidden_coarse))) + posterior = F.softmax(out_coarse, dim=1) + distrib = torch.distributions.Categorical(posterior) + out_coarse = distrib.sample() + c_outputs.append(out_coarse) + + # Project the [prev outputs and predicted coarse sample] + coarse_pred = out_coarse.float() / 127.5 - 1. + fine_input = torch.cat([prev_outputs, coarse_pred.unsqueeze(0)], dim=1) + fine_input_proj = self.I_fine(fine_input) + I_fine_u, I_fine_r, I_fine_e = \ + torch.split(fine_input_proj, self.split_size, dim=1) + + # Compute the fine gates + u = F.sigmoid(R_fine_u + I_fine_u + b_fine_u) + r = F.sigmoid(R_fine_r + I_fine_r + b_fine_r) + e = F.tanh(r * R_fine_e + I_fine_e + b_fine_e) + hidden_fine = u * hidden_fine + (1. - u) * e + + # Compute the fine output + out_fine = self.O4(F.relu(self.O3(hidden_fine))) + posterior = F.softmax(out_fine, dim=1) + distrib = torch.distributions.Categorical(posterior) + out_fine = distrib.sample() + f_outputs.append(out_fine) + + # Put the hidden state back together + hidden = torch.cat([hidden_coarse, hidden_fine], dim=1) + + # Display progress + speed = (i + 1) / (time.time() - start) + stream('Gen: %i/%i -- Speed: %i', (i + 1, seq_len, speed)) + + coarse = torch.stack(c_outputs).squeeze(1).cpu().data.numpy() + fine = torch.stack(f_outputs).squeeze(1).cpu().data.numpy() + output = combine_signal(coarse, fine) + + return output, coarse, fine + + + def init_hidden(self, batch_size=1) : + return torch.zeros(batch_size, self.hidden_size).cuda() + + + def num_params(self) : + parameters = filter(lambda p: p.requires_grad, self.parameters()) + parameters = sum([np.prod(p.size()) for p in parameters]) / 1_000_000 + print('Trainable Parameters: %.3f million' % parameters) \ No newline at end of file diff --git a/models/WaveRNNModel/notebooks/outputs/nb1/model_output.wav b/models/WaveRNNModel/notebooks/outputs/nb1/model_output.wav new file mode 100644 index 0000000000000000000000000000000000000000..7b8d5003fcc547949b5871cad952009a558fa169 Binary files /dev/null and b/models/WaveRNNModel/notebooks/outputs/nb1/model_output.wav differ diff --git a/models/WaveRNNModel/notebooks/outputs/nb2/3k_steps.wav b/models/WaveRNNModel/notebooks/outputs/nb2/3k_steps.wav new file mode 100644 index 0000000000000000000000000000000000000000..8efce570f49ba5a5d962edd2cf8ad47de5025b08 --- /dev/null +++ b/models/WaveRNNModel/notebooks/outputs/nb2/3k_steps.wav @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:eeadf150c5e62325421d700609eec88c106ba86330a011d6b54542a8764a0728 +size 220544 diff --git a/models/WaveRNNModel/notebooks/outputs/nb3/12k_steps.wav b/models/WaveRNNModel/notebooks/outputs/nb3/12k_steps.wav new file mode 100644 index 0000000000000000000000000000000000000000..1165ad6ee4c0d3365074e5fce1eb5d381b9da8f3 --- /dev/null +++ b/models/WaveRNNModel/notebooks/outputs/nb3/12k_steps.wav @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b18a69000c2f2852d1b9f5104a7f9bc3421882c5ff2847f7185b081c9feab0b8 +size 882044 diff --git a/models/WaveRNNModel/notebooks/utils/__init__.py b/models/WaveRNNModel/notebooks/utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/models/WaveRNNModel/notebooks/utils/display.py b/models/WaveRNNModel/notebooks/utils/display.py new file mode 100644 index 0000000000000000000000000000000000000000..54d58cdf1e8252fab8007a83a539a244a354a5f5 --- /dev/null +++ b/models/WaveRNNModel/notebooks/utils/display.py @@ -0,0 +1,40 @@ +import matplotlib.pyplot as plt +import time, sys, math +import numpy as np + +def stream(string, variables) : + sys.stdout.write(f'\r{string}' % variables) + +def num_params(model) : + parameters = filter(lambda p: p.requires_grad, model.parameters()) + parameters = sum([np.prod(p.size()) for p in parameters]) / 1_000_000 + print('Trainable Parameters: %.3f million' % parameters) + +def time_since(started) : + elapsed = time.time() - started + m = int(elapsed // 60) + s = int(elapsed % 60) + if m >= 60 : + h = int(m // 60) + m = m % 60 + return f'{h}h {m}m {s}s' + else : + return f'{m}m {s}s' + +def plot(array) : + fig = plt.figure(figsize=(30, 5)) + ax = fig.add_subplot(111) + ax.xaxis.label.set_color('grey') + ax.yaxis.label.set_color('grey') + ax.xaxis.label.set_fontsize(23) + ax.yaxis.label.set_fontsize(23) + ax.tick_params(axis='x', colors='grey', labelsize=23) + ax.tick_params(axis='y', colors='grey', labelsize=23) + plt.plot(array) + +def plot_spec(M) : + M = np.flip(M, axis=0) + plt.figure(figsize=(18,4)) + plt.imshow(M, interpolation='nearest', aspect='auto') + plt.show() + diff --git a/models/WaveRNNModel/notebooks/utils/dsp.py b/models/WaveRNNModel/notebooks/utils/dsp.py new file mode 100644 index 0000000000000000000000000000000000000000..9ddb20c98c1ede816d835ba87f4726ad5afb8153 --- /dev/null +++ b/models/WaveRNNModel/notebooks/utils/dsp.py @@ -0,0 +1,70 @@ +import numpy as np +import librosa, math + +sample_rate = 22050 +n_fft = 2048 +fft_bins = n_fft // 2 + 1 +num_mels = 80 +hop_length = int(sample_rate * 0.0125) # 12.5ms +win_length = int(sample_rate * 0.05) # 50ms +fmin = 40 +min_level_db = -100 +ref_level_db = 20 + +def load_wav(filename, encode=True) : + x = librosa.load(filename, sr=sample_rate)[0] + if encode == True : x = encode_16bits(x) + return x + +def save_wav(y, filename) : + if y.dtype != 'int16' : + y = encode_16bits(y) + librosa.output.write_wav(filename, y.astype(np.int16), sample_rate) + +def split_signal(x) : + unsigned = x + 2**15 + coarse = unsigned // 256 + fine = unsigned % 256 + return coarse, fine + +def combine_signal(coarse, fine) : + return coarse * 256 + fine - 2**15 + +def encode_16bits(x) : + return np.clip(x * 2**15, -2**15, 2**15 - 1).astype(np.int16) + +mel_basis = None + +def linear_to_mel(spectrogram): + global mel_basis + if mel_basis is None: + mel_basis = build_mel_basis() + return np.dot(mel_basis, spectrogram) + +def build_mel_basis(): + return librosa.filters.mel(sample_rate, n_fft, n_mels=num_mels, fmin=fmin) + +def normalize(S): + return np.clip((S - min_level_db) / -min_level_db, 0, 1) + +def denormalize(S): + return (np.clip(S, 0, 1) * -min_level_db) + min_level_db + +def amp_to_db(x): + return 20 * np.log10(np.maximum(1e-5, x)) + +def db_to_amp(x): + return np.power(10.0, x * 0.05) + +def spectrogram(y): + D = stft(y) + S = amp_to_db(np.abs(D)) - ref_level_db + return normalize(S) + +def melspectrogram(y): + D = stft(y) + S = amp_to_db(linear_to_mel(np.abs(D))) + return normalize(S) + +def stft(y): + return librosa.stft(y=y, n_fft=n_fft, hop_length=hop_length, win_length=win_length) \ No newline at end of file diff --git a/models/WaveRNNModel/preprocess.py b/models/WaveRNNModel/preprocess.py new file mode 100644 index 0000000000000000000000000000000000000000..f92d9e72114d3494df619ce3ed08217457f9e0c1 --- /dev/null +++ b/models/WaveRNNModel/preprocess.py @@ -0,0 +1,103 @@ +import glob +from utils.display import * +from utils.dsp import * +from utils import hparams as hp +from multiprocessing import Pool, cpu_count +from utils.paths import Paths +import pickle +import argparse +from utils.text.recipes import ljspeech +from utils.files import get_files +from pathlib import Path + + +# Helper functions for argument types +def valid_n_workers(num): + n = int(num) + if n < 1: + raise argparse.ArgumentTypeError('%r must be an integer greater than 0' % num) + return n + +parser = argparse.ArgumentParser(description='Preprocessing for WaveRNN and Tacotron') +parser.add_argument('--path', '-p', help='directly point to dataset path (overrides hparams.wav_path') +parser.add_argument('--extension', '-e', metavar='EXT', default='.wav', help='file extension to search for in dataset folder') +parser.add_argument('--num_workers', '-w', metavar='N', type=valid_n_workers, default=cpu_count()-1, help='The number of worker threads to use for preprocessing') +parser.add_argument('--hp_file', metavar='FILE', default='hparams.py', help='The file to use for the hyperparameters') + +args = parser.parse_args() +hp.configure(args.hp_file) # Load hparams from file +if args.path is None: + args.path = hp.wav_path + +extension = args.extension +path = args.path + +wav_files = get_files(path, extension) +paths = Paths(hp.data_path, hp.voc_model_id, hp.tts_model_id) + +print(f'\n{len(wav_files)} {extension[1:]} files found in "{path}"\n') + + + +def convert_file(path: Path): + y = load_wav(path) + peak = np.abs(y).max() + if hp.peak_norm or peak > 1.0: + y /= peak + mel = melspectrogram(y) + if hp.voc_mode == 'RAW': + quant = encode_mu_law(y, mu=2**hp.bits) if hp.mu_law else float_2_label(y, bits=hp.bits) + elif hp.voc_mode == 'MOL': + quant = float_2_label(y, bits=16) + + return mel.astype(np.float32), quant.astype(np.int64) + + +def process_wav(path: Path): + wav_id = path.stem + m, x = convert_file(path) + #print("paths.mel:::",paths.mel) + np.save(paths.mel/f'{wav_id}.npy', m, allow_pickle=False) + np.save(paths.quant/f'{wav_id}.npy', x, allow_pickle=False) + return wav_id, m.shape[-1] + +if __name__ == '__main__': + + + if len(wav_files) == 0: + + print('Please point wav_path in hparams.py to your dataset,') + print('or use the --path option.\n') + + else: + + if not hp.ignore_tts: + + text_dict = ljspeech(path) + + with open(paths.data/'text_dict.pkl', 'wb') as f: + pickle.dump(text_dict, f) + + n_workers = max(1, args.num_workers) + + simple_table([ + ('Sample Rate', hp.sample_rate), + ('Bit Depth', hp.bits), + ('Mu Law', hp.mu_law), + ('Hop Length', hp.hop_length), + ('CPU Usage', f'{n_workers}/{cpu_count()}') + ]) + + pool = Pool(processes=n_workers) + dataset = [] + print("test22222") + for i, (item_id, length) in enumerate(pool.imap_unordered(process_wav, wav_files), 1): + dataset += [(item_id, length)] + bar = progbar(i, len(wav_files)) + message = f'{bar} {i}/{len(wav_files)} ' + stream(message) + + with open(paths.data/'dataset.pkl', 'wb') as f: + pickle.dump(dataset, f) + + print('\n\nCompleted. Ready to run "python train_tacotron.py" or "python train_wavernn.py". \n') diff --git a/models/WaveRNNModel/quick_start.py b/models/WaveRNNModel/quick_start.py new file mode 100644 index 0000000000000000000000000000000000000000..47e9c4b4aeacdca7111df45c20d9f0c0283f0ed5 --- /dev/null +++ b/models/WaveRNNModel/quick_start.py @@ -0,0 +1,122 @@ +import torch +from models.fatchord_version import WaveRNN +from utils import hparams as hp +from utils.text.symbols import symbols +from models.tacotron import Tacotron +import argparse +from utils.text import text_to_sequence +from utils.display import save_attention, simple_table +import zipfile, os + + +os.makedirs('quick_start/tts_weights/', exist_ok=True) +os.makedirs('quick_start/voc_weights/', exist_ok=True) + +zip_ref = zipfile.ZipFile('pretrained/ljspeech.wavernn.mol.800k.zip', 'r') +zip_ref.extractall('quick_start/voc_weights/') +zip_ref.close() + +zip_ref = zipfile.ZipFile('pretrained/ljspeech.tacotron.r2.180k.zip', 'r') +zip_ref.extractall('quick_start/tts_weights/') +zip_ref.close() + + +if __name__ == "__main__": + + # Parse Arguments + parser = argparse.ArgumentParser(description='TTS Generator') + parser.add_argument('--input_text', '-i', type=str, help='[string] Type in something here and TTS will generate it!') + parser.add_argument('--batched', '-b', dest='batched', action='store_true', help='Fast Batched Generation (lower quality)') + parser.add_argument('--unbatched', '-u', dest='batched', action='store_false', help='Slower Unbatched Generation (better quality)') + parser.add_argument('--force_cpu', '-c', action='store_true', help='Forces CPU-only training, even when in CUDA capable environment') + parser.add_argument('--hp_file', metavar='FILE', default='hparams.py', + help='The file to use for the hyperparameters') + args = parser.parse_args() + + hp.configure(args.hp_file) # Load hparams from file + + parser.set_defaults(batched=True) + parser.set_defaults(input_text=None) + + batched = args.batched + input_text = args.input_text + + if not args.force_cpu and torch.cuda.is_available(): + device = torch.device('cuda') + else: + device = torch.device('cpu') + print('Using device:', device) + + print('\nInitialising WaveRNN Model...\n') + + # Instantiate WaveRNN Model + voc_model = WaveRNN(rnn_dims=hp.voc_rnn_dims, + fc_dims=hp.voc_fc_dims, + bits=hp.bits, + pad=hp.voc_pad, + upsample_factors=hp.voc_upsample_factors, + feat_dims=hp.num_mels, + compute_dims=hp.voc_compute_dims, + res_out_dims=hp.voc_res_out_dims, + res_blocks=hp.voc_res_blocks, + hop_length=hp.hop_length, + sample_rate=hp.sample_rate, + mode='MOL').to(device) + + voc_model.load('quick_start/voc_weights/latest_weights.pyt') + + print('\nInitialising Tacotron Model...\n') + + # Instantiate Tacotron Model + tts_model = Tacotron(embed_dims=hp.tts_embed_dims, + num_chars=len(symbols), + encoder_dims=hp.tts_encoder_dims, + decoder_dims=hp.tts_decoder_dims, + n_mels=hp.num_mels, + fft_bins=hp.num_mels, + postnet_dims=hp.tts_postnet_dims, + encoder_K=hp.tts_encoder_K, + lstm_dims=hp.tts_lstm_dims, + postnet_K=hp.tts_postnet_K, + num_highways=hp.tts_num_highways, + dropout=hp.tts_dropout, + stop_threshold=hp.tts_stop_threshold).to(device) + + + tts_model.load('quick_start/tts_weights/latest_weights.pyt') + + if input_text: + inputs = [text_to_sequence(input_text.strip(), hp.tts_cleaner_names)] + else: + with open('sentences.txt') as f: + inputs = [text_to_sequence(l.strip(), hp.tts_cleaner_names) for l in f] + + voc_k = voc_model.get_step() // 1000 + tts_k = tts_model.get_step() // 1000 + + r = tts_model.r + + simple_table([('WaveRNN', str(voc_k) + 'k'), + (f'Tacotron(r={r})', str(tts_k) + 'k'), + ('Generation Mode', 'Batched' if batched else 'Unbatched'), + ('Target Samples', 11_000 if batched else 'N/A'), + ('Overlap Samples', 550 if batched else 'N/A')]) + + for i, x in enumerate(inputs, 1): + + print(f'\n| Generating {i}/{len(inputs)}') + _, m, attention = tts_model.generate(x) + + if input_text: + save_path = f'quick_start/__input_{input_text[:10]}_{tts_k}k.wav' + else: + save_path = f'quick_start/{i}_batched{str(batched)}_{tts_k}k.wav' + + # save_attention(attention, save_path) + + m = torch.tensor(m).unsqueeze(0) + m = (m + 4) / 8 + + voc_model.generate(m, save_path, batched, 11_000, 550, hp.mu_law) + + print('\n\nDone.\n') diff --git a/models/WaveRNNModel/quick_start/tts_weights/latest_weights.pyt b/models/WaveRNNModel/quick_start/tts_weights/latest_weights.pyt new file mode 100644 index 0000000000000000000000000000000000000000..1575e93062f812598d6fb69664e86ff31b15ea7c --- /dev/null +++ b/models/WaveRNNModel/quick_start/tts_weights/latest_weights.pyt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9c4c491d6ad43f1b9b9e1f393c7d8437592da4b26412838a7bc20f446b76d2f0 +size 44433225 diff --git a/models/WaveRNNModel/quick_start/voc_weights/latest_weights.pyt b/models/WaveRNNModel/quick_start/voc_weights/latest_weights.pyt new file mode 100644 index 0000000000000000000000000000000000000000..d59d80bd413a112d2c82fc8afdfd97b0f221df90 --- /dev/null +++ b/models/WaveRNNModel/quick_start/voc_weights/latest_weights.pyt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:99e2a93453a8d531ba851b2e5c488105816f7c60ec50153c56436ff9bda8a26a +size 16985706 diff --git a/models/WaveRNNModel/requirements.txt b/models/WaveRNNModel/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..f43f540569ed77706eff2132ea9c2fcc99f8ddec --- /dev/null +++ b/models/WaveRNNModel/requirements.txt @@ -0,0 +1,6 @@ +numpy==1.22.0 +librosa==0.6.3 +matplotlib +unidecode +inflect +nltk \ No newline at end of file diff --git a/models/WaveRNNModel/sentences.txt b/models/WaveRNNModel/sentences.txt new file mode 100644 index 0000000000000000000000000000000000000000..4e8b0d719bf156d9609b0307dc548cdbc004b85d --- /dev/null +++ b/models/WaveRNNModel/sentences.txt @@ -0,0 +1,6 @@ +However, no attempt has been made yet to formulat a relativistic generalisation of action-angle variables for geodesic motion in Kerr spacetime and to calculate the dynamical frequencies of arbitrary bound non-plunging orbits. + +The investigation of bound geodesic orbits in Kerr spacetime presented in this article clearly illustrates that the properties of these orbits in the regime of strong gravity are profoundly different from Keplerian orbits in the Newtonian regime. + +The observation of as few as ten EMRIs can provide a measurement of the slope of the black-hole mass function to better precision than is currently known. + diff --git a/models/WaveRNNModel/source.txt b/models/WaveRNNModel/source.txt new file mode 100644 index 0000000000000000000000000000000000000000..48396a9ac05187aae6e5afa8a80cd94bb3eaa847 --- /dev/null +++ b/models/WaveRNNModel/source.txt @@ -0,0 +1 @@ +https://github.com/Adwardgyhjs/RNNoiseAndWaveRNN \ No newline at end of file diff --git a/models/WaveRNNModel/train_tacotron.py b/models/WaveRNNModel/train_tacotron.py new file mode 100644 index 0000000000000000000000000000000000000000..84f4ce7c117534e84398ae76a9a74aecb960723a --- /dev/null +++ b/models/WaveRNNModel/train_tacotron.py @@ -0,0 +1,203 @@ +import torch +from torch import optim +import torch.nn.functional as F +from utils import hparams as hp +from utils.display import * +from utils.dataset import get_tts_datasets +from utils.text.symbols import symbols +from utils.paths import Paths +from models.tacotron import Tacotron +import argparse +from utils import data_parallel_workaround +import os +from pathlib import Path +import time +import numpy as np +import sys +from utils.checkpoints import save_checkpoint, restore_checkpoint + + +def np_now(x: torch.Tensor): return x.detach().cpu().numpy() + + +def main(): + # Parse Arguments + parser = argparse.ArgumentParser(description='Train Tacotron TTS') + parser.add_argument('--force_train', '-f', action='store_true', help='Forces the model to train past total steps') + parser.add_argument('--force_gta', '-g', action='store_true', help='Force the model to create GTA features') + parser.add_argument('--force_cpu', '-c', action='store_true', help='Forces CPU-only training, even when in CUDA capable environment') + parser.add_argument('--hp_file', metavar='FILE', default='hparams.py', help='The file to use for the hyperparameters') + args = parser.parse_args() + + hp.configure(args.hp_file) # Load hparams from file + paths = Paths(hp.data_path, hp.voc_model_id, hp.tts_model_id) + + force_train = args.force_train + force_gta = args.force_gta + + if not args.force_cpu and torch.cuda.is_available(): + device = torch.device('cuda') + for session in hp.tts_schedule: + _, _, _, batch_size = session + if batch_size % torch.cuda.device_count() != 0: + raise ValueError('`batch_size` must be evenly divisible by n_gpus!') + else: + device = torch.device('cpu') + print('Using device:', device) + + # Instantiate Tacotron Model + print('\nInitialising Tacotron Model...\n') + model = Tacotron(embed_dims=hp.tts_embed_dims, + num_chars=len(symbols), + encoder_dims=hp.tts_encoder_dims, + decoder_dims=hp.tts_decoder_dims, + n_mels=hp.num_mels, + fft_bins=hp.num_mels, + postnet_dims=hp.tts_postnet_dims, + encoder_K=hp.tts_encoder_K, + lstm_dims=hp.tts_lstm_dims, + postnet_K=hp.tts_postnet_K, + num_highways=hp.tts_num_highways, + dropout=hp.tts_dropout, + stop_threshold=hp.tts_stop_threshold).to(device) + + optimizer = optim.Adam(model.parameters()) + restore_checkpoint('tts', paths, model, optimizer, create_if_missing=True) + + if not force_gta: + for i, session in enumerate(hp.tts_schedule): + current_step = model.get_step() + + r, lr, max_step, batch_size = session + + training_steps = max_step - current_step + + # Do we need to change to the next session? + if current_step >= max_step: + # Are there no further sessions than the current one? + if i == len(hp.tts_schedule)-1: + # There are no more sessions. Check if we force training. + if force_train: + # Don't finish the loop - train forever + training_steps = 999_999_999 + else: + # We have completed training. Breaking is same as continue + break + else: + # There is a following session, go to it + continue + + model.r = r + + simple_table([(f'Steps with r={r}', str(training_steps//1000) + 'k Steps'), + ('Batch Size', batch_size), + ('Learning Rate', lr), + ('Outputs/Step (r)', model.r)]) + + train_set, attn_example = get_tts_datasets(paths.data, batch_size, r) + tts_train_loop(paths, model, optimizer, train_set, lr, training_steps, attn_example) + + print('Training Complete.') + print('To continue training increase tts_total_steps in hparams.py or use --force_train\n') + + + print('Creating Ground Truth Aligned Dataset...\n') + + train_set, attn_example = get_tts_datasets(paths.data, 8, model.r) + create_gta_features(model, train_set, paths.gta) + + print('\n\nYou can now train WaveRNN on GTA features - use python train_wavernn.py --gta\n') + + +def tts_train_loop(paths: Paths, model: Tacotron, optimizer, train_set, lr, train_steps, attn_example): + device = next(model.parameters()).device # use same device as model parameters + + for g in optimizer.param_groups: g['lr'] = lr + + total_iters = len(train_set) + #print("train set",total_iters) + epochs = train_steps // total_iters + 1 + + for e in range(1, epochs+1): + + start = time.time() + running_loss = 0 + + # Perform 1 epoch + for i, (x, m, ids, _) in enumerate(train_set, 1): + + x, m = x.to(device), m.to(device) + #print("test33333333") + # Parallelize model onto GPUS using workaround due to python bug + if device.type == 'cuda' and torch.cuda.device_count() > 1: + m1_hat, m2_hat, attention = data_parallel_workaround(model, x, m) + else: + m1_hat, m2_hat, attention = model(x, m) + + m1_loss = F.l1_loss(m1_hat, m) + m2_loss = F.l1_loss(m2_hat, m) + + loss = m1_loss + m2_loss + + optimizer.zero_grad() + loss.backward() + if hp.tts_clip_grad_norm is not None: + grad_norm = torch.nn.utils.clip_grad_norm_(model.parameters(), hp.tts_clip_grad_norm) + if torch.isnan(grad_norm): + print('grad_norm was NaN!') + + optimizer.step() + #print("test4444444") + running_loss += loss.item() + avg_loss = running_loss / i + + speed = i / (time.time() - start) + + step = model.get_step() + k = step // 1000 + + if step % hp.tts_checkpoint_every == 0: + ckpt_name = f'taco_step{k}K' + save_checkpoint('tts', paths, model, optimizer, + name=ckpt_name, is_silent=True) + + if attn_example in ids: + idx = ids.index(attn_example) + save_attention(np_now(attention[idx][:, :160]), paths.tts_attention/f'{step}') + save_spectrogram(np_now(m2_hat[idx]), paths.tts_mel_plot/f'{step}', 600) + + msg = f'| Epoch: {e}/{epochs} ({i}/{total_iters}) | Loss: {avg_loss:#.4} | {speed:#.2} steps/s | Step: {k}k | ' + stream(msg) + + # Must save latest optimizer state to ensure that resuming training + # doesn't produce artifacts + save_checkpoint('tts', paths, model, optimizer, is_silent=True) + model.log(paths.tts_log, msg) + print(' ') + + +def create_gta_features(model: Tacotron, train_set, save_path: Path): + device = next(model.parameters()).device # use same device as model parameters + + iters = len(train_set) + + for i, (x, mels, ids, mel_lens) in enumerate(train_set, 1): + + x, mels = x.to(device), mels.to(device) + + with torch.no_grad(): _, gta, _ = model(x, mels) + + gta = gta.cpu().numpy() + + for j, item_id in enumerate(ids): + mel = gta[j][:, :mel_lens[j]] + mel = (mel + 4) / 8 + np.save(save_path/f'{item_id}.npy', mel, allow_pickle=False) + + bar = progbar(i, iters) + msg = f'{bar} {i}/{iters} Batches ' + stream(msg) + + +if __name__ == "__main__": + main() diff --git a/models/WaveRNNModel/train_wavernn.py b/models/WaveRNNModel/train_wavernn.py new file mode 100644 index 0000000000000000000000000000000000000000..efbd333472a25576aa5591303cd07471a9377a6e --- /dev/null +++ b/models/WaveRNNModel/train_wavernn.py @@ -0,0 +1,164 @@ +import time +import numpy as np +import torch +from torch import optim +import torch.nn.functional as F +from utils.display import stream, simple_table +from utils.dataset import get_vocoder_datasets +from utils.distribution import discretized_mix_logistic_loss +from utils import hparams as hp +from models.fatchord_version import WaveRNN +from gen_wavernn import gen_testset +from utils.paths import Paths +import argparse +from utils import data_parallel_workaround +from utils.checkpoints import save_checkpoint, restore_checkpoint + + +def main(): + + # Parse Arguments + parser = argparse.ArgumentParser(description='Train WaveRNN Vocoder') + parser.add_argument('--lr', '-l', type=float, help='[float] override hparams.py learning rate') + parser.add_argument('--batch_size', '-b', type=int, help='[int] override hparams.py batch size') + parser.add_argument('--force_train', '-f', action='store_true', help='Forces the model to train past total steps') + parser.add_argument('--gta', '-g', action='store_true', help='train wavernn on GTA features') + parser.add_argument('--force_cpu', '-c', action='store_true', help='Forces CPU-only training, even when in CUDA capable environment') + parser.add_argument('--hp_file', metavar='FILE', default='hparams.py', help='The file to use for the hyperparameters') + args = parser.parse_args() + + hp.configure(args.hp_file) # load hparams from file + if args.lr is None: + args.lr = hp.voc_lr + if args.batch_size is None: + args.batch_size = hp.voc_batch_size + + paths = Paths(hp.data_path, hp.voc_model_id, hp.tts_model_id) + + batch_size = args.batch_size + force_train = args.force_train + train_gta = args.gta + lr = args.lr + + if not args.force_cpu and torch.cuda.is_available(): + device = torch.device('cuda') + if batch_size % torch.cuda.device_count() != 0: + raise ValueError('`batch_size` must be evenly divisible by n_gpus!') + else: + device = torch.device('cpu') + print('Using device:', device) + + print('\nInitialising Model...\n') + + # Instantiate WaveRNN Model + voc_model = WaveRNN(rnn_dims=hp.voc_rnn_dims, + fc_dims=hp.voc_fc_dims, + bits=hp.bits, + pad=hp.voc_pad, + upsample_factors=hp.voc_upsample_factors, + feat_dims=hp.num_mels, + compute_dims=hp.voc_compute_dims, + res_out_dims=hp.voc_res_out_dims, + res_blocks=hp.voc_res_blocks, + hop_length=hp.hop_length, + sample_rate=hp.sample_rate, + mode=hp.voc_mode).to(device) + + # Check to make sure the hop length is correctly factorised + assert np.cumprod(hp.voc_upsample_factors)[-1] == hp.hop_length + + optimizer = optim.Adam(voc_model.parameters()) + restore_checkpoint('voc', paths, voc_model, optimizer, create_if_missing=True) + + train_set, test_set = get_vocoder_datasets(paths.data, batch_size, train_gta) + + total_steps = 10_000_000 if force_train else hp.voc_total_steps + + simple_table([('Remaining', str((total_steps - voc_model.get_step())//1000) + 'k Steps'), + ('Batch Size', batch_size), + ('LR', lr), + ('Sequence Len', hp.voc_seq_len), + ('GTA Train', train_gta)]) + + loss_func = F.cross_entropy if voc_model.mode == 'RAW' else discretized_mix_logistic_loss + #print("test5555555555") + voc_train_loop(paths, voc_model, loss_func, optimizer, train_set, test_set, lr, total_steps) + + print('Training Complete.') + print('To continue training increase voc_total_steps in hparams.py or use --force_train') + + +def voc_train_loop(paths: Paths, model: WaveRNN, loss_func, optimizer, train_set, test_set, lr, total_steps): + # Use same device as model parameters + device = next(model.parameters()).device + + for g in optimizer.param_groups: g['lr'] = lr + + total_iters = len(train_set) + print("total iters test:",len(train_set)) + epochs = (total_steps - model.get_step()) // total_iters + 1 + + for e in range(1, epochs + 1): + + start = time.time() + running_loss = 0. + #print("test666666666") + for i, (x, y, m) in enumerate(train_set, 1): + #print("test44444444444") + x, m, y = x.to(device), m.to(device), y.to(device) + + # Parallelize model onto GPUS using workaround due to python bug + if device.type == 'cuda' and torch.cuda.device_count() > 1: + y_hat = data_parallel_workaround(model, x, m) + else: + y_hat = model(x, m) + + if model.mode == 'RAW': + y_hat = y_hat.transpose(1, 2).unsqueeze(-1) + + elif model.mode == 'MOL': + y = y.float() + + y = y.unsqueeze(-1) + + + loss = loss_func(y_hat, y) + + optimizer.zero_grad() + loss.backward() + #print("test111111111111111111") + if hp.voc_clip_grad_norm is not None: + #print("test333333333333") + grad_norm = torch.nn.utils.clip_grad_norm_(model.parameters(), hp.voc_clip_grad_norm) + if torch.isnan(grad_norm): + print('grad_norm was NaN!') + optimizer.step() + + running_loss += loss.item() + avg_loss = running_loss / i + + speed = i / (time.time() - start) + + step = model.get_step() + k = step // 1000 + + if step % hp.voc_checkpoint_every == 0: + #print("test22222222222222222") + gen_testset(model, test_set, hp.voc_gen_at_checkpoint, hp.voc_gen_batched, + hp.voc_target, hp.voc_overlap, paths.voc_output) + ckpt_name = f'wave_step{k}K' + save_checkpoint('voc', paths, model, optimizer, + name=ckpt_name, is_silent=True) + + msg = f'| Epoch: {e}/{epochs} ({i}/{total_iters}) | Loss: {avg_loss:.4f} | {speed:.1f} steps/s | Step: {k}k | ' + stream(msg) + + # Must save latest optimizer state to ensure that resuming training + # doesn't produce artifacts + save_checkpoint('voc', paths, model, optimizer, is_silent=True) + model.log(paths.voc_log, msg) + print(' ') + + +if __name__ == "__main__": + main() diff --git a/models/WaveRNNModel/utils/__init__.py b/models/WaveRNNModel/utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2f9beb227a0c9655b1aa6db7f26b85316b7319a0 --- /dev/null +++ b/models/WaveRNNModel/utils/__init__.py @@ -0,0 +1,106 @@ +# Make it explicit that we do it the Python 3 way +from __future__ import absolute_import, division, print_function, unicode_literals +from builtins import * +import sys +import torch +import re + +from importlib.util import spec_from_file_location, module_from_spec +from pathlib import Path +from typing import Union + +# Credit: Ryuichi Yamamoto (https://github.com/r9y9/wavenet_vocoder/blob/1717f145c8f8c0f3f85ccdf346b5209fa2e1c920/train.py#L599) +# Modified by: Ryan Butler (https://github.com/TheButlah) +# workaround for https://github.com/pytorch/pytorch/issues/15716 +# the idea is to return outputs and replicas explicitly, so that making pytorch +# not to release the nodes (this is a pytorch bug though) + +_output_ref = None +_replicas_ref = None + +def data_parallel_workaround(model, *input): + global _output_ref + global _replicas_ref + device_ids = list(range(torch.cuda.device_count())) + output_device = device_ids[0] + replicas = torch.nn.parallel.replicate(model, device_ids) + # input.shape = (num_args, batch, ...) + inputs = torch.nn.parallel.scatter(input, device_ids) + # inputs.shape = (num_gpus, num_args, batch/num_gpus, ...) + replicas = replicas[:len(inputs)] + outputs = torch.nn.parallel.parallel_apply(replicas, inputs) + y_hat = torch.nn.parallel.gather(outputs, output_device) + _output_ref = outputs + _replicas_ref = replicas + return y_hat + + +###### Deal with hparams import that has to be configured at runtime ###### +class __HParams: + """Manages the hyperparams pseudo-module""" + def __init__(self, path: Union[str, Path]=None): + """Constructs the hyperparameters from a path to a python module. If + `path` is None, will raise an AttributeError whenever its attributes + are accessed. Otherwise, configures self based on `path`.""" + if path is None: + print("path is none") + self._configured = False + else: + self.configure(path) + + def __getattr__(self, item): + print("self config2222:",self.is_configured()) + if not self.is_configured(): + raise AttributeError("HParams not configured yet. Call self.configure()") + else: + return super().__getattr__(item) + + def configure(self, path: Union[str, Path]): + """Configures hparams by copying over atrributes from a module with the + given path. Raises an exception if already configured.""" + if self.is_configured(): + raise RuntimeError("Cannot reconfigure hparams!") + print("path=",path) + ###### Check for proper path ###### + if not isinstance(path, Path): + path = Path(path).expanduser() + if not path.exists(): + raise FileNotFoundError(f"Could not find hparams file {path}") + elif path.suffix != ".py": + raise ValueError("`path` must be a python file") + + ###### Load in attributes from module ###### + m = _import_from_file("hparams", path) + + reg = re.compile(r"^__.+__$") # Matches magic methods + for name, value in m.__dict__.items(): + if reg.match(name): + # Skip builtins + continue + if name in self.__dict__: + # Cannot overwrite already existing attributes + raise AttributeError( + f"module at `path` cannot contain attribute {name} as it " + "overwrites an attribute of the same name in utils.hparams") + # Fair game to copy over the attribute + self.__setattr__(name, value) + + self._configured = True + print("self config1111:",self._configured) + + def is_configured(self): + return self._configured + +hparams = __HParams() + + +def _import_from_file(name, path: Path): + """Programmatically returns a module object from a filepath""" + if not Path(path).exists(): + raise FileNotFoundError('"%s" doesn\'t exist!' % path) + spec = spec_from_file_location(name, path) + if spec is None: + raise ValueError('could not load module from "%s"' % path) + m = module_from_spec(spec) + spec.loader.exec_module(m) + return m \ No newline at end of file diff --git a/models/WaveRNNModel/utils/checkpoints.py b/models/WaveRNNModel/utils/checkpoints.py new file mode 100644 index 0000000000000000000000000000000000000000..f0ad5e3d0663a31ca4c0bb0d9f28b481ce6f25b0 --- /dev/null +++ b/models/WaveRNNModel/utils/checkpoints.py @@ -0,0 +1,128 @@ +import torch +from utils.paths import Paths +from models.tacotron import Tacotron + + +def get_checkpoint_paths(checkpoint_type: str, paths: Paths): + """ + Returns the correct checkpointing paths + depending on whether model is Vocoder or TTS + + Args: + checkpoint_type: Either 'voc' or 'tts' + paths: Paths object + """ + if checkpoint_type is 'tts': + weights_path = paths.tts_latest_weights + optim_path = paths.tts_latest_optim + checkpoint_path = paths.tts_checkpoints + elif checkpoint_type is 'voc': + weights_path = paths.voc_latest_weights + optim_path = paths.voc_latest_optim + checkpoint_path = paths.voc_checkpoints + else: + raise NotImplementedError + + return weights_path, optim_path, checkpoint_path + + +def save_checkpoint(checkpoint_type: str, paths: Paths, model, optimizer, *, + name=None, is_silent=False): + """Saves the training session to disk. + + Args: + paths: Provides information about the different paths to use. + model: A `Tacotron` or `WaveRNN` model to save the parameters and buffers from. + optimizer: An optmizer to save the state of (momentum, etc). + name: If provided, will name to a checkpoint with the given name. Note + that regardless of whether this is provided or not, this function + will always update the files specified in `paths` that give the + location of the latest weights and optimizer state. Saving + a named checkpoint happens in addition to this update. + """ + def helper(path_dict, is_named): + s = 'named' if is_named else 'latest' + num_exist = sum(p.exists() for p in path_dict.values()) + + if num_exist not in (0,2): + # Checkpoint broken + raise FileNotFoundError( + f'We expected either both or no files in the {s} checkpoint to ' + 'exist, but instead we got exactly one!') + + if num_exist == 0: + if not is_silent: print(f'Creating {s} checkpoint...') + for p in path_dict.values(): + p.parent.mkdir(parents=True, exist_ok=True) + else: + if not is_silent: print(f'Saving to existing {s} checkpoint...') + + if not is_silent: print(f'Saving {s} weights: {path_dict["w"]}') + model.save(path_dict['w']) + if not is_silent: print(f'Saving {s} optimizer state: {path_dict["o"]}') + torch.save(optimizer.state_dict(), path_dict['o']) + + weights_path, optim_path, checkpoint_path = \ + get_checkpoint_paths(checkpoint_type, paths) + + latest_paths = {'w': weights_path, 'o': optim_path} + helper(latest_paths, False) + + if name: + named_paths = { + 'w': checkpoint_path/f'{name}_weights.pyt', + 'o': checkpoint_path/f'{name}_optim.pyt', + } + helper(named_paths, True) + + +def restore_checkpoint(checkpoint_type: str, paths: Paths, model, optimizer, *, + name=None, create_if_missing=False): + """Restores from a training session saved to disk. + + NOTE: The optimizer's state is placed on the same device as it's model + parameters. Therefore, be sure you have done `model.to(device)` before + calling this method. + + Args: + paths: Provides information about the different paths to use. + model: A `Tacotron` or `WaveRNN` model to save the parameters and buffers from. + optimizer: An optmizer to save the state of (momentum, etc). + name: If provided, will restore from a checkpoint with the given name. + Otherwise, will restore from the latest weights and optimizer state + as specified in `paths`. + create_if_missing: If `True`, will create the checkpoint if it doesn't + yet exist, as well as update the files specified in `paths` that + give the location of the current latest weights and optimizer state. + If `False` and the checkpoint doesn't exist, will raise a + `FileNotFoundError`. + """ + + weights_path, optim_path, checkpoint_path = \ + get_checkpoint_paths(checkpoint_type, paths) + + if name: + path_dict = { + 'w': checkpoint_path/f'{name}_weights.pyt', + 'o': checkpoint_path/f'{name}_optim.pyt', + } + s = 'named' + else: + path_dict = { + 'w': weights_path, + 'o': optim_path + } + s = 'latest' + + num_exist = sum(p.exists() for p in path_dict.values()) + if num_exist == 2: + # Checkpoint exists + print(f'Restoring from {s} checkpoint...') + print(f'Loading {s} weights: {path_dict["w"]}') + model.load(path_dict['w']) + print(f'Loading {s} optimizer state: {path_dict["o"]}') + optimizer.load_state_dict(torch.load(path_dict['o'])) + elif create_if_missing: + save_checkpoint(checkpoint_type, paths, model, optimizer, name=name, is_silent=False) + else: + raise FileNotFoundError(f'The {s} checkpoint could not be found!') \ No newline at end of file diff --git a/models/WaveRNNModel/utils/dataset.py b/models/WaveRNNModel/utils/dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..8f47bfc50c0100a4a15c68f66c9884d919b61917 --- /dev/null +++ b/models/WaveRNNModel/utils/dataset.py @@ -0,0 +1,232 @@ +import pickle +import random +import torch +from torch.utils.data import Dataset, DataLoader +from torch.utils.data.sampler import Sampler +from utils.dsp import * +from utils import hparams as hp +from utils.text import text_to_sequence +from utils.paths import Paths +from pathlib import Path + +from functools import partial + +################################################################################### +# WaveRNN/Vocoder Dataset ######################################################### +################################################################################### + + +class VocoderDataset(Dataset): + def __init__(self, path: Path, dataset_ids, train_gta=False): + self.metadata = dataset_ids + self.mel_path = path/'gta' if train_gta else path/'mel' + self.quant_path = path/'quant' + + + def __getitem__(self, index): + item_id = self.metadata[index] + m = np.load(self.mel_path/f'{item_id}.npy') + x = np.load(self.quant_path/f'{item_id}.npy') + return m, x + + def __len__(self): + return len(self.metadata) + + +def get_vocoder_datasets(path: Path, batch_size, train_gta): + + with open(path/'dataset.pkl', 'rb') as f: + dataset = pickle.load(f) + + dataset_ids = [x[0] for x in dataset] + + random.seed(1234) + random.shuffle(dataset_ids) + + test_ids = dataset_ids[-hp.voc_test_samples:] + train_ids = dataset_ids[:-hp.voc_test_samples] + + train_dataset = VocoderDataset(path, train_ids, train_gta) + test_dataset = VocoderDataset(path, test_ids, train_gta) + + train_set = DataLoader(train_dataset, + collate_fn=collate_vocoder, + batch_size=batch_size, + num_workers=2, + shuffle=True, + pin_memory=True) + + test_set = DataLoader(test_dataset, + batch_size=1, + num_workers=1, + shuffle=False, + pin_memory=True) + + return train_set, test_set + + +def collate_vocoder(batch): + if not hp.is_configured(): + print("未配置参数") + hp.configure("E:\\智能语音处理系统\\Noise-suppression-and-speech-recognition-systems-master\\WaveRNNModel\\hparams.py") + mel_win = hp.voc_seq_len // hp.hop_length + 2 * hp.voc_pad + max_offsets = [x[0].shape[-1] -2 - (mel_win + 2 * hp.voc_pad) for x in batch] + mel_offsets = [np.random.randint(0, offset) for offset in max_offsets] + sig_offsets = [(offset + hp.voc_pad) * hp.hop_length for offset in mel_offsets] + + mels = [x[0][:, mel_offsets[i]:mel_offsets[i] + mel_win] for i, x in enumerate(batch)] + + labels = [x[1][sig_offsets[i]:sig_offsets[i] + hp.voc_seq_len + 1] for i, x in enumerate(batch)] + + mels = np.stack(mels).astype(np.float32) + labels = np.stack(labels).astype(np.int64) + + mels = torch.tensor(mels) + labels = torch.tensor(labels).long() + + x = labels[:, :hp.voc_seq_len] + y = labels[:, 1:] + + bits = 16 if hp.voc_mode == 'MOL' else hp.bits + + x = label_2_float(x.float(), bits) + + if hp.voc_mode == 'MOL': + y = label_2_float(y.float(), bits) + + return x, y, mels + + +################################################################################### +# Tacotron/TTS Dataset ############################################################ +################################################################################### + + +def get_tts_datasets(path: Path, batch_size, r): + print("path",path) + with open(path/'dataset.pkl', 'rb') as f: + dataset = pickle.load(f) + + dataset_ids = [] + mel_lengths = [] + print("hp.tts_max_mel_len",hp.tts_max_mel_len) + for (item_id, len) in dataset: + if len <= hp.tts_max_mel_len: + dataset_ids += [item_id] + mel_lengths += [len] + + with open(path/'text_dict.pkl', 'rb') as f: + text_dict = pickle.load(f) + + + train_dataset = TTSDataset(path, dataset_ids, text_dict) + + sampler = None + + if hp.tts_bin_lengths: + sampler = BinnedLengthSampler(mel_lengths, batch_size, batch_size * 3) + + train_set = DataLoader(train_dataset, + collate_fn=partial(collate_tts, r=r), + batch_size=batch_size, + sampler=sampler, + num_workers=1, + pin_memory=True) + + longest = mel_lengths.index(max(mel_lengths)) + + # Used to evaluate attention during training process + attn_example = dataset_ids[longest] + + # print(attn_example) + + return train_set, attn_example + + +class TTSDataset(Dataset): + def __init__(self, path: Path, dataset_ids, text_dict): + self.path = path + self.metadata = dataset_ids + self.text_dict = text_dict + + def __getitem__(self, index): + item_id = self.metadata[index] + #print("path555555",self.path) + if not hp.is_configured(): + print("未配置参数") + hp.configure("E:\\智能语音处理系统\\Noise-suppression-and-speech-recognition-systems-master\\WaveRNNModel\\hparams.py") + #print("test666666",hp.tts_cleaner_names) + x = text_to_sequence(self.text_dict[item_id], hp.tts_cleaner_names) + mel = np.load(self.path/'mel'/f'{item_id}.npy') + mel_len = mel.shape[-1] + return x, mel, item_id, mel_len + + def __len__(self): + return len(self.metadata) + + +def pad1d(x, max_len): + return np.pad(x, (0, max_len - len(x)), mode='constant') + + +def pad2d(x, max_len): + return np.pad(x, ((0, 0), (0, max_len - x.shape[-1])), mode='constant') + + +def collate_tts(batch, r): + + x_lens = [len(x[0]) for x in batch] + max_x_len = max(x_lens) + + chars = [pad1d(x[0], max_x_len) for x in batch] + chars = np.stack(chars) + + spec_lens = [x[1].shape[-1] for x in batch] + max_spec_len = max(spec_lens) + 1 + if max_spec_len % r != 0: + max_spec_len += r - max_spec_len % r + + mel = [pad2d(x[1], max_spec_len) for x in batch] + mel = np.stack(mel) + + ids = [x[2] for x in batch] + mel_lens = [x[3] for x in batch] + + chars = torch.tensor(chars).long() + mel = torch.tensor(mel) + + # scale spectrograms to -4 <--> 4 + mel = (mel * 8.) - 4. + return chars, mel, ids, mel_lens + + +class BinnedLengthSampler(Sampler): + def __init__(self, lengths, batch_size, bin_size): + _, self.idx = torch.sort(torch.tensor(lengths).long()) + self.batch_size = batch_size + self.bin_size = bin_size + assert self.bin_size % self.batch_size == 0 + + def __iter__(self): + # Need to change to numpy since there's a bug in random.shuffle(tensor) + # TODO: Post an issue on pytorch repo + idx = self.idx.numpy() + bins = [] + + for i in range(len(idx) // self.bin_size): + this_bin = idx[i * self.bin_size:(i + 1) * self.bin_size] + random.shuffle(this_bin) + bins += [this_bin] + + random.shuffle(bins) + binned_idx = np.stack(bins).reshape(-1) + + if len(binned_idx) < len(idx): + last_bin = idx[len(binned_idx):] + random.shuffle(last_bin) + binned_idx = np.concatenate([binned_idx, last_bin]) + + return iter(torch.tensor(binned_idx).long()) + + def __len__(self): + return len(self.idx) diff --git a/models/WaveRNNModel/utils/display.py b/models/WaveRNNModel/utils/display.py new file mode 100644 index 0000000000000000000000000000000000000000..5fbe4e3c7b4fa389436af5dc447387e2bd953ebe --- /dev/null +++ b/models/WaveRNNModel/utils/display.py @@ -0,0 +1,121 @@ +import matplotlib as mpl +mpl.use('agg') # Use non-interactive backend by default +import matplotlib.pyplot as plt +import time +import numpy as np +import sys + + +def progbar(i, n, size=16): + done = (i * size) // n + bar = '' + for i in range(size): + bar += '█' if i <= done else '░' + return bar + + +def stream(message): + sys.stdout.write(f"\r{message}") + + +def simple_table(item_tuples): + + border_pattern = '+---------------------------------------' + whitespace = ' ' + + headings, cells, = [], [] + + for item in item_tuples: + + heading, cell = str(item[0]), str(item[1]) + + pad_head = True if len(heading) < len(cell) else False + + pad = abs(len(heading) - len(cell)) + pad = whitespace[:pad] + + pad_left = pad[:len(pad)//2] + pad_right = pad[len(pad)//2:] + + if pad_head: + heading = pad_left + heading + pad_right + else: + cell = pad_left + cell + pad_right + + headings += [heading] + cells += [cell] + + border, head, body = '', '', '' + + for i in range(len(item_tuples)): + + temp_head = f'| {headings[i]} ' + temp_body = f'| {cells[i]} ' + + border += border_pattern[:len(temp_head)] + head += temp_head + body += temp_body + + if i == len(item_tuples) - 1: + head += '|' + body += '|' + border += '+' + + print(border) + print(head) + print(border) + print(body) + print(border) + print(' ') + + +def time_since(started): + elapsed = time.time() - started + m = int(elapsed // 60) + s = int(elapsed % 60) + if m >= 60: + h = int(m // 60) + m = m % 60 + return f'{h}h {m}m {s}s' + else: + return f'{m}m {s}s' + + +def save_attention(attn, path): + fig = plt.figure(figsize=(12, 6)) + plt.imshow(attn.T, interpolation='nearest', aspect='auto') + fig.savefig(path.parent/f'{path.stem}.png', bbox_inches='tight') + plt.close(fig) + + +def save_spectrogram(M, path, length=None): + M = np.flip(M, axis=0) + if length: M = M[:, :length] + fig = plt.figure(figsize=(12, 6)) + plt.imshow(M, interpolation='nearest', aspect='auto') + fig.savefig(f'{path}.png', bbox_inches='tight') + plt.close(fig) + + +def plot(array): + mpl.interactive(True) + fig = plt.figure(figsize=(30, 5)) + ax = fig.add_subplot(111) + ax.xaxis.label.set_color('grey') + ax.yaxis.label.set_color('grey') + ax.xaxis.label.set_fontsize(23) + ax.yaxis.label.set_fontsize(23) + ax.tick_params(axis='x', colors='grey', labelsize=23) + ax.tick_params(axis='y', colors='grey', labelsize=23) + plt.plot(array) + mpl.interactive(False) + + +def plot_spec(M): + mpl.interactive(True) + M = np.flip(M, axis=0) + plt.figure(figsize=(18,4)) + plt.imshow(M, interpolation='nearest', aspect='auto') + plt.show() + mpl.interactive(False) + diff --git a/models/WaveRNNModel/utils/distribution.py b/models/WaveRNNModel/utils/distribution.py new file mode 100644 index 0000000000000000000000000000000000000000..504a3cedd4297b2e6b9461a828b47338a5470568 --- /dev/null +++ b/models/WaveRNNModel/utils/distribution.py @@ -0,0 +1,132 @@ +import numpy as np +import torch +import torch.nn.functional as F + + +def log_sum_exp(x): + """ numerically stable log_sum_exp implementation that prevents overflow """ + # TF ordering + axis = len(x.size()) - 1 + m, _ = torch.max(x, dim=axis) + m2, _ = torch.max(x, dim=axis, keepdim=True) + return m + torch.log(torch.sum(torch.exp(x - m2), dim=axis)) + + +# It is adapted from https://github.com/r9y9/wavenet_vocoder/blob/master/wavenet_vocoder/mixture.py +def discretized_mix_logistic_loss(y_hat, y, num_classes=65536, + log_scale_min=None, reduce=True): + if log_scale_min is None: + log_scale_min = float(np.log(1e-14)) + y_hat = y_hat.permute(0,2,1) + assert y_hat.dim() == 3 + assert y_hat.size(1) % 3 == 0 + nr_mix = y_hat.size(1) // 3 + + # (B x T x C) + y_hat = y_hat.transpose(1, 2) + + # unpack parameters. (B, T, num_mixtures) x 3 + logit_probs = y_hat[:, :, :nr_mix] + means = y_hat[:, :, nr_mix:2 * nr_mix] + log_scales = torch.clamp(y_hat[:, :, 2 * nr_mix:3 * nr_mix], min=log_scale_min) + + # B x T x 1 -> B x T x num_mixtures + y = y.expand_as(means) + + centered_y = y - means + inv_stdv = torch.exp(-log_scales) + plus_in = inv_stdv * (centered_y + 1. / (num_classes - 1)) + cdf_plus = torch.sigmoid(plus_in) + min_in = inv_stdv * (centered_y - 1. / (num_classes - 1)) + cdf_min = torch.sigmoid(min_in) + + # log probability for edge case of 0 (before scaling) + # equivalent: torch.log(F.sigmoid(plus_in)) + log_cdf_plus = plus_in - F.softplus(plus_in) + + # log probability for edge case of 255 (before scaling) + # equivalent: (1 - F.sigmoid(min_in)).log() + log_one_minus_cdf_min = -F.softplus(min_in) + + # probability for all other cases + cdf_delta = cdf_plus - cdf_min + + mid_in = inv_stdv * centered_y + # log probability in the center of the bin, to be used in extreme cases + # (not actually used in our code) + log_pdf_mid = mid_in - log_scales - 2. * F.softplus(mid_in) + + # tf equivalent + """ + log_probs = tf.where(x < -0.999, log_cdf_plus, + tf.where(x > 0.999, log_one_minus_cdf_min, + tf.where(cdf_delta > 1e-5, + tf.log(tf.maximum(cdf_delta, 1e-12)), + log_pdf_mid - np.log(127.5)))) + """ + # TODO: cdf_delta <= 1e-5 actually can happen. How can we choose the value + # for num_classes=65536 case? 1e-7? not sure.. + inner_inner_cond = (cdf_delta > 1e-5).float() + + inner_inner_out = inner_inner_cond * \ + torch.log(torch.clamp(cdf_delta, min=1e-12)) + \ + (1. - inner_inner_cond) * (log_pdf_mid - np.log((num_classes - 1) / 2)) + inner_cond = (y > 0.999).float() + inner_out = inner_cond * log_one_minus_cdf_min + (1. - inner_cond) * inner_inner_out + cond = (y < -0.999).float() + log_probs = cond * log_cdf_plus + (1. - cond) * inner_out + + log_probs = log_probs + F.log_softmax(logit_probs, -1) + + if reduce: + return -torch.mean(log_sum_exp(log_probs)) + else: + return -log_sum_exp(log_probs).unsqueeze(-1) + + +def sample_from_discretized_mix_logistic(y, log_scale_min=None): + """ + Sample from discretized mixture of logistic distributions + Args: + y (Tensor): B x C x T + log_scale_min (float): Log scale minimum value + Returns: + Tensor: sample in range of [-1, 1]. + """ + if log_scale_min is None: + log_scale_min = float(np.log(1e-14)) + assert y.size(1) % 3 == 0 + nr_mix = y.size(1) // 3 + + # B x T x C + y = y.transpose(1, 2) + logit_probs = y[:, :, :nr_mix] + + # sample mixture indicator from softmax + temp = logit_probs.data.new(logit_probs.size()).uniform_(1e-5, 1.0 - 1e-5) + temp = logit_probs.data - torch.log(- torch.log(temp)) + _, argmax = temp.max(dim=-1) + + # (B, T) -> (B, T, nr_mix) + one_hot = F.one_hot(argmax, nr_mix).float() + # select logistic parameters + means = torch.sum(y[:, :, nr_mix:2 * nr_mix] * one_hot, dim=-1) + log_scales = torch.clamp(torch.sum( + y[:, :, 2 * nr_mix:3 * nr_mix] * one_hot, dim=-1), min=log_scale_min) + # sample from logistic & clip to interval + # we don't actually round to the nearest 8bit value when sampling + u = means.data.new(means.size()).uniform_(1e-5, 1.0 - 1e-5) + x = means + torch.exp(log_scales) * (torch.log(u) - torch.log(1. - u)) + + x = torch.clamp(torch.clamp(x, min=-1.), max=1.) + + return x + +''' +def to_one_hot(tensor, n, fill_with=1.): + # we perform one hot encore with respect to the last axis + one_hot = torch.FloatTensor(tensor.size() + (n,)).zero_() + if tensor.is_cuda: + one_hot = one_hot.cuda() + one_hot.scatter_(len(tensor.size()), tensor.unsqueeze(-1), fill_with) + return one_hot''' diff --git a/models/WaveRNNModel/utils/dsp.py b/models/WaveRNNModel/utils/dsp.py new file mode 100644 index 0000000000000000000000000000000000000000..ce33f5c2a516039ca87499d43be6b3f94d9391c4 --- /dev/null +++ b/models/WaveRNNModel/utils/dsp.py @@ -0,0 +1,118 @@ +import math +import numpy as np +import librosa +from utils import hparams as hp +from scipy.signal import lfilter + + +def label_2_float(x, bits): + return 2 * x / (2**bits - 1.) - 1. + + +def float_2_label(x, bits): + assert abs(x).max() <= 1.0 + x = (x + 1.) * (2**bits - 1) / 2 + return x.clip(0, 2**bits - 1) + + +def load_wav(path): + return librosa.load(path, sr=hp.sample_rate)[0] + + +def save_wav(x, path): + #print("path=",path) + librosa.output.write_wav(path, x.astype(np.float32), sr=hp.sample_rate) + + +def split_signal(x): + unsigned = x + 2**15 + coarse = unsigned // 256 + fine = unsigned % 256 + return coarse, fine + + +def combine_signal(coarse, fine): + return coarse * 256 + fine - 2**15 + + +def encode_16bits(x): + return np.clip(x * 2**15, -2**15, 2**15 - 1).astype(np.int16) + + +def linear_to_mel(spectrogram): + return librosa.feature.melspectrogram( + S=spectrogram, sr=hp.sample_rate, n_fft=hp.n_fft, n_mels=hp.num_mels, fmin=hp.fmin) + +''' +def build_mel_basis(): + return librosa.filters.mel(hp.sample_rate, hp.n_fft, n_mels=hp.num_mels, fmin=hp.fmin) +''' + +def normalize(S): + return np.clip((S - hp.min_level_db) / -hp.min_level_db, 0, 1) + + +def denormalize(S): + return (np.clip(S, 0, 1) * -hp.min_level_db) + hp.min_level_db + + +def amp_to_db(x): + return 20 * np.log10(np.maximum(1e-5, x)) + + +def db_to_amp(x): + return np.power(10.0, x * 0.05) + + +def spectrogram(y): + D = stft(y) + S = amp_to_db(np.abs(D)) - hp.ref_level_db + return normalize(S) + + +def melspectrogram(y): + D = stft(y) + S = amp_to_db(linear_to_mel(np.abs(D))) + return normalize(S) + + +def stft(y): + return librosa.stft( + y=y, + n_fft=hp.n_fft, hop_length=hp.hop_length, win_length=hp.win_length) + + +def pre_emphasis(x): + return lfilter([1, -hp.preemphasis], [1], x) + + +def de_emphasis(x): + return lfilter([1], [1, -hp.preemphasis], x) + + +def encode_mu_law(x, mu): + mu = mu - 1 + fx = np.sign(x) * np.log(1 + mu * np.abs(x)) / np.log(1 + mu) + return np.floor((fx + 1) / 2 * mu + 0.5) + + +def decode_mu_law(y, mu, from_labels=True): + # TODO: get rid of log2 - makes no sense + if from_labels: y = label_2_float(y, math.log2(mu)) + mu = mu - 1 + x = np.sign(y) / mu * ((1 + mu) ** np.abs(y) - 1) + return x + +def reconstruct_waveform(mel, n_iter=32): + """Uses Griffin-Lim phase reconstruction to convert from a normalized + mel spectrogram back into a waveform.""" + denormalized = denormalize(mel) + amp_mel = db_to_amp(denormalized) + S = librosa.feature.inverse.mel_to_stft( + amp_mel, power=1, sr=hp.sample_rate, + n_fft=hp.n_fft, fmin=hp.fmin) + wav = librosa.core.griffinlim( + S, n_iter=n_iter, + hop_length=hp.hop_length, win_length=hp.win_length) + return wav + diff --git a/models/WaveRNNModel/utils/files.py b/models/WaveRNNModel/utils/files.py new file mode 100644 index 0000000000000000000000000000000000000000..d302b8694001e117ee9baadbc4deee29b302bd28 --- /dev/null +++ b/models/WaveRNNModel/utils/files.py @@ -0,0 +1,6 @@ +from pathlib import Path +from typing import Union + +def get_files(path: Union[str, Path], extension='.wav'): + if isinstance(path, str): path = Path(path).expanduser().resolve() + return list(path.rglob(f'*{extension}')) diff --git a/models/WaveRNNModel/utils/paths.py b/models/WaveRNNModel/utils/paths.py new file mode 100644 index 0000000000000000000000000000000000000000..1a8a34eb8d00a39a9bedecaf75863a0514842c09 --- /dev/null +++ b/models/WaveRNNModel/utils/paths.py @@ -0,0 +1,64 @@ +import os +from pathlib import Path + + +class Paths: + """Manages and configures the paths used by WaveRNN, Tacotron, and the data.""" + def __init__(self, data_path, voc_id, tts_id): + self.base = Path(__file__).parent.parent.expanduser().resolve() + + # Data Paths + self.data = Path(data_path).expanduser().resolve() + self.quant = self.data/'quant' + self.mel = self.data/'mel' + self.gta = self.data/'gta' + + # WaveRNN/Vocoder Paths + self.voc_checkpoints = self.base/'checkpoints'/f'{voc_id}.wavernn' + self.voc_latest_weights = self.voc_checkpoints/'latest_weights.pyt' + self.voc_latest_optim = self.voc_checkpoints/'latest_optim.pyt' + self.voc_output = self.base/'model_outputs'/f'{voc_id}.wavernn' + self.voc_step = self.voc_checkpoints/'step.npy' + self.voc_log = self.voc_checkpoints/'log.txt' + + # Tactron/TTS Paths + self.tts_checkpoints = self.base/'checkpoints'/f'{tts_id}.tacotron' + self.tts_latest_weights = self.tts_checkpoints/'latest_weights.pyt' + self.tts_latest_optim = self.tts_checkpoints/'latest_optim.pyt' + self.tts_output = self.base/'model_outputs'/f'{tts_id}.tacotron' + self.tts_step = self.tts_checkpoints/'step.npy' + self.tts_log = self.tts_checkpoints/'log.txt' + self.tts_attention = self.tts_checkpoints/'attention' + self.tts_mel_plot = self.tts_checkpoints/'mel_plots' + + self.create_paths() + + def create_paths(self): + os.makedirs(self.data, exist_ok=True) + os.makedirs(self.quant, exist_ok=True) + os.makedirs(self.mel, exist_ok=True) + os.makedirs(self.gta, exist_ok=True) + os.makedirs(self.voc_checkpoints, exist_ok=True) + os.makedirs(self.voc_output, exist_ok=True) + os.makedirs(self.tts_checkpoints, exist_ok=True) + os.makedirs(self.tts_output, exist_ok=True) + os.makedirs(self.tts_attention, exist_ok=True) + os.makedirs(self.tts_mel_plot, exist_ok=True) + + def get_tts_named_weights(self, name): + """Gets the path for the weights in a named tts checkpoint.""" + return self.tts_checkpoints/f'{name}_weights.pyt' + + def get_tts_named_optim(self, name): + """Gets the path for the optimizer state in a named tts checkpoint.""" + return self.tts_checkpoints/f'{name}_optim.pyt' + + def get_voc_named_weights(self, name): + """Gets the path for the weights in a named voc checkpoint.""" + return self.voc_checkpoints/f'{name}_weights.pyt' + + def get_voc_named_optim(self, name): + """Gets the path for the optimizer state in a named voc checkpoint.""" + return self.voc_checkpoints/f'{name}_optim.pyt' + + diff --git a/models/WaveRNNModel/utils/text/LICENSE b/models/WaveRNNModel/utils/text/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..91483e2db24fbcf6e03a6d0d8ce3c5fdf2ba0301 --- /dev/null +++ b/models/WaveRNNModel/utils/text/LICENSE @@ -0,0 +1,19 @@ +Copyright (c) 2017 Keith Ito + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/models/WaveRNNModel/utils/text/__init__.py b/models/WaveRNNModel/utils/text/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..fffb0ebec24c269bca847f3a62d3d334942abc1f --- /dev/null +++ b/models/WaveRNNModel/utils/text/__init__.py @@ -0,0 +1,74 @@ +""" from https://github.com/keithito/tacotron """ +import re +from utils.text import cleaners +from utils.text.symbols import symbols + + +# Mappings from symbol to numeric ID and vice versa: +_symbol_to_id = {s: i for i, s in enumerate(symbols)} +_id_to_symbol = {i: s for i, s in enumerate(symbols)} + +# Regular expression matching text enclosed in curly braces: +_curly_re = re.compile(r'(.*?)\{(.+?)\}(.*)') + + +def text_to_sequence(text, cleaner_names): + '''Converts a string of text to a sequence of IDs corresponding to the symbols in the text. + + The text can optionally have ARPAbet sequences enclosed in curly braces embedded + in it. For example, "Turn left on {HH AW1 S S T AH0 N} Street." + + Args: + text: string to convert to a sequence + cleaner_names: names of the cleaner functions to run the text through + + Returns: + List of integers corresponding to the symbols in the text + ''' + sequence = [] + + # Check for curly braces and treat their contents as ARPAbet: + while len(text): + m = _curly_re.match(text) + if not m: + sequence += _symbols_to_sequence(_clean_text(text, cleaner_names)) + break + sequence += _symbols_to_sequence(_clean_text(m.group(1), cleaner_names)) + sequence += _arpabet_to_sequence(m.group(2)) + text = m.group(3) + + return sequence + + +def sequence_to_text(sequence): + '''Converts a sequence of IDs back to a string''' + result = '' + for symbol_id in sequence: + if symbol_id in _id_to_symbol: + s = _id_to_symbol[symbol_id] + # Enclose ARPAbet back in curly braces: + if len(s) > 1 and s[0] == '@': + s = '{%s}' % s[1:] + result += s + return result.replace('}{', ' ') + + +def _clean_text(text, cleaner_names): + for name in cleaner_names: + cleaner = getattr(cleaners, name) + if not cleaner: + raise Exception('Unknown cleaner: %s' % name) + text = cleaner(text) + return text + + +def _symbols_to_sequence(symbols): + return [_symbol_to_id[s] for s in symbols if _should_keep_symbol(s)] + + +def _arpabet_to_sequence(text): + return _symbols_to_sequence(['@' + s for s in text.split()]) + + +def _should_keep_symbol(s): + return s in _symbol_to_id and s is not '_' and s is not '~' diff --git a/models/WaveRNNModel/utils/text/cleaners.py b/models/WaveRNNModel/utils/text/cleaners.py new file mode 100644 index 0000000000000000000000000000000000000000..6a13a3c42a5ddca7ce8aa4603944173b63339b0d --- /dev/null +++ b/models/WaveRNNModel/utils/text/cleaners.py @@ -0,0 +1,90 @@ +""" from https://github.com/keithito/tacotron """ + +''' +Cleaners are transformations that run over the input text at both training and eval time. + +Cleaners can be selected by passing a comma-delimited list of cleaner names as the "cleaners" +hyperparameter. Some cleaners are English-specific. You'll typically want to use: + 1. "english_cleaners" for English text + 2. "transliteration_cleaners" for non-English text that can be transliterated to ASCII using + the Unidecode library (https://pypi.python.org/pypi/Unidecode) + 3. "basic_cleaners" if you do not want to transliterate (in this case, you should also update + the symbols in symbols.py to match your data). +''' + +import re +from unidecode import unidecode +from .numbers import normalize_numbers + + +# Regular expression matching whitespace: +_whitespace_re = re.compile(r'\s+') + +# List of (regular expression, replacement) pairs for abbreviations: +_abbreviations = [(re.compile('\\b%s\\.' % x[0], re.IGNORECASE), x[1]) for x in [ + ('mrs', 'misess'), + ('mr', 'mister'), + ('dr', 'doctor'), + ('st', 'saint'), + ('co', 'company'), + ('jr', 'junior'), + ('maj', 'major'), + ('gen', 'general'), + ('drs', 'doctors'), + ('rev', 'reverend'), + ('lt', 'lieutenant'), + ('hon', 'honorable'), + ('sgt', 'sergeant'), + ('capt', 'captain'), + ('esq', 'esquire'), + ('ltd', 'limited'), + ('col', 'colonel'), + ('ft', 'fort'), +]] + + +def expand_abbreviations(text): + for regex, replacement in _abbreviations: + text = re.sub(regex, replacement, text) + return text + + +def expand_numbers(text): + return normalize_numbers(text) + + +def lowercase(text): + return text.lower() + + +def collapse_whitespace(text): + return re.sub(_whitespace_re, ' ', text) + + +def convert_to_ascii(text): + return unidecode(text) + + +def basic_cleaners(text): + '''Basic pipeline that lowercases and collapses whitespace without transliteration.''' + text = lowercase(text) + text = collapse_whitespace(text) + return text + + +def transliteration_cleaners(text): + '''Pipeline for non-English text that transliterates to ASCII.''' + text = convert_to_ascii(text) + text = lowercase(text) + text = collapse_whitespace(text) + return text + + +def english_cleaners(text): + '''Pipeline for English text, including number and abbreviation expansion.''' + text = convert_to_ascii(text) + text = lowercase(text) + text = expand_numbers(text) + text = expand_abbreviations(text) + text = collapse_whitespace(text) + return text diff --git a/models/WaveRNNModel/utils/text/cmudict.py b/models/WaveRNNModel/utils/text/cmudict.py new file mode 100644 index 0000000000000000000000000000000000000000..45e30a625a70b113afc6139d5b23313efccc56ee --- /dev/null +++ b/models/WaveRNNModel/utils/text/cmudict.py @@ -0,0 +1,65 @@ +""" from https://github.com/keithito/tacotron """ + +import re + + +valid_symbols = [ + 'AA', 'AA0', 'AA1', 'AA2', 'AE', 'AE0', 'AE1', 'AE2', 'AH', 'AH0', 'AH1', 'AH2', + 'AO', 'AO0', 'AO1', 'AO2', 'AW', 'AW0', 'AW1', 'AW2', 'AY', 'AY0', 'AY1', 'AY2', + 'B', 'CH', 'D', 'DH', 'EH', 'EH0', 'EH1', 'EH2', 'ER', 'ER0', 'ER1', 'ER2', 'EY', + 'EY0', 'EY1', 'EY2', 'F', 'G', 'HH', 'IH', 'IH0', 'IH1', 'IH2', 'IY', 'IY0', 'IY1', + 'IY2', 'JH', 'K', 'L', 'M', 'N', 'NG', 'OW', 'OW0', 'OW1', 'OW2', 'OY', 'OY0', + 'OY1', 'OY2', 'P', 'R', 'S', 'SH', 'T', 'TH', 'UH', 'UH0', 'UH1', 'UH2', 'UW', + 'UW0', 'UW1', 'UW2', 'V', 'W', 'Y', 'Z', 'ZH' +] + +_valid_symbol_set = set(valid_symbols) + + +class CMUDict: + '''Thin wrapper around CMUDict data. http://www.speech.cs.cmu.edu/cgi-bin/cmudict''' + def __init__(self, file_or_path, keep_ambiguous=True): + if isinstance(file_or_path, str): + with open(file_or_path, encoding='latin-1') as f: + entries = _parse_cmudict(f) + else: + entries = _parse_cmudict(file_or_path) + if not keep_ambiguous: + entries = {word: pron for word, pron in entries.items() if len(pron) == 1} + self._entries = entries + + + def __len__(self): + return len(self._entries) + + + def lookup(self, word): + '''Returns list of ARPAbet pronunciations of the given word.''' + return self._entries.get(word.upper()) + + + +_alt_re = re.compile(r'\([0-9]+\)') + + +def _parse_cmudict(file): + cmudict = {} + for line in file: + if len(line) and (line[0] >= 'A' and line[0] <= 'Z' or line[0] == "'"): + parts = line.split(' ') + word = re.sub(_alt_re, '', parts[0]) + pronunciation = _get_pronunciation(parts[1]) + if pronunciation: + if word in cmudict: + cmudict[word].append(pronunciation) + else: + cmudict[word] = [pronunciation] + return cmudict + + +def _get_pronunciation(s): + parts = s.strip().split(' ') + for part in parts: + if part not in _valid_symbol_set: + return None + return ' '.join(parts) diff --git a/models/WaveRNNModel/utils/text/numbers.py b/models/WaveRNNModel/utils/text/numbers.py new file mode 100644 index 0000000000000000000000000000000000000000..e4c803cf93cd61c5be96dc2e9bda56e901258e4e --- /dev/null +++ b/models/WaveRNNModel/utils/text/numbers.py @@ -0,0 +1,71 @@ +""" from https://github.com/keithito/tacotron """ + +import inflect +import re + + +_inflect = inflect.engine() +_comma_number_re = re.compile(r'([0-9][0-9\,]+[0-9])') +_decimal_number_re = re.compile(r'([0-9]+\.[0-9]+)') +_pounds_re = re.compile(r'£([0-9\,]*[0-9]+)') +_dollars_re = re.compile(r'\$([0-9\.\,]*[0-9]+)') +_ordinal_re = re.compile(r'[0-9]+(st|nd|rd|th)') +_number_re = re.compile(r'[0-9]+') + + +def _remove_commas(m): + return m.group(1).replace(',', '') + + +def _expand_decimal_point(m): + return m.group(1).replace('.', ' point ') + + +def _expand_dollars(m): + match = m.group(1) + parts = match.split('.') + if len(parts) > 2: + return match + ' dollars' # Unexpected format + dollars = int(parts[0]) if parts[0] else 0 + cents = int(parts[1]) if len(parts) > 1 and parts[1] else 0 + if dollars and cents: + dollar_unit = 'dollar' if dollars == 1 else 'dollars' + cent_unit = 'cent' if cents == 1 else 'cents' + return '%s %s, %s %s' % (dollars, dollar_unit, cents, cent_unit) + elif dollars: + dollar_unit = 'dollar' if dollars == 1 else 'dollars' + return '%s %s' % (dollars, dollar_unit) + elif cents: + cent_unit = 'cent' if cents == 1 else 'cents' + return '%s %s' % (cents, cent_unit) + else: + return 'zero dollars' + + +def _expand_ordinal(m): + return _inflect.number_to_words(m.group(0)) + + +def _expand_number(m): + num = int(m.group(0)) + if num > 1000 and num < 3000: + if num == 2000: + return 'two thousand' + elif num > 2000 and num < 2010: + return 'two thousand ' + _inflect.number_to_words(num % 100) + elif num % 100 == 0: + return _inflect.number_to_words(num // 100) + ' hundred' + else: + return _inflect.number_to_words(num, andword='', zero='oh', group=2).replace(', ', ' ') + else: + return _inflect.number_to_words(num, andword='') + + +def normalize_numbers(text): + text = re.sub(_comma_number_re, _remove_commas, text) + text = re.sub(_pounds_re, r'\1 pounds', text) + text = re.sub(_dollars_re, _expand_dollars, text) + text = re.sub(_decimal_number_re, _expand_decimal_point, text) + text = re.sub(_ordinal_re, _expand_ordinal, text) + text = re.sub(_number_re, _expand_number, text) + return text diff --git a/models/WaveRNNModel/utils/text/recipes.py b/models/WaveRNNModel/utils/text/recipes.py new file mode 100644 index 0000000000000000000000000000000000000000..ffc8925d7f1b3e7dd8f7963b2a9e3dd90aa30a01 --- /dev/null +++ b/models/WaveRNNModel/utils/text/recipes.py @@ -0,0 +1,18 @@ +from utils.files import get_files +from pathlib import Path +from typing import Union + + +def ljspeech(path: Union[str, Path]): + csv_file = get_files(path, extension='.csv') + + assert len(csv_file) == 1 + + text_dict = {} + + with open(csv_file[0], encoding='utf-8') as f : + for line in f : + split = line.split('|') + text_dict[split[0]] = split[-1] + + return text_dict \ No newline at end of file diff --git a/models/WaveRNNModel/utils/text/symbols.py b/models/WaveRNNModel/utils/text/symbols.py new file mode 100644 index 0000000000000000000000000000000000000000..7f9644a22665a17dad66990be0b72abc268fbfe7 --- /dev/null +++ b/models/WaveRNNModel/utils/text/symbols.py @@ -0,0 +1,18 @@ +""" from https://github.com/keithito/tacotron """ + +''' +Defines the set of symbols used in text input to the model. + +The default is a set of ASCII characters that works well for English or text that has been run through Unidecode. For other data, you can modify _characters. See TRAINING_DATA.md for details. ''' +from utils.text import cmudict + +_pad = '_' +_punctuation = '!\'(),.:;? ' +_special = '-' +_letters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz' + +# Prepend "@" to ARPAbet symbols to ensure uniqueness (some are the same as uppercase letters): +_arpabet = ['@' + s for s in cmudict.valid_symbols] + +# Export all symbols: +symbols = [_pad] + list(_special) + list(_punctuation) + list(_letters) + _arpabet