From 5be66f5fd699f268a72592c718b50e9ada96d577 Mon Sep 17 00:00:00 2001 From: soumik12345 <19soumik.rakshit96@gmail.com> Date: Tue, 29 Mar 2022 20:27:08 +0000 Subject: [PATCH 01/15] fixed clip version --- environment/environment.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/environment/environment.yml b/environment/environment.yml index f445cb0..3f23ceb 100644 --- a/environment/environment.yml +++ b/environment/environment.yml @@ -160,7 +160,7 @@ dependencies: - cachetools==4.2.4 - charset-normalizer==2.0.7 - click==8.0.3 - - clip==1.0 + - clip==0.2.0 - deprecated==1.2.13 - dlib==19.22.1 - et-xmlfile==1.1.0 From 7f82f59dbffd9de525eaa103b91020a618f0f6a6 Mon Sep 17 00:00:00 2001 From: soumik12345 <19soumik.rakshit96@gmail.com> Date: Tue, 29 Mar 2022 20:28:58 +0000 Subject: [PATCH 02/15] added wandb as pip dependency --- environment/environment.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/environment/environment.yml b/environment/environment.yml index 3f23ceb..fd9e925 100644 --- a/environment/environment.yml +++ b/environment/environment.yml @@ -206,4 +206,5 @@ dependencies: - uritemplate==3.0.1 - urllib3==1.26.7 - wrapt==1.13.3 + - wandb==0.12.11 prefix: ~/.conda/envs/Barbershop From d78e658ce34ba791562f2b6722d068c0eeed0bd6 Mon Sep 17 00:00:00 2001 From: soumik12345 <19soumik.rakshit96@gmail.com> Date: Tue, 29 Mar 2022 22:10:24 +0000 Subject: [PATCH 03/15] feature: wandb artifacts integration --- .gitignore | 3 ++ main.py | 83 ++++++++++++++++++++------------------------- models/Alignment.py | 14 ++++---- models/Blending.py | 14 ++++---- models/Embedding.py | 4 +-- models/Net.py | 36 +++++--------------- 6 files changed, 61 insertions(+), 93 deletions(-) diff --git a/.gitignore b/.gitignore index 47d1f5a..3eac843 100644 --- a/.gitignore +++ b/.gitignore @@ -131,6 +131,9 @@ dmypy.json .pyre/ wandb/ +artifacts/ +input/ +output/ *.lmdb/ *.pkl *.pt diff --git a/main.py b/main.py index 597031b..7a01e5e 100644 --- a/main.py +++ b/main.py @@ -1,55 +1,45 @@ -import argparse - -import torch -import numpy as np -import sys import os -import dlib - - -from PIL import Image - +import wandb +import argparse +from typing import Union from models.Embedding import Embedding from models.Alignment import Alignment from models.Blending import Blending -def main(args): - ii2s = Embedding(args) - # - # ##### Option 1: input folder - # # ii2s.invert_images_in_W() - # # ii2s.invert_images_in_FS() - - # ##### Option 2: image path - # # ii2s.invert_images_in_W('input/face/28.png') - # # ii2s.invert_images_in_FS('input/face/28.png') - # - ##### Option 3: image path list - # im_path1 = 'input/face/90.png' - # im_path2 = 'input/face/15.png' - # im_path3 = 'input/face/117.png' +def main(args): + wandb.login() + with wandb.init(project=args.wandb_project, entity=args.wandb_entity, job_type="test"): - im_path1 = os.path.join(args.input_dir, args.im_path1) - im_path2 = os.path.join(args.input_dir, args.im_path2) - im_path3 = os.path.join(args.input_dir, args.im_path3) + images_artifact = wandb.use_artifact(args.images_artifact, type='dataset') + images_artifact_dir = images_artifact.download() - im_set = {im_path1, im_path2, im_path3} - ii2s.invert_images_in_W([*im_set]) - ii2s.invert_images_in_FS([*im_set]) + ffhq_model_artifact = wandb.use_artifact(args.ffhq_models_artifact, type='model') + ffhq_model_artifact_dir = ffhq_model_artifact.download() + ffhq_model_file = os.path.join(ffhq_model_artifact_dir, "ffhq.pt") - align = Alignment(args) - align.align_images(im_path1, im_path2, sign=args.sign, align_more_region=False, smooth=args.smooth) - if im_path2 != im_path3: - align.align_images(im_path1, im_path3, sign=args.sign, align_more_region=False, smooth=args.smooth, save_intermediate=False) + segmentation_model_artifact = wandb.use_artifact(args.segmentation_models_artifact, type='model') + segmentation_model_artifact_dir = segmentation_model_artifact.download() + segmentation_model_file = os.path.join(segmentation_model_artifact_dir, "seg.pth") - blend = Blending(args) - blend.blend_images(im_path1, im_path2, im_path3, sign=args.sign) + ii2s = Embedding(args, checkpoint_file=ffhq_model_file) + im_path1 = os.path.join(images_artifact_dir, args.im_path1) + im_path2 = os.path.join(images_artifact_dir, args.im_path2) + im_path3 = os.path.join(images_artifact_dir, args.im_path3) + im_set = {im_path1, im_path2, im_path3} + ii2s.invert_images_in_W([*im_set]) + ii2s.invert_images_in_FS([*im_set]) + align = Alignment(args, ffhq_checkpoint_file=ffhq_model_file, segmentation_checkpoint_file=segmentation_model_file) + align.align_images(im_path1, im_path2, sign=args.sign, align_more_region=False, smooth=args.smooth) + if im_path2 != im_path3: + align.align_images(im_path1, im_path3, sign=args.sign, align_more_region=False, smooth=args.smooth, save_intermediate=False) + blend = Blending(args, ffhq_checkpoint_file=ffhq_model_file, segmentation_checkpoint_file=segmentation_model_file) + blend.blend_images(im_path1, im_path2, im_path3, sign=args.sign) if __name__ == "__main__": @@ -57,10 +47,12 @@ def main(args): parser = argparse.ArgumentParser(description='Barbershop') # I/O arguments - parser.add_argument('--input_dir', type=str, default='input/face', - help='The directory of the images to be inverted') - parser.add_argument('--output_dir', type=str, default='output', - help='The directory to save the latent codes and inversion images') + parser.add_argument('--wandb_project', type=str, default='barbershop', help='WandB Project Name') + parser.add_argument('--wandb_entity', type=str, default=None, help='WandB Entity') + parser.add_argument('--images_artifact', type=str, default="geekyrakshit/barbershop/II2S-Images:v0", help='WandB Artifact address for II2S Images') + parser.add_argument('--ffhq_models_artifact', type=str, default="geekyrakshit/barbershop/ffhq:v0", help='WandB Artifact address for ffhq model') + parser.add_argument('--segmentation_models_artifact', type=str, default="geekyrakshit/barbershop/segmentation:v0", help='WandB Artifact address for segmentation model') + parser.add_argument('--output_dir', type=str, default='output', help='The directory to save the latent codes and inversion images') parser.add_argument('--im_path1', type=str, default='16.png', help='Identity image') parser.add_argument('--im_path2', type=str, default='15.png', help='Structure image') parser.add_argument('--im_path3', type=str, default='117.png', help='Appearance image') @@ -69,7 +61,7 @@ def main(args): # StyleGAN2 setting parser.add_argument('--size', type=int, default=1024) - parser.add_argument('--ckpt', type=str, default="pretrained_models/ffhq.pt") + # parser.add_argument('--ckpt', type=str, default="pretrained_models/ffhq.pt") parser.add_argument('--channel_multiplier', type=int, default=2) parser.add_argument('--latent', type=int, default=512) parser.add_argument('--n_mlp', type=int, default=8) @@ -85,7 +77,7 @@ def main(args): help='Whether to store and save intermediate HR and LR images during optimization') parser.add_argument('--save_interval', type=int, default=300, help='Latent checkpoint interval') parser.add_argument('--verbose', action='store_true', help='Print loss information') - parser.add_argument('--seg_ckpt', type=str, default='pretrained_models/seg.pth') + # parser.add_argument('--seg_ckpt', type=str, default='pretrained_models/seg.pth') # Embedding loss options @@ -97,7 +89,6 @@ def main(args): parser.add_argument('--FS_steps', type=int, default=250, help='Number of W space optimization steps') - # Alignment loss options parser.add_argument('--ce_lambda', type=float, default=1.0, help='cross entropy loss multiplier factor') parser.add_argument('--style_lambda', type=str, default=4e4, help='style loss multiplier factor') @@ -111,7 +102,5 @@ def main(args): parser.add_argument('--blend_steps', type=int, default=400, help='') - - args = parser.parse_args() - main(args) \ No newline at end of file + main(args) diff --git a/models/Alignment.py b/models/Alignment.py index 8b9740d..571ff89 100644 --- a/models/Alignment.py +++ b/models/Alignment.py @@ -25,13 +25,11 @@ class Alignment(nn.Module): - def __init__(self, opts, net=None): + def __init__(self, opts, ffhq_checkpoint_file: str, segmentation_checkpoint_file: str, net=None): super(Alignment, self).__init__() self.opts = opts - if not net: - self.net = Net(self.opts) - else: - self.net = net + self.segmentation_checkpoint_file = segmentation_checkpoint_file + self.net = Net(self.opts, checkpoint_file=ffhq_checkpoint_file) if not net else net self.load_segmentation_network() self.load_downsampling() @@ -41,9 +39,9 @@ def load_segmentation_network(self): self.seg = BiSeNet(n_classes=16) self.seg.to(self.opts.device) - if not os.path.exists(self.opts.seg_ckpt): - download_weight(self.opts.seg_ckpt) - self.seg.load_state_dict(torch.load(self.opts.seg_ckpt)) + if not os.path.exists(self.segmentation_checkpoint_file): + download_weight(self.segmentation_checkpoint_file) + self.seg.load_state_dict(torch.load(self.segmentation_checkpoint_file)) for param in self.seg.parameters(): param.requires_grad = False self.seg.eval() diff --git a/models/Blending.py b/models/Blending.py index f964385..b951a58 100644 --- a/models/Blending.py +++ b/models/Blending.py @@ -24,13 +24,11 @@ class Blending(nn.Module): - def __init__(self, opts, net=None): + def __init__(self, opts, ffhq_checkpoint_file: str, segmentation_checkpoint_file: str, net=None): super(Blending, self).__init__() self.opts = opts - if not net: - self.net = Net(self.opts) - else: - self.net = net + self.segmentation_checkpoint_file = segmentation_checkpoint_file + self.net = Net(self.opts, checkpoint_file=ffhq_checkpoint_file) if not net else net self.load_segmentation_network() self.load_downsampling() @@ -47,9 +45,9 @@ def load_segmentation_network(self): self.seg = BiSeNet(n_classes=16) self.seg.to(self.opts.device) - if not os.path.exists(self.opts.seg_ckpt): - download_weight(self.opts.seg_ckpt) - self.seg.load_state_dict(torch.load(self.opts.seg_ckpt)) + if not os.path.exists(self.segmentation_checkpoint_file): + download_weight(self.segmentation_checkpoint_file) + self.seg.load_state_dict(torch.load(self.segmentation_checkpoint_file)) for param in self.seg.parameters(): param.requires_grad = False self.seg.eval() diff --git a/models/Embedding.py b/models/Embedding.py index 5ddf259..50c45f7 100644 --- a/models/Embedding.py +++ b/models/Embedding.py @@ -17,10 +17,10 @@ class Embedding(nn.Module): - def __init__(self, opts): + def __init__(self, opts, checkpoint_file: str): super(Embedding, self).__init__() self.opts = opts - self.net = Net(self.opts) + self.net = Net(self.opts, checkpoint_file=checkpoint_file) self.load_downsampling() self.setup_embedding_loss_builder() diff --git a/models/Net.py b/models/Net.py index 0afffe4..3600115 100644 --- a/models/Net.py +++ b/models/Net.py @@ -7,22 +7,22 @@ class Net(nn.Module): - def __init__(self, opts): + def __init__(self, opts, checkpoint_file: str): super(Net, self).__init__() self.opts = opts + self.checkpoint_file = checkpoint_file self.generator = Generator(opts.size, opts.latent, opts.n_mlp, channel_multiplier=opts.channel_multiplier) self.cal_layer_num() self.load_weights() self.load_PCA_model() - def load_weights(self): - if not os.path.exists(self.opts.ckpt): - print('Downloading StyleGAN2 checkpoint: {}'.format(self.opts.ckpt)) - download_weight(self.opts.ckpt) + if not os.path.exists(self.checkpoint_file): + print('Downloading StyleGAN2 checkpoint: {}'.format(self.checkpoint_file)) + download_weight(self.checkpoint_file) - print('Loading StyleGAN2 from checkpoint: {}'.format(self.opts.ckpt)) - checkpoint = torch.load(self.opts.ckpt) + print('Loading StyleGAN2 from checkpoint: {}'.format(self.checkpoint_file)) + checkpoint = torch.load(self.checkpoint_file) device = self.opts.device self.generator.load_state_dict(checkpoint['g_ema']) self.latent_avg = checkpoint['latent_avg'] @@ -51,30 +51,16 @@ def build_PCA_model(self, PCA_path): X_comp, X_stdev, X_var_ratio = transformer.get_components() np.savez(PCA_path, X_mean=X_mean, X_comp=X_comp, X_stdev=X_stdev, X_var_ratio=X_var_ratio) - def load_PCA_model(self): device = self.opts.device - - PCA_path = self.opts.ckpt[:-3] + '_PCA.npz' - + PCA_path = self.checkpoint_file[:-3] + '_PCA.npz' if not os.path.isfile(PCA_path): self.build_PCA_model(PCA_path) - PCA_model = np.load(PCA_path) self.X_mean = torch.from_numpy(PCA_model['X_mean']).float().to(device) self.X_comp = torch.from_numpy(PCA_model['X_comp']).float().to(device) self.X_stdev = torch.from_numpy(PCA_model['X_stdev']).float().to(device) - - - # def make_noise(self): - # noises_single = self.generator.make_noise() - # noises = [] - # for noise in noises_single: - # noises.append(noise.repeat(1, 1, 1, 1).normal_()) - # - # return noises - def cal_layer_num(self): if self.opts.size == 1024: self.layer_num = 18 @@ -82,20 +68,14 @@ def cal_layer_num(self): self.layer_num = 16 elif self.opts.size == 256: self.layer_num = 14 - self.S_index = self.layer_num - 11 - return - def cal_p_norm_loss(self, latent_in): latent_p_norm = (torch.nn.LeakyReLU(negative_slope=5)(latent_in) - self.X_mean).bmm( self.X_comp.T.unsqueeze(0)) / self.X_stdev p_norm_loss = self.opts.p_norm_lambda * (latent_p_norm.pow(2).mean()) return p_norm_loss - def cal_l_F(self, latent_F, F_init): return self.opts.l_F_lambda * (latent_F - F_init).pow(2).mean() - - From 11f54a0fb757aafbbae21f6b7469db324493f778 Mon Sep 17 00:00:00 2001 From: soumik12345 <19soumik.rakshit96@gmail.com> Date: Wed, 30 Mar 2022 12:16:51 +0000 Subject: [PATCH 04/15] added gpu utilization for inference --- main.py | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/main.py b/main.py index 7a01e5e..1833a3b 100644 --- a/main.py +++ b/main.py @@ -1,7 +1,7 @@ import os +import torch import wandb import argparse -from typing import Union from models.Embedding import Embedding from models.Alignment import Alignment @@ -23,7 +23,9 @@ def main(args): segmentation_model_artifact_dir = segmentation_model_artifact.download() segmentation_model_file = os.path.join(segmentation_model_artifact_dir, "seg.pth") - ii2s = Embedding(args, checkpoint_file=ffhq_model_file) + device = "cuda:0" if torch.cuda.is_available() else "cpu" + + ii2s = Embedding(args, checkpoint_file=ffhq_model_file).to(device=device) im_path1 = os.path.join(images_artifact_dir, args.im_path1) im_path2 = os.path.join(images_artifact_dir, args.im_path2) @@ -33,12 +35,12 @@ def main(args): ii2s.invert_images_in_W([*im_set]) ii2s.invert_images_in_FS([*im_set]) - align = Alignment(args, ffhq_checkpoint_file=ffhq_model_file, segmentation_checkpoint_file=segmentation_model_file) + align = Alignment(args, ffhq_checkpoint_file=ffhq_model_file, segmentation_checkpoint_file=segmentation_model_file).to(device=device) align.align_images(im_path1, im_path2, sign=args.sign, align_more_region=False, smooth=args.smooth) if im_path2 != im_path3: align.align_images(im_path1, im_path3, sign=args.sign, align_more_region=False, smooth=args.smooth, save_intermediate=False) - blend = Blending(args, ffhq_checkpoint_file=ffhq_model_file, segmentation_checkpoint_file=segmentation_model_file) + blend = Blending(args, ffhq_checkpoint_file=ffhq_model_file, segmentation_checkpoint_file=segmentation_model_file).to(device=device) blend.blend_images(im_path1, im_path2, im_path3, sign=args.sign) From 4d35ab2bf6dfaff58dced62f10d00c1f692b616f Mon Sep 17 00:00:00 2001 From: soumik12345 <19soumik.rakshit96@gmail.com> Date: Wed, 30 Mar 2022 13:01:16 +0000 Subject: [PATCH 05/15] updated image arguments --- main.py | 26 +++++++++++--------------- models/Embedding.py | 5 ----- 2 files changed, 11 insertions(+), 20 deletions(-) diff --git a/main.py b/main.py index 1833a3b..03ff365 100644 --- a/main.py +++ b/main.py @@ -27,21 +27,21 @@ def main(args): ii2s = Embedding(args, checkpoint_file=ffhq_model_file).to(device=device) - im_path1 = os.path.join(images_artifact_dir, args.im_path1) - im_path2 = os.path.join(images_artifact_dir, args.im_path2) - im_path3 = os.path.join(images_artifact_dir, args.im_path3) + identity_image = os.path.join(images_artifact_dir, args.identity_image) + structure_image = os.path.join(images_artifact_dir, args.structure_image) + appearance_image = os.path.join(images_artifact_dir, args.appearance_image) - im_set = {im_path1, im_path2, im_path3} + im_set = {identity_image, structure_image, appearance_image} ii2s.invert_images_in_W([*im_set]) ii2s.invert_images_in_FS([*im_set]) align = Alignment(args, ffhq_checkpoint_file=ffhq_model_file, segmentation_checkpoint_file=segmentation_model_file).to(device=device) - align.align_images(im_path1, im_path2, sign=args.sign, align_more_region=False, smooth=args.smooth) - if im_path2 != im_path3: - align.align_images(im_path1, im_path3, sign=args.sign, align_more_region=False, smooth=args.smooth, save_intermediate=False) + align.align_images(identity_image, structure_image, sign=args.sign, align_more_region=False, smooth=args.smooth) + if structure_image != appearance_image: + align.align_images(identity_image, appearance_image, sign=args.sign, align_more_region=False, smooth=args.smooth, save_intermediate=False) blend = Blending(args, ffhq_checkpoint_file=ffhq_model_file, segmentation_checkpoint_file=segmentation_model_file).to(device=device) - blend.blend_images(im_path1, im_path2, im_path3, sign=args.sign) + blend.blend_images(identity_image, structure_image, appearance_image, sign=args.sign) if __name__ == "__main__": @@ -55,9 +55,9 @@ def main(args): parser.add_argument('--ffhq_models_artifact', type=str, default="geekyrakshit/barbershop/ffhq:v0", help='WandB Artifact address for ffhq model') parser.add_argument('--segmentation_models_artifact', type=str, default="geekyrakshit/barbershop/segmentation:v0", help='WandB Artifact address for segmentation model') parser.add_argument('--output_dir', type=str, default='output', help='The directory to save the latent codes and inversion images') - parser.add_argument('--im_path1', type=str, default='16.png', help='Identity image') - parser.add_argument('--im_path2', type=str, default='15.png', help='Structure image') - parser.add_argument('--im_path3', type=str, default='117.png', help='Appearance image') + parser.add_argument('--identity_image', type=str, default='16.png', help='Identity image') + parser.add_argument('--structure_image', type=str, default='15.png', help='Structure image') + parser.add_argument('--appearance_image', type=str, default='117.png', help='Appearance image') parser.add_argument('--sign', type=str, default='realistic', help='realistic or fidelity results') parser.add_argument('--smooth', type=int, default=5, help='dilation and erosion parameter') @@ -81,7 +81,6 @@ def main(args): parser.add_argument('--verbose', action='store_true', help='Print loss information') # parser.add_argument('--seg_ckpt', type=str, default='pretrained_models/seg.pth') - # Embedding loss options parser.add_argument('--percept_lambda', type=float, default=1.0, help='Perceptual loss multiplier factor') parser.add_argument('--l2_lambda', type=float, default=1.0, help='L2 loss multiplier factor') @@ -90,19 +89,16 @@ def main(args): parser.add_argument('--W_steps', type=int, default=1100, help='Number of W space optimization steps') parser.add_argument('--FS_steps', type=int, default=250, help='Number of W space optimization steps') - # Alignment loss options parser.add_argument('--ce_lambda', type=float, default=1.0, help='cross entropy loss multiplier factor') parser.add_argument('--style_lambda', type=str, default=4e4, help='style loss multiplier factor') parser.add_argument('--align_steps1', type=int, default=140, help='') parser.add_argument('--align_steps2', type=int, default=100, help='') - # Blend loss options parser.add_argument('--face_lambda', type=float, default=1.0, help='') parser.add_argument('--hair_lambda', type=str, default=1.0, help='') parser.add_argument('--blend_steps', type=int, default=400, help='') - args = parser.parse_args() main(args) diff --git a/models/Embedding.py b/models/Embedding.py index 50c45f7..1969f54 100644 --- a/models/Embedding.py +++ b/models/Embedding.py @@ -55,7 +55,6 @@ def setup_W_optimizer(self): return optimizer_W, latent - def setup_FS_optimizer(self, latent_W, F_init): latent_F = F_init.clone().detach().requires_grad_(True) @@ -127,8 +126,6 @@ def invert_images_in_W(self, image_path=None): self.save_W_results(ref_name, gen_im, latent_in) - - def invert_images_in_FS(self, image_path=None): self.setup_dataloader(image_path=image_path) output_dir = self.opts.output_dir @@ -168,8 +165,6 @@ def invert_images_in_FS(self, image_path=None): self.save_FS_results(ref_name, gen_im, latent_in, latent_F) - - def cal_loss(self, im_dict, latent_in, latent_F=None, F_init=None): loss, loss_dic = self.loss_builder(**im_dict) p_norm_loss = self.net.cal_p_norm_loss(latent_in) From 9b78f970b046de1f70b0f646c76fd3c643689588 Mon Sep 17 00:00:00 2001 From: soumik12345 <19soumik.rakshit96@gmail.com> Date: Wed, 30 Mar 2022 13:03:41 +0000 Subject: [PATCH 06/15] updated main.py --- main.py | 212 +++++++++++++++++++++++++++++++++++++++++++------------- 1 file changed, 162 insertions(+), 50 deletions(-) diff --git a/main.py b/main.py index 03ff365..6942884 100644 --- a/main.py +++ b/main.py @@ -10,18 +10,26 @@ def main(args): wandb.login() - with wandb.init(project=args.wandb_project, entity=args.wandb_entity, job_type="test"): + with wandb.init( + project=args.wandb_project, entity=args.wandb_entity, job_type="test" + ): - images_artifact = wandb.use_artifact(args.images_artifact, type='dataset') + images_artifact = wandb.use_artifact(args.images_artifact, type="dataset") images_artifact_dir = images_artifact.download() - ffhq_model_artifact = wandb.use_artifact(args.ffhq_models_artifact, type='model') + ffhq_model_artifact = wandb.use_artifact( + args.ffhq_models_artifact, type="model" + ) ffhq_model_artifact_dir = ffhq_model_artifact.download() ffhq_model_file = os.path.join(ffhq_model_artifact_dir, "ffhq.pt") - segmentation_model_artifact = wandb.use_artifact(args.segmentation_models_artifact, type='model') + segmentation_model_artifact = wandb.use_artifact( + args.segmentation_models_artifact, type="model" + ) segmentation_model_artifact_dir = segmentation_model_artifact.download() - segmentation_model_file = os.path.join(segmentation_model_artifact_dir, "seg.pth") + segmentation_model_file = os.path.join( + segmentation_model_artifact_dir, "seg.pth" + ) device = "cuda:0" if torch.cuda.is_available() else "cpu" @@ -35,70 +43,174 @@ def main(args): ii2s.invert_images_in_W([*im_set]) ii2s.invert_images_in_FS([*im_set]) - align = Alignment(args, ffhq_checkpoint_file=ffhq_model_file, segmentation_checkpoint_file=segmentation_model_file).to(device=device) - align.align_images(identity_image, structure_image, sign=args.sign, align_more_region=False, smooth=args.smooth) + align = Alignment( + args, + ffhq_checkpoint_file=ffhq_model_file, + segmentation_checkpoint_file=segmentation_model_file, + ).to(device=device) + align.align_images( + identity_image, + structure_image, + sign=args.sign, + align_more_region=False, + smooth=args.smooth, + ) if structure_image != appearance_image: - align.align_images(identity_image, appearance_image, sign=args.sign, align_more_region=False, smooth=args.smooth, save_intermediate=False) - - blend = Blending(args, ffhq_checkpoint_file=ffhq_model_file, segmentation_checkpoint_file=segmentation_model_file).to(device=device) - blend.blend_images(identity_image, structure_image, appearance_image, sign=args.sign) + align.align_images( + identity_image, + appearance_image, + sign=args.sign, + align_more_region=False, + smooth=args.smooth, + save_intermediate=False, + ) + + blend = Blending( + args, + ffhq_checkpoint_file=ffhq_model_file, + segmentation_checkpoint_file=segmentation_model_file, + ).to(device=device) + blend.blend_images( + identity_image, structure_image, appearance_image, sign=args.sign + ) if __name__ == "__main__": - parser = argparse.ArgumentParser(description='Barbershop') + parser = argparse.ArgumentParser(description="Barbershop") # I/O arguments - parser.add_argument('--wandb_project', type=str, default='barbershop', help='WandB Project Name') - parser.add_argument('--wandb_entity', type=str, default=None, help='WandB Entity') - parser.add_argument('--images_artifact', type=str, default="geekyrakshit/barbershop/II2S-Images:v0", help='WandB Artifact address for II2S Images') - parser.add_argument('--ffhq_models_artifact', type=str, default="geekyrakshit/barbershop/ffhq:v0", help='WandB Artifact address for ffhq model') - parser.add_argument('--segmentation_models_artifact', type=str, default="geekyrakshit/barbershop/segmentation:v0", help='WandB Artifact address for segmentation model') - parser.add_argument('--output_dir', type=str, default='output', help='The directory to save the latent codes and inversion images') - parser.add_argument('--identity_image', type=str, default='16.png', help='Identity image') - parser.add_argument('--structure_image', type=str, default='15.png', help='Structure image') - parser.add_argument('--appearance_image', type=str, default='117.png', help='Appearance image') - parser.add_argument('--sign', type=str, default='realistic', help='realistic or fidelity results') - parser.add_argument('--smooth', type=int, default=5, help='dilation and erosion parameter') + parser.add_argument( + "--wandb_project", type=str, default="barbershop", help="WandB Project Name" + ) + parser.add_argument("--wandb_entity", type=str, default=None, help="WandB Entity") + parser.add_argument( + "--images_artifact", + type=str, + default="geekyrakshit/barbershop/II2S-Images:v0", + help="WandB Artifact address for II2S Images", + ) + parser.add_argument( + "--ffhq_models_artifact", + type=str, + default="geekyrakshit/barbershop/ffhq:v0", + help="WandB Artifact address for ffhq model", + ) + parser.add_argument( + "--segmentation_models_artifact", + type=str, + default="geekyrakshit/barbershop/segmentation:v0", + help="WandB Artifact address for segmentation model", + ) + parser.add_argument( + "--output_dir", + type=str, + default="output", + help="The directory to save the latent codes and inversion images", + ) + parser.add_argument( + "--identity_image", type=str, default="16.png", help="Identity image" + ) + parser.add_argument( + "--structure_image", type=str, default="15.png", help="Structure image" + ) + parser.add_argument( + "--appearance_image", type=str, default="117.png", help="Appearance image" + ) + parser.add_argument( + "--sign", type=str, default="realistic", help="realistic or fidelity results" + ) + parser.add_argument( + "--smooth", type=int, default=5, help="dilation and erosion parameter" + ) # StyleGAN2 setting - parser.add_argument('--size', type=int, default=1024) + parser.add_argument("--size", type=int, default=1024) # parser.add_argument('--ckpt', type=str, default="pretrained_models/ffhq.pt") - parser.add_argument('--channel_multiplier', type=int, default=2) - parser.add_argument('--latent', type=int, default=512) - parser.add_argument('--n_mlp', type=int, default=8) + parser.add_argument("--channel_multiplier", type=int, default=2) + parser.add_argument("--latent", type=int, default=512) + parser.add_argument("--n_mlp", type=int, default=8) # Arguments - parser.add_argument('--device', type=str, default='cuda') - parser.add_argument('--seed', type=int, default=None) - parser.add_argument('--tile_latent', action='store_true', help='Whether to forcibly tile the same latent N times') - parser.add_argument('--opt_name', type=str, default='adam', help='Optimizer to use in projected gradient descent') - parser.add_argument('--learning_rate', type=float, default=0.01, help='Learning rate to use during optimization') - parser.add_argument('--lr_schedule', type=str, default='fixed', help='fixed, linear1cycledrop, linear1cycle') - parser.add_argument('--save_intermediate', action='store_true', - help='Whether to store and save intermediate HR and LR images during optimization') - parser.add_argument('--save_interval', type=int, default=300, help='Latent checkpoint interval') - parser.add_argument('--verbose', action='store_true', help='Print loss information') + parser.add_argument("--device", type=str, default="cuda") + parser.add_argument("--seed", type=int, default=None) + parser.add_argument( + "--tile_latent", + action="store_true", + help="Whether to forcibly tile the same latent N times", + ) + parser.add_argument( + "--opt_name", + type=str, + default="adam", + help="Optimizer to use in projected gradient descent", + ) + parser.add_argument( + "--learning_rate", + type=float, + default=0.01, + help="Learning rate to use during optimization", + ) + parser.add_argument( + "--lr_schedule", + type=str, + default="fixed", + help="fixed, linear1cycledrop, linear1cycle", + ) + parser.add_argument( + "--save_intermediate", + action="store_true", + help="Whether to store and save intermediate HR and LR images during optimization", + ) + parser.add_argument( + "--save_interval", type=int, default=300, help="Latent checkpoint interval" + ) + parser.add_argument("--verbose", action="store_true", help="Print loss information") # parser.add_argument('--seg_ckpt', type=str, default='pretrained_models/seg.pth') # Embedding loss options - parser.add_argument('--percept_lambda', type=float, default=1.0, help='Perceptual loss multiplier factor') - parser.add_argument('--l2_lambda', type=float, default=1.0, help='L2 loss multiplier factor') - parser.add_argument('--p_norm_lambda', type=float, default=0.001, help='P-norm Regularizer multiplier factor') - parser.add_argument('--l_F_lambda', type=float, default=0.1, help='L_F loss multiplier factor') - parser.add_argument('--W_steps', type=int, default=1100, help='Number of W space optimization steps') - parser.add_argument('--FS_steps', type=int, default=250, help='Number of W space optimization steps') + parser.add_argument( + "--percept_lambda", + type=float, + default=1.0, + help="Perceptual loss multiplier factor", + ) + parser.add_argument( + "--l2_lambda", type=float, default=1.0, help="L2 loss multiplier factor" + ) + parser.add_argument( + "--p_norm_lambda", + type=float, + default=0.001, + help="P-norm Regularizer multiplier factor", + ) + parser.add_argument( + "--l_F_lambda", type=float, default=0.1, help="L_F loss multiplier factor" + ) + parser.add_argument( + "--W_steps", type=int, default=1100, help="Number of W space optimization steps" + ) + parser.add_argument( + "--FS_steps", type=int, default=250, help="Number of W space optimization steps" + ) # Alignment loss options - parser.add_argument('--ce_lambda', type=float, default=1.0, help='cross entropy loss multiplier factor') - parser.add_argument('--style_lambda', type=str, default=4e4, help='style loss multiplier factor') - parser.add_argument('--align_steps1', type=int, default=140, help='') - parser.add_argument('--align_steps2', type=int, default=100, help='') + parser.add_argument( + "--ce_lambda", + type=float, + default=1.0, + help="cross entropy loss multiplier factor", + ) + parser.add_argument( + "--style_lambda", type=str, default=4e4, help="style loss multiplier factor" + ) + parser.add_argument("--align_steps1", type=int, default=140, help="") + parser.add_argument("--align_steps2", type=int, default=100, help="") # Blend loss options - parser.add_argument('--face_lambda', type=float, default=1.0, help='') - parser.add_argument('--hair_lambda', type=str, default=1.0, help='') - parser.add_argument('--blend_steps', type=int, default=400, help='') + parser.add_argument("--face_lambda", type=float, default=1.0, help="") + parser.add_argument("--hair_lambda", type=str, default=1.0, help="") + parser.add_argument("--blend_steps", type=int, default=400, help="") args = parser.parse_args() main(args) From 9521d0e28ab82a49a75157f41f746801432d6688 Mon Sep 17 00:00:00 2001 From: soumik12345 <19soumik.rakshit96@gmail.com> Date: Wed, 30 Mar 2022 15:23:40 +0000 Subject: [PATCH 07/15] black formatting + table integration --- align_face.py | 55 ++-- datasets/image_dataset.py | 16 +- inference.ipynb | 382 ++++++++++++++++++++++ losses/align_loss.py | 28 +- losses/blend_loss.py | 36 +-- losses/embedding_loss.py | 32 +- losses/lpips/__init__.py | 148 +++++---- losses/lpips/base_model.py | 25 +- losses/lpips/dist_model.py | 215 +++++++------ losses/lpips/networks_basic.py | 222 ++++++++----- losses/lpips/pretrained_networks.py | 32 +- losses/masked_lpips/__init__.py | 4 +- losses/masked_lpips/dist_model.py | 2 +- losses/masked_lpips/networks_basic.py | 20 +- losses/style/style_loss.py | 6 +- losses/vgg_loss.py | 1 + main.py | 34 +- models/Alignment.py | 384 ++++++++++++++++------- models/Blending.py | 159 +++++++--- models/Embedding.py | 151 +++++---- models/Net.py | 39 ++- models/face_parsing/makeup.py | 40 +-- models/face_parsing/model.py | 91 +++--- models/face_parsing/modules/bn.py | 94 ++++-- models/face_parsing/modules/deeplab.py | 69 ++-- models/face_parsing/modules/dense.py | 51 ++- models/face_parsing/modules/functions.py | 88 ++++-- models/face_parsing/modules/misc.py | 5 +- models/face_parsing/modules/residual.py | 84 ++++- models/face_parsing/resnet.py | 28 +- models/face_parsing/transform.py | 77 ++--- models/optimizer/ClampOptimizer.py | 9 +- models/stylegan2/model.py | 123 +++++--- models/stylegan2/op/fused_act.py | 4 +- utils/PCA_utils.py | 25 +- utils/bicubic.py | 45 ++- utils/data_utils.py | 24 +- utils/drive.py | 33 +- utils/image_utils.py | 37 ++- utils/model_utils.py | 19 +- utils/seg_utils.py | 44 +-- utils/shape_predictor.py | 90 ++++-- 42 files changed, 2122 insertions(+), 949 deletions(-) create mode 100644 inference.ipynb diff --git a/align_face.py b/align_face.py index 5746794..7d64e65 100644 --- a/align_face.py +++ b/align_face.py @@ -6,18 +6,31 @@ from utils.shape_predictor import align_face import PIL -parser = argparse.ArgumentParser(description='Align_face') +parser = argparse.ArgumentParser(description="Align_face") -parser.add_argument('-unprocessed_dir', type=str, default='unprocessed', help='directory with unprocessed images') -parser.add_argument('-output_dir', type=str, default='input/face', help='output directory') +parser.add_argument( + "-unprocessed_dir", + type=str, + default="unprocessed", + help="directory with unprocessed images", +) +parser.add_argument( + "-output_dir", type=str, default="input/face", help="output directory" +) -parser.add_argument('-output_size', type=int, default=1024, help='size to downscale the input images to, must be power of 2') -parser.add_argument('-seed', type=int, help='manual seed to use') -parser.add_argument('-cache_dir', type=str, default='cache', help='cache directory for model weights') +parser.add_argument( + "-output_size", + type=int, + default=1024, + help="size to downscale the input images to, must be power of 2", +) +parser.add_argument("-seed", type=int, help="manual seed to use") +parser.add_argument( + "-cache_dir", type=str, default="cache", help="cache directory for model weights" +) ############### -parser.add_argument('-inter_method', type=str, default='bicubic') - +parser.add_argument("-inter_method", type=str, default="bicubic") args = parser.parse_args() @@ -26,25 +39,31 @@ cache_dir.mkdir(parents=True, exist_ok=True) output_dir = Path(args.output_dir) -output_dir.mkdir(parents=True,exist_ok=True) +output_dir.mkdir(parents=True, exist_ok=True) print("Downloading Shape Predictor") -f=open_url("https://drive.google.com/uc?id=1huhv8PYpNNKbGCLOaYUjOgR1pY5pmbJx", cache_dir=cache_dir, return_path=True) +f = open_url( + "https://drive.google.com/uc?id=1huhv8PYpNNKbGCLOaYUjOgR1pY5pmbJx", + cache_dir=cache_dir, + return_path=True, +) predictor = dlib.shape_predictor(f) for im in Path(args.unprocessed_dir).glob("*.*"): - faces = align_face(str(im),predictor) + faces = align_face(str(im), predictor) - for i,face in enumerate(faces): - if(args.output_size): - factor = 1024//args.output_size - assert args.output_size*factor == 1024 + for i, face in enumerate(faces): + if args.output_size: + factor = 1024 // args.output_size + assert args.output_size * factor == 1024 face_tensor = torchvision.transforms.ToTensor()(face).unsqueeze(0).cuda() face_tensor_lr = face_tensor[0].cpu().detach().clamp(0, 1) face = torchvision.transforms.ToPILImage()(face_tensor_lr) if factor != 1: - face = face.resize((args.output_size, args.output_size), PIL.Image.LANCZOS) + face = face.resize( + (args.output_size, args.output_size), PIL.Image.LANCZOS + ) if len(faces) > 1: - face.save(Path(args.output_dir) / (im.stem+f"_{i}.png")) + face.save(Path(args.output_dir) / (im.stem + f"_{i}.png")) else: - face.save(Path(args.output_dir) / (im.stem + f".png")) \ No newline at end of file + face.save(Path(args.output_dir) / (im.stem + f".png")) diff --git a/datasets/image_dataset.py b/datasets/image_dataset.py index 2701da5..aff4057 100644 --- a/datasets/image_dataset.py +++ b/datasets/image_dataset.py @@ -5,8 +5,8 @@ import torchvision.transforms as transforms import os -class ImagesDataset(Dataset): +class ImagesDataset(Dataset): def __init__(self, opts, image_path=None): if not image_path: image_root = opts.input_dir @@ -16,9 +16,12 @@ def __init__(self, opts, image_path=None): elif type(image_path) == list: self.image_paths = image_path - self.image_transform = transforms.Compose([ - transforms.ToTensor(), - transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])]) + self.image_transform = transforms.Compose( + [ + transforms.ToTensor(), + transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5]), + ] + ) self.opts = opts def __len__(self): @@ -26,7 +29,7 @@ def __len__(self): def __getitem__(self, index): im_path = self.image_paths[index] - im_H = Image.open(im_path).convert('RGB') + im_H = Image.open(im_path).convert("RGB") im_L = im_H.resize((256, 256), PIL.Image.LANCZOS) im_name = os.path.splitext(os.path.basename(im_path))[0] if self.image_transform: @@ -34,6 +37,3 @@ def __getitem__(self, index): im_L = self.image_transform(im_L) return im_H, im_L, im_name - - - diff --git a/inference.ipynb b/inference.ipynb new file mode 100644 index 0000000..c662594 --- /dev/null +++ b/inference.ipynb @@ -0,0 +1,382 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import torch\n", + "import wandb\n", + "import numpy as np\n", + "from PIL import Image\n", + "\n", + "from models.Embedding import Embedding\n", + "from models.Alignment import Alignment\n", + "from models.Blending import Blending" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Failed to detect the name of this notebook, you can set it manually with the WANDB_NOTEBOOK_NAME environment variable to enable code saving.\n", + "\u001b[34m\u001b[1mwandb\u001b[0m: Currently logged in as: \u001b[33mgeekyrakshit\u001b[0m (use `wandb login --relogin` to force relogin)\n" + ] + }, + { + "data": { + "text/html": [ + "Tracking run with wandb version 0.12.11" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Run data is saved locally in /home/paperspace/Workspace/Barbershop/wandb/run-20220330_150026-2j8lbj0d" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Syncing run flowing-field-12 to Weights & Biases (docs)
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "wandb.login()\n", + "wandb.init(\n", + " project=\"barbershop\",\n", + " entity=\"geekyrakshit\",\n", + " job_type=\"test\"\n", + ")\n", + "\n", + "config = wandb.config\n", + "config.wandb_project = 'barbershop'\n", + "config.wandb_entity = None\n", + "config.images_artifact = 'geekyrakshit/barbershop/II2S-Images:v0'\n", + "config.ffhq_models_artifact = 'geekyrakshit/barbershop/ffhq:v0'\n", + "config.segmentation_models_artifact = 'geekyrakshit/barbershop/segmentation:v0'\n", + "config.output_dir = 'output'\n", + "config.identity_image = '90.png'\n", + "config.structure_image = '15.png'\n", + "config.appearance_image = '117.png'\n", + "config.sign = 'realistic'\n", + "config.smooth = 5\n", + "config.size = 1024\n", + "config.channel_multiplier = 2\n", + "config.latent = 512\n", + "config.n_mlp = 8\n", + "config.device = \"cuda\"\n", + "config.seed = None\n", + "config.tile_latent = False\n", + "config.opt_name = 'adam'\n", + "config.learning_rate = 0.01\n", + "config.lr_schedule = 'fixed'\n", + "config.save_intermediate = False\n", + "config.save_interval = 300\n", + "config.verbose = False\n", + "config.percept_lambda = 1.0\n", + "config.l2_lambda = 1.0\n", + "config.p_norm_lambda = 0.001\n", + "config.l_F_lambda = 0.1\n", + "config.W_steps = 1100\n", + "config.FS_steps = 250\n", + "config.ce_lambda = 1.0\n", + "config.style_lambda = 40000.0\n", + "config.align_steps1 = 140\n", + "config.align_steps2 = 100\n", + "config.face_lambda = 1.0\n", + "config.hair_lambda = 1.0\n", + "config.blend_steps = 400" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[34m\u001b[1mwandb\u001b[0m: Downloading large artifact II2S-Images:v0, 155.34MB. 120 files... Done. 0:0:0\n", + "\u001b[34m\u001b[1mwandb\u001b[0m: Downloading large artifact ffhq:v0, 126.55MB. 1 files... Done. 0:0:0\n", + "\u001b[34m\u001b[1mwandb\u001b[0m: Downloading large artifact segmentation:v0, 50.82MB. 1 files... Done. 0:0:0\n" + ] + } + ], + "source": [ + "images_artifact = wandb.use_artifact(config.images_artifact, type=\"dataset\")\n", + "images_artifact_dir = images_artifact.download()\n", + "\n", + "ffhq_model_artifact = wandb.use_artifact(\n", + " config.ffhq_models_artifact, type=\"model\"\n", + ")\n", + "ffhq_model_artifact_dir = ffhq_model_artifact.download()\n", + "ffhq_model_file = os.path.join(ffhq_model_artifact_dir, \"ffhq.pt\")\n", + "\n", + "segmentation_model_artifact = wandb.use_artifact(\n", + " config.segmentation_models_artifact, type=\"model\"\n", + ")\n", + "segmentation_model_artifact_dir = segmentation_model_artifact.download()\n", + "segmentation_model_file = os.path.join(\n", + " segmentation_model_artifact_dir, \"seg.pth\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading StyleGAN2 from checkpoint: ./artifacts/ffhq:v0/ffhq.pt\n", + "Setting up Perceptual loss...\n", + "Loading model from: /home/paperspace/Workspace/Barbershop/losses/lpips/weights/v0.1/vgg.pth\n", + "...[net-lin [vgg]] initialized\n", + "...Done\n" + ] + } + ], + "source": [ + "device = \"cuda:0\" if torch.cuda.is_available() else \"cpu\"\n", + "\n", + "ii2s = Embedding(config, checkpoint_file=ffhq_model_file).to(device=device)\n", + "\n", + "identity_image = os.path.join(images_artifact_dir, config.identity_image)\n", + "structure_image = os.path.join(images_artifact_dir, config.structure_image)\n", + "appearance_image = os.path.join(images_artifact_dir, config.appearance_image)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading StyleGAN2 from checkpoint: ./artifacts/ffhq:v0/ffhq.pt\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " \r" + ] + } + ], + "source": [ + "align = Alignment(\n", + " config,\n", + " ffhq_checkpoint_file=ffhq_model_file,\n", + " segmentation_checkpoint_file=segmentation_model_file,\n", + ").to(device=device)\n", + "aligned_image = align.align_images(\n", + " identity_image,\n", + " structure_image,\n", + " sign=config.sign,\n", + " align_more_region=False,\n", + " smooth=config.smooth,\n", + ")\n", + "if structure_image != appearance_image:\n", + " aligned_image = align.align_images(\n", + " identity_image,\n", + " appearance_image,\n", + " sign=config.sign,\n", + " align_more_region=False,\n", + " smooth=config.smooth,\n", + " save_intermediate=False,\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading StyleGAN2 from checkpoint: ./artifacts/ffhq:v0/ffhq.pt\n", + "Setting up Perceptual loss...\n", + "Loading model from: /home/paperspace/Workspace/Barbershop/losses/masked_lpips/weights/v0.1/vgg.pth\n", + "...[net-lin [vgg]] initialized\n", + "...Done\n", + "Setting up Perceptual loss...\n", + "Loading model from: /home/paperspace/Workspace/Barbershop/losses/masked_lpips/weights/v0.1/vgg.pth\n", + "...[net-lin [vgg]] initialized\n", + "...Done\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " \r" + ] + } + ], + "source": [ + "blend = Blending(\n", + " config,\n", + " ffhq_checkpoint_file=ffhq_model_file,\n", + " segmentation_checkpoint_file=segmentation_model_file,\n", + ").to(device=device)\n", + "blended_image = blend.blend_images(\n", + " identity_image, structure_image, appearance_image, sign=config.sign\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Identity Image')" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(np.array(Image.open(identity_image)))\n", + "plt.title(\"Identity Image\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Structure Image')" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(np.array(Image.open(structure_image)))\n", + "plt.title(\"Structure Image\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.imshow(np.array(Image.open(appearance_image)))\n", + "plt.title(\"Appearance Image\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "aligned_image" + ] + } + ], + "metadata": { + "interpreter": { + "hash": "fff2847cd74d0abab8e7b713e45368b315320c9df162762b3e6d925ce5c86810" + }, + "kernelspec": { + "display_name": "Python 3.7.11 ('Barbershop')", + "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.7.11" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/losses/align_loss.py b/losses/align_loss.py index 261fea8..2991bc3 100644 --- a/losses/align_loss.py +++ b/losses/align_loss.py @@ -1,43 +1,47 @@ import torch from losses.style.style_loss import StyleLoss + class AlignLossBuilder(torch.nn.Module): def __init__(self, opt): super(AlignLossBuilder, self).__init__() self.opt = opt - self.parsed_loss = [[opt.l2_lambda, 'l2'], [opt.percept_lambda, 'percep']] - if opt.device == 'cuda': + self.parsed_loss = [[opt.l2_lambda, "l2"], [opt.percept_lambda, "percep"]] + if opt.device == "cuda": use_gpu = True else: use_gpu = False self.cross_entropy = torch.nn.CrossEntropyLoss() - self.style = StyleLoss(distance="l2", VGG16_ACTIVATIONS_LIST=[3, 8, 15, 22], normalize=False).to(opt.device) + self.style = StyleLoss( + distance="l2", VGG16_ACTIVATIONS_LIST=[3, 8, 15, 22], normalize=False + ).to(opt.device) self.style.eval() - tmp = torch.zeros(16).to(opt.device) tmp[0] = 1 self.cross_entropy_wo_background = torch.nn.CrossEntropyLoss(weight=1 - tmp) self.cross_entropy_only_background = torch.nn.CrossEntropyLoss(weight=tmp) - - def cross_entropy_loss(self, down_seg, target_mask): loss = self.opt.ce_lambda * self.cross_entropy(down_seg, target_mask) return loss - def style_loss(self, im1, im2, mask1, mask2): - loss = self.opt.style_lambda * self.style(im1 * mask1, im2 * mask2, mask1=mask1, mask2=mask2) + loss = self.opt.style_lambda * self.style( + im1 * mask1, im2 * mask2, mask1=mask1, mask2=mask2 + ) return loss - def cross_entropy_loss_wo_background(self, down_seg, target_mask): - loss = self.opt.ce_lambda * self.cross_entropy_wo_background(down_seg, target_mask) + loss = self.opt.ce_lambda * self.cross_entropy_wo_background( + down_seg, target_mask + ) return loss def cross_entropy_loss_only_background(self, down_seg, target_mask): - loss = self.opt.ce_lambda * self.cross_entropy_only_background(down_seg, target_mask) - return loss \ No newline at end of file + loss = self.opt.ce_lambda * self.cross_entropy_only_background( + down_seg, target_mask + ) + return loss diff --git a/losses/blend_loss.py b/losses/blend_loss.py index 0675ca3..bb86b59 100644 --- a/losses/blend_loss.py +++ b/losses/blend_loss.py @@ -3,29 +3,28 @@ import os from losses import masked_lpips + class BlendLossBuilder(torch.nn.Module): def __init__(self, opt): super(BlendLossBuilder, self).__init__() self.opt = opt - self.parsed_loss = [[1.0, 'face'], [1.0, 'hair']] - if opt.device == 'cuda': + self.parsed_loss = [[1.0, "face"], [1.0, "hair"]] + if opt.device == "cuda": use_gpu = True else: use_gpu = False self.face_percept = masked_lpips.PerceptualLoss( - model="net-lin", net="vgg", vgg_blocks=['1', '2', '3'], use_gpu=use_gpu + model="net-lin", net="vgg", vgg_blocks=["1", "2", "3"], use_gpu=use_gpu ) self.face_percept.eval() self.hair_percept = masked_lpips.PerceptualLoss( - model="net-lin", net="vgg", vgg_blocks=['1', '2', '3'], use_gpu=use_gpu + model="net-lin", net="vgg", vgg_blocks=["1", "2", "3"], use_gpu=use_gpu ) self.hair_percept.eval() - - def _loss_face_percept(self, gen_im, ref_im, mask, **kwargs): return self.face_percept(gen_im, ref_im, mask=mask) @@ -34,29 +33,20 @@ def _loss_hair_percept(self, gen_im, ref_im, mask, **kwargs): return self.hair_percept(gen_im, ref_im, mask=mask) - def forward(self, gen_im, im_1, im_3, mask_face, mask_hair): loss = 0 loss_fun_dict = { - 'face': self._loss_face_percept, - 'hair': self._loss_hair_percept, + "face": self._loss_face_percept, + "hair": self._loss_hair_percept, } losses = {} for weight, loss_type in self.parsed_loss: - if loss_type == 'face': - var_dict = { - 'gen_im': gen_im, - 'ref_im': im_1, - 'mask': mask_face - } - elif loss_type == 'hair': - var_dict = { - 'gen_im': gen_im, - 'ref_im': im_3, - 'mask': mask_hair - } + if loss_type == "face": + var_dict = {"gen_im": gen_im, "ref_im": im_1, "mask": mask_face} + elif loss_type == "hair": + var_dict = {"gen_im": gen_im, "ref_im": im_3, "mask": mask_hair} tmp_loss = loss_fun_dict[loss_type](**var_dict) losses[loss_type] = tmp_loss - loss += weight*tmp_loss - return loss, losses \ No newline at end of file + loss += weight * tmp_loss + return loss, losses diff --git a/losses/embedding_loss.py b/losses/embedding_loss.py index 6e5324f..af1068c 100644 --- a/losses/embedding_loss.py +++ b/losses/embedding_loss.py @@ -9,9 +9,9 @@ def __init__(self, opt): super(EmbeddingLossBuilder, self).__init__() self.opt = opt - self.parsed_loss = [[opt.l2_lambda, 'l2'], [opt.percept_lambda, 'percep']] + self.parsed_loss = [[opt.l2_lambda, "l2"], [opt.percept_lambda, "percep"]] self.l2 = torch.nn.MSELoss() - if opt.device == 'cuda': + if opt.device == "cuda": use_gpu = True else: use_gpu = False @@ -19,39 +19,33 @@ def __init__(self, opt): self.percept.eval() # self.percept = VGGLoss() - - - def _loss_l2(self, gen_im, ref_im, **kwargs): return self.l2(gen_im, ref_im) - def _loss_lpips(self, gen_im, ref_im, **kwargs): return self.percept(gen_im, ref_im).sum() - - - def forward(self, ref_im_H,ref_im_L, gen_im_H, gen_im_L): + def forward(self, ref_im_H, ref_im_L, gen_im_H, gen_im_L): loss = 0 loss_fun_dict = { - 'l2': self._loss_l2, - 'percep': self._loss_lpips, + "l2": self._loss_l2, + "percep": self._loss_lpips, } losses = {} for weight, loss_type in self.parsed_loss: - if loss_type == 'l2': + if loss_type == "l2": var_dict = { - 'gen_im': gen_im_H, - 'ref_im': ref_im_H, + "gen_im": gen_im_H, + "ref_im": ref_im_H, } - elif loss_type == 'percep': + elif loss_type == "percep": var_dict = { - 'gen_im': gen_im_L, - 'ref_im': ref_im_L, + "gen_im": gen_im_L, + "ref_im": ref_im_L, } tmp_loss = loss_fun_dict[loss_type](**var_dict) losses[loss_type] = tmp_loss - loss += weight*tmp_loss - return loss, losses \ No newline at end of file + loss += weight * tmp_loss + return loss, losses diff --git a/losses/lpips/__init__.py b/losses/lpips/__init__.py index 2dd73e7..47a8fb0 100644 --- a/losses/lpips/__init__.py +++ b/losses/lpips/__init__.py @@ -1,4 +1,3 @@ - from __future__ import absolute_import from __future__ import division from __future__ import print_function @@ -10,18 +9,34 @@ from ..lpips import dist_model + class PerceptualLoss(torch.nn.Module): - def __init__(self, model='net-lin', net='alex', colorspace='rgb', spatial=False, use_gpu=True, gpu_ids=[0]): # VGG using our perceptually-learned weights (LPIPS metric) - # def __init__(self, model='net', net='vgg', use_gpu=True): # "default" way of using VGG as a perceptual loss + def __init__( + self, + model="net-lin", + net="alex", + colorspace="rgb", + spatial=False, + use_gpu=True, + gpu_ids=[0], + ): # VGG using our perceptually-learned weights (LPIPS metric) + # def __init__(self, model='net', net='vgg', use_gpu=True): # "default" way of using VGG as a perceptual loss super(PerceptualLoss, self).__init__() - print('Setting up Perceptual loss...') + print("Setting up Perceptual loss...") self.use_gpu = use_gpu self.spatial = spatial self.gpu_ids = gpu_ids self.model = dist_model.DistModel() - self.model.initialize(model=model, net=net, use_gpu=use_gpu, colorspace=colorspace, spatial=self.spatial, gpu_ids=gpu_ids) - print('...[%s] initialized'%self.model.name()) - print('...Done') + self.model.initialize( + model=model, + net=net, + use_gpu=use_gpu, + colorspace=colorspace, + spatial=self.spatial, + gpu_ids=gpu_ids, + ) + print("...[%s] initialized" % self.model.name()) + print("...Done") def forward(self, pred, target, normalize=False): """ @@ -34,107 +49,127 @@ def forward(self, pred, target, normalize=False): """ if normalize: - target = 2 * target - 1 - pred = 2 * pred - 1 + target = 2 * target - 1 + pred = 2 * pred - 1 return self.model.forward(target, pred) -def normalize_tensor(in_feat,eps=1e-10): - norm_factor = torch.sqrt(torch.sum(in_feat**2,dim=1,keepdim=True)) - return in_feat/(norm_factor+eps) -def l2(p0, p1, range=255.): - return .5*np.mean((p0 / range - p1 / range)**2) +def normalize_tensor(in_feat, eps=1e-10): + norm_factor = torch.sqrt(torch.sum(in_feat**2, dim=1, keepdim=True)) + return in_feat / (norm_factor + eps) + + +def l2(p0, p1, range=255.0): + return 0.5 * np.mean((p0 / range - p1 / range) ** 2) + + +def psnr(p0, p1, peak=255.0): + return 10 * np.log10(peak**2 / np.mean((1.0 * p0 - 1.0 * p1) ** 2)) -def psnr(p0, p1, peak=255.): - return 10*np.log10(peak**2/np.mean((1.*p0-1.*p1)**2)) -def dssim(p0, p1, range=255.): - return (1 - structural_similarity(p0, p1, data_range=range, multichannel=True)) / 2. +def dssim(p0, p1, range=255.0): + return ( + 1 - structural_similarity(p0, p1, data_range=range, multichannel=True) + ) / 2.0 -def rgb2lab(in_img,mean_cent=False): + +def rgb2lab(in_img, mean_cent=False): from skimage import color + img_lab = color.rgb2lab(in_img) - if(mean_cent): - img_lab[:,:,0] = img_lab[:,:,0]-50 + if mean_cent: + img_lab[:, :, 0] = img_lab[:, :, 0] - 50 return img_lab + def tensor2np(tensor_obj): # change dimension of a tensor object into a numpy array - return tensor_obj[0].cpu().float().numpy().transpose((1,2,0)) + return tensor_obj[0].cpu().float().numpy().transpose((1, 2, 0)) + def np2tensor(np_obj): - # change dimenion of np array into tensor array + # change dimenion of np array into tensor array return torch.Tensor(np_obj[:, :, :, np.newaxis].transpose((3, 2, 0, 1))) -def tensor2tensorlab(image_tensor,to_norm=True,mc_only=False): + +def tensor2tensorlab(image_tensor, to_norm=True, mc_only=False): # image tensor to lab tensor from skimage import color img = tensor2im(image_tensor) img_lab = color.rgb2lab(img) - if(mc_only): - img_lab[:,:,0] = img_lab[:,:,0]-50 - if(to_norm and not mc_only): - img_lab[:,:,0] = img_lab[:,:,0]-50 - img_lab = img_lab/100. + if mc_only: + img_lab[:, :, 0] = img_lab[:, :, 0] - 50 + if to_norm and not mc_only: + img_lab[:, :, 0] = img_lab[:, :, 0] - 50 + img_lab = img_lab / 100.0 return np2tensor(img_lab) -def tensorlab2tensor(lab_tensor,return_inbnd=False): + +def tensorlab2tensor(lab_tensor, return_inbnd=False): from skimage import color import warnings + warnings.filterwarnings("ignore") - lab = tensor2np(lab_tensor)*100. - lab[:,:,0] = lab[:,:,0]+50 + lab = tensor2np(lab_tensor) * 100.0 + lab[:, :, 0] = lab[:, :, 0] + 50 - rgb_back = 255.*np.clip(color.lab2rgb(lab.astype('float')),0,1) - if(return_inbnd): + rgb_back = 255.0 * np.clip(color.lab2rgb(lab.astype("float")), 0, 1) + if return_inbnd: # convert back to lab, see if we match - lab_back = color.rgb2lab(rgb_back.astype('uint8')) - mask = 1.*np.isclose(lab_back,lab,atol=2.) - mask = np2tensor(np.prod(mask,axis=2)[:,:,np.newaxis]) - return (im2tensor(rgb_back),mask) + lab_back = color.rgb2lab(rgb_back.astype("uint8")) + mask = 1.0 * np.isclose(lab_back, lab, atol=2.0) + mask = np2tensor(np.prod(mask, axis=2)[:, :, np.newaxis]) + return (im2tensor(rgb_back), mask) else: return im2tensor(rgb_back) + def rgb2lab(input): from skimage import color - return color.rgb2lab(input / 255.) -def tensor2im(image_tensor, imtype=np.uint8, cent=1., factor=255./2.): + return color.rgb2lab(input / 255.0) + + +def tensor2im(image_tensor, imtype=np.uint8, cent=1.0, factor=255.0 / 2.0): image_numpy = image_tensor[0].cpu().float().numpy() image_numpy = (np.transpose(image_numpy, (1, 2, 0)) + cent) * factor return image_numpy.astype(imtype) -def im2tensor(image, imtype=np.uint8, cent=1., factor=255./2.): - return torch.Tensor((image / factor - cent) - [:, :, :, np.newaxis].transpose((3, 2, 0, 1))) + +def im2tensor(image, imtype=np.uint8, cent=1.0, factor=255.0 / 2.0): + return torch.Tensor( + (image / factor - cent)[:, :, :, np.newaxis].transpose((3, 2, 0, 1)) + ) + def tensor2vec(vector_tensor): return vector_tensor.data.cpu().numpy()[:, :, 0, 0] + def voc_ap(rec, prec, use_07_metric=False): - """ ap = voc_ap(rec, prec, [use_07_metric]) + """ap = voc_ap(rec, prec, [use_07_metric]) Compute VOC AP given precision and recall. If use_07_metric is true, uses the VOC 07 11 point method (default:False). """ if use_07_metric: # 11 point metric - ap = 0. - for t in np.arange(0., 1.1, 0.1): + ap = 0.0 + for t in np.arange(0.0, 1.1, 0.1): if np.sum(rec >= t) == 0: p = 0 else: p = np.max(prec[rec >= t]) - ap = ap + p / 11. + ap = ap + p / 11.0 else: # correct AP calculation # first append sentinel values at the end - mrec = np.concatenate(([0.], rec, [1.])) - mpre = np.concatenate(([0.], prec, [0.])) + mrec = np.concatenate(([0.0], rec, [1.0])) + mpre = np.concatenate(([0.0], prec, [0.0])) # compute the precision envelope for i in range(mpre.size - 1, 0, -1): @@ -148,13 +183,16 @@ def voc_ap(rec, prec, use_07_metric=False): ap = np.sum((mrec[i + 1] - mrec[i]) * mpre[i + 1]) return ap -def tensor2im(image_tensor, imtype=np.uint8, cent=1., factor=255./2.): -# def tensor2im(image_tensor, imtype=np.uint8, cent=1., factor=1.): + +def tensor2im(image_tensor, imtype=np.uint8, cent=1.0, factor=255.0 / 2.0): + # def tensor2im(image_tensor, imtype=np.uint8, cent=1., factor=1.): image_numpy = image_tensor[0].cpu().float().numpy() image_numpy = (np.transpose(image_numpy, (1, 2, 0)) + cent) * factor return image_numpy.astype(imtype) -def im2tensor(image, imtype=np.uint8, cent=1., factor=255./2.): -# def im2tensor(image, imtype=np.uint8, cent=1., factor=1.): - return torch.Tensor((image / factor - cent) - [:, :, :, np.newaxis].transpose((3, 2, 0, 1))) + +def im2tensor(image, imtype=np.uint8, cent=1.0, factor=255.0 / 2.0): + # def im2tensor(image, imtype=np.uint8, cent=1., factor=1.): + return torch.Tensor( + (image / factor - cent)[:, :, :, np.newaxis].transpose((3, 2, 0, 1)) + ) diff --git a/losses/lpips/base_model.py b/losses/lpips/base_model.py index 8de1d16..20b3b34 100644 --- a/losses/lpips/base_model.py +++ b/losses/lpips/base_model.py @@ -5,12 +5,13 @@ from pdb import set_trace as st from IPython import embed -class BaseModel(): + +class BaseModel: def __init__(self): - pass; - + pass + def name(self): - return 'BaseModel' + return "BaseModel" def initialize(self, use_gpu=True, gpu_ids=[0]): self.use_gpu = use_gpu @@ -36,15 +37,15 @@ def save(self, label): # helper saving function that can be used by subclasses def save_network(self, network, path, network_label, epoch_label): - save_filename = '%s_net_%s.pth' % (epoch_label, network_label) + save_filename = "%s_net_%s.pth" % (epoch_label, network_label) save_path = os.path.join(path, save_filename) torch.save(network.state_dict(), save_path) # helper loading function that can be used by subclasses def load_network(self, network, network_label, epoch_label): - save_filename = '%s_net_%s.pth' % (epoch_label, network_label) + save_filename = "%s_net_%s.pth" % (epoch_label, network_label) save_path = os.path.join(self.save_dir, save_filename) - print('Loading network from %s'%save_path) + print("Loading network from %s" % save_path) network.load_state_dict(torch.load(save_path)) def update_learning_rate(): @@ -54,5 +55,11 @@ def get_image_paths(self): return self.image_paths def save_done(self, flag=False): - np.save(os.path.join(self.save_dir, 'done_flag'),flag) - np.savetxt(os.path.join(self.save_dir, 'done_flag'),[flag,],fmt='%i') + np.save(os.path.join(self.save_dir, "done_flag"), flag) + np.savetxt( + os.path.join(self.save_dir, "done_flag"), + [ + flag, + ], + fmt="%i", + ) diff --git a/losses/lpips/dist_model.py b/losses/lpips/dist_model.py index 6c69380..45caa2b 100644 --- a/losses/lpips/dist_model.py +++ b/losses/lpips/dist_model.py @@ -1,4 +1,3 @@ - from __future__ import absolute_import import sys @@ -21,14 +20,29 @@ from . import networks_basic as networks from losses import lpips as util + class DistModel(BaseModel): def name(self): return self.model_name - def initialize(self, model='net-lin', net='alex', colorspace='Lab', pnet_rand=False, pnet_tune=False, model_path=None, - use_gpu=True, printNet=False, spatial=False, - is_train=False, lr=.0001, beta1=0.5, version='0.1', gpu_ids=[0]): - ''' + def initialize( + self, + model="net-lin", + net="alex", + colorspace="Lab", + pnet_rand=False, + pnet_tune=False, + model_path=None, + use_gpu=True, + printNet=False, + spatial=False, + is_train=False, + lr=0.0001, + beta1=0.5, + version="0.1", + gpu_ids=[0], + ): + """ INPUTS model - ['net-lin'] for linearly calibrated network ['net'] for off-the-shelf network @@ -48,7 +62,7 @@ def initialize(self, model='net-lin', net='alex', colorspace='Lab', pnet_rand=Fa beta1 - float - initial momentum term for adam version - 0.1 for latest, 0.0 was original (with a bug) gpu_ids - int array - [0] by default, gpus to use - ''' + """ BaseModel.initialize(self, use_gpu=use_gpu, gpu_ids=gpu_ids) self.model = model @@ -56,63 +70,83 @@ def initialize(self, model='net-lin', net='alex', colorspace='Lab', pnet_rand=Fa self.is_train = is_train self.spatial = spatial self.gpu_ids = gpu_ids - self.model_name = '%s [%s]'%(model,net) - - if(self.model == 'net-lin'): # pretrained net + linear layer - self.net = networks.PNetLin(pnet_rand=pnet_rand, pnet_tune=pnet_tune, pnet_type=net, - use_dropout=True, spatial=spatial, version=version, lpips=True) + self.model_name = "%s [%s]" % (model, net) + + if self.model == "net-lin": # pretrained net + linear layer + self.net = networks.PNetLin( + pnet_rand=pnet_rand, + pnet_tune=pnet_tune, + pnet_type=net, + use_dropout=True, + spatial=spatial, + version=version, + lpips=True, + ) kw = {} if not use_gpu: - kw['map_location'] = 'cpu' - if(model_path is None): + kw["map_location"] = "cpu" + if model_path is None: import inspect - model_path = os.path.abspath(os.path.join(inspect.getfile(self.initialize), '..', 'weights/v%s/%s.pth'%(version,net))) - if(not is_train): - print('Loading model from: %s'%model_path) + model_path = os.path.abspath( + os.path.join( + inspect.getfile(self.initialize), + "..", + "weights/v%s/%s.pth" % (version, net), + ) + ) + + if not is_train: + print("Loading model from: %s" % model_path) self.net.load_state_dict(torch.load(model_path, **kw), strict=False) - elif(self.model=='net'): # pretrained network + elif self.model == "net": # pretrained network self.net = networks.PNetLin(pnet_rand=pnet_rand, pnet_type=net, lpips=False) - elif(self.model in ['L2','l2']): - self.net = networks.L2(use_gpu=use_gpu,colorspace=colorspace) # not really a network, only for testing - self.model_name = 'L2' - elif(self.model in ['DSSIM','dssim','SSIM','ssim']): - self.net = networks.DSSIM(use_gpu=use_gpu,colorspace=colorspace) - self.model_name = 'SSIM' + elif self.model in ["L2", "l2"]: + self.net = networks.L2( + use_gpu=use_gpu, colorspace=colorspace + ) # not really a network, only for testing + self.model_name = "L2" + elif self.model in ["DSSIM", "dssim", "SSIM", "ssim"]: + self.net = networks.DSSIM(use_gpu=use_gpu, colorspace=colorspace) + self.model_name = "SSIM" else: raise ValueError("Model [%s] not recognized." % self.model) self.parameters = list(self.net.parameters()) - if self.is_train: # training mode + if self.is_train: # training mode # extra network on top to go from distances (d0,d1) => predicted human judgment (h*) self.rankLoss = networks.BCERankingLoss() self.parameters += list(self.rankLoss.net.parameters()) self.lr = lr self.old_lr = lr - self.optimizer_net = torch.optim.Adam(self.parameters, lr=lr, betas=(beta1, 0.999)) - else: # test mode + self.optimizer_net = torch.optim.Adam( + self.parameters, lr=lr, betas=(beta1, 0.999) + ) + else: # test mode self.net.eval() - if(use_gpu): + if use_gpu: self.net.to(gpu_ids[0]) self.net = torch.nn.DataParallel(self.net, device_ids=gpu_ids) - if(self.is_train): - self.rankLoss = self.rankLoss.to(device=gpu_ids[0]) # just put this on GPU0 + if self.is_train: + self.rankLoss = self.rankLoss.to( + device=gpu_ids[0] + ) # just put this on GPU0 - if(printNet): - print('---------- Networks initialized -------------') + if printNet: + print("---------- Networks initialized -------------") networks.print_network(self.net) - print('-----------------------------------------------') + print("-----------------------------------------------") def forward(self, in0, in1, retPerLayer=False): - ''' Function computes the distance between image patches in0 and in1 + """Function computes the distance between image patches in0 and in1 INPUTS in0, in1 - torch.Tensor object of shape Nx3xXxY - image patch scaled to [-1,1] OUTPUT computed distances between in0 and in1 - ''' + """ return self.net.forward(in0, in1, retPerLayer=retPerLayer) @@ -126,51 +160,54 @@ def optimize_parameters(self): def clamp_weights(self): for module in self.net.modules(): - if(hasattr(module, 'weight') and module.kernel_size==(1,1)): - module.weight.data = torch.clamp(module.weight.data,min=0) + if hasattr(module, "weight") and module.kernel_size == (1, 1): + module.weight.data = torch.clamp(module.weight.data, min=0) def set_input(self, data): - self.input_ref = data['ref'] - self.input_p0 = data['p0'] - self.input_p1 = data['p1'] - self.input_judge = data['judge'] + self.input_ref = data["ref"] + self.input_p0 = data["p0"] + self.input_p1 = data["p1"] + self.input_judge = data["judge"] - if(self.use_gpu): + if self.use_gpu: self.input_ref = self.input_ref.to(device=self.gpu_ids[0]) self.input_p0 = self.input_p0.to(device=self.gpu_ids[0]) self.input_p1 = self.input_p1.to(device=self.gpu_ids[0]) self.input_judge = self.input_judge.to(device=self.gpu_ids[0]) - self.var_ref = Variable(self.input_ref,requires_grad=True) - self.var_p0 = Variable(self.input_p0,requires_grad=True) - self.var_p1 = Variable(self.input_p1,requires_grad=True) + self.var_ref = Variable(self.input_ref, requires_grad=True) + self.var_p0 = Variable(self.input_p0, requires_grad=True) + self.var_p1 = Variable(self.input_p1, requires_grad=True) - def forward_train(self): # run forward pass + def forward_train(self): # run forward pass # print(self.net.module.scaling_layer.shift) # print(torch.norm(self.net.module.net.slice1[0].weight).item(), torch.norm(self.net.module.lin0.model[1].weight).item()) self.d0 = self.forward(self.var_ref, self.var_p0) self.d1 = self.forward(self.var_ref, self.var_p1) - self.acc_r = self.compute_accuracy(self.d0,self.d1,self.input_judge) + self.acc_r = self.compute_accuracy(self.d0, self.d1, self.input_judge) - self.var_judge = Variable(1.*self.input_judge).view(self.d0.size()) + self.var_judge = Variable(1.0 * self.input_judge).view(self.d0.size()) - self.loss_total = self.rankLoss.forward(self.d0, self.d1, self.var_judge*2.-1.) + self.loss_total = self.rankLoss.forward( + self.d0, self.d1, self.var_judge * 2.0 - 1.0 + ) return self.loss_total def backward_train(self): torch.mean(self.loss_total).backward() - def compute_accuracy(self,d0,d1,judge): - ''' d0, d1 are Variables, judge is a Tensor ''' - d1_lt_d0 = (d1 %f' % (type,self.old_lr, lr)) + print("update lr [%s] decay: %f -> %f" % (type, self.old_lr, lr)) self.old_lr = lr -def score_2afc_dataset(data_loader, func, name=''): - ''' Function computes Two Alternative Forced Choice (2AFC) score using + +def score_2afc_dataset(data_loader, func, name=""): + """Function computes Two Alternative Forced Choice (2AFC) score using distance function 'func' in dataset 'data_loader' INPUTS data_loader - CustomDatasetDataLoader object - contains a TwoAFCDataset inside @@ -219,33 +257,34 @@ def score_2afc_dataset(data_loader, func, name=''): OUTPUTS [0] - 2AFC score in [0,1], fraction of time func agrees with human evaluators [1] - dictionary with following elements - d0s,d1s - N arrays containing distances between reference patch to perturbed patches + d0s,d1s - N arrays containing distances between reference patch to perturbed patches gts - N array in [0,1], preferred patch selected by human evaluators (closer to "0" for left patch p0, "1" for right patch p1, "0.6" means 60pct people preferred right patch, 40pct preferred left) scores - N array in [0,1], corresponding to what percentage function agreed with humans CONSTS N - number of test triplets in data_loader - ''' + """ d0s = [] d1s = [] gts = [] for data in tqdm(data_loader.load_data(), desc=name): - d0s+=func(data['ref'],data['p0']).data.cpu().numpy().flatten().tolist() - d1s+=func(data['ref'],data['p1']).data.cpu().numpy().flatten().tolist() - gts+=data['judge'].cpu().numpy().flatten().tolist() + d0s += func(data["ref"], data["p0"]).data.cpu().numpy().flatten().tolist() + d1s += func(data["ref"], data["p1"]).data.cpu().numpy().flatten().tolist() + gts += data["judge"].cpu().numpy().flatten().tolist() d0s = np.array(d0s) d1s = np.array(d1s) gts = np.array(gts) - scores = (d0s1: + if ctx.world_size > 1: # get global batch size if equal_batches: batch_size *= ctx.world_size else: dist.all_reduce(batch_size, dist.ReduceOp.SUM) - ctx.factor = x.shape[0]/float(batch_size.item()) + ctx.factor = x.shape[0] / float(batch_size.item()) mean_all = mean.clone() * ctx.factor dist.all_reduce(mean_all, dist.ReduceOp.SUM) @@ -180,8 +212,10 @@ def forward(cls, ctx, x, weight, bias, running_mean, running_var, # Update running stats running_mean.mul_((1 - ctx.momentum)).add_(ctx.momentum * mean) - count = batch_size.item() * x.view(x.shape[0],x.shape[1],-1).shape[-1] - running_var.mul_((1 - ctx.momentum)).add_(ctx.momentum * var * (float(count) / (count - 1))) + count = batch_size.item() * x.view(x.shape[0], x.shape[1], -1).shape[-1] + running_var.mul_((1 - ctx.momentum)).add_( + ctx.momentum * var * (float(count) / (count - 1)) + ) # Mark in-place modified tensors ctx.mark_dirty(x, running_mean, running_var) @@ -212,7 +246,7 @@ def backward(ctx, dz): edz_local = edz.clone() eydz_local = eydz.clone() - if ctx.world_size>1: + if ctx.world_size > 1: edz *= ctx.factor dist.all_reduce(edz, dist.ReduceOp.SUM) @@ -228,7 +262,15 @@ def backward(ctx, dz): return dx, dweight, dbias, None, None, None, None, None, None, None + inplace_abn = InPlaceABN.apply inplace_abn_sync = InPlaceABNSync.apply -__all__ = ["inplace_abn", "inplace_abn_sync", "ACT_RELU", "ACT_LEAKY_RELU", "ACT_ELU", "ACT_NONE"] +__all__ = [ + "inplace_abn", + "inplace_abn_sync", + "ACT_RELU", + "ACT_LEAKY_RELU", + "ACT_ELU", + "ACT_NONE", +] diff --git a/models/face_parsing/modules/misc.py b/models/face_parsing/modules/misc.py index 3c50b69..2fbacbc 100644 --- a/models/face_parsing/modules/misc.py +++ b/models/face_parsing/modules/misc.py @@ -2,6 +2,7 @@ import torch import torch.distributed as dist + class GlobalAvgPool2d(nn.Module): def __init__(self): """Global average pooling over the input's spatial dimensions""" @@ -11,11 +12,11 @@ def forward(self, inputs): in_size = inputs.size() return inputs.view((in_size[0], in_size[1], -1)).mean(dim=2) + class SingleGPU(nn.Module): def __init__(self, module): super(SingleGPU, self).__init__() - self.module=module + self.module = module def forward(self, input): return self.module(input.cuda(non_blocking=True)) - diff --git a/models/face_parsing/modules/residual.py b/models/face_parsing/modules/residual.py index b7d51ad..9bfa65e 100644 --- a/models/face_parsing/modules/residual.py +++ b/models/face_parsing/modules/residual.py @@ -6,14 +6,16 @@ class IdentityResidualBlock(nn.Module): - def __init__(self, - in_channels, - channels, - stride=1, - dilation=1, - groups=1, - norm_act=ABN, - dropout=None): + def __init__( + self, + in_channels, + channels, + stride=1, + dilation=1, + groups=1, + norm_act=ABN, + dropout=None, + ): """Configurable identity-mapping residual block Parameters @@ -50,29 +52,77 @@ def __init__(self, self.bn1 = norm_act(in_channels) if not is_bottleneck: layers = [ - ("conv1", nn.Conv2d(in_channels, channels[0], 3, stride=stride, padding=dilation, bias=False, - dilation=dilation)), + ( + "conv1", + nn.Conv2d( + in_channels, + channels[0], + 3, + stride=stride, + padding=dilation, + bias=False, + dilation=dilation, + ), + ), ("bn2", norm_act(channels[0])), - ("conv2", nn.Conv2d(channels[0], channels[1], 3, stride=1, padding=dilation, bias=False, - dilation=dilation)) + ( + "conv2", + nn.Conv2d( + channels[0], + channels[1], + 3, + stride=1, + padding=dilation, + bias=False, + dilation=dilation, + ), + ), ] if dropout is not None: layers = layers[0:2] + [("dropout", dropout())] + layers[2:] else: layers = [ - ("conv1", nn.Conv2d(in_channels, channels[0], 1, stride=stride, padding=0, bias=False)), + ( + "conv1", + nn.Conv2d( + in_channels, + channels[0], + 1, + stride=stride, + padding=0, + bias=False, + ), + ), ("bn2", norm_act(channels[0])), - ("conv2", nn.Conv2d(channels[0], channels[1], 3, stride=1, padding=dilation, bias=False, - groups=groups, dilation=dilation)), + ( + "conv2", + nn.Conv2d( + channels[0], + channels[1], + 3, + stride=1, + padding=dilation, + bias=False, + groups=groups, + dilation=dilation, + ), + ), ("bn3", norm_act(channels[1])), - ("conv3", nn.Conv2d(channels[1], channels[2], 1, stride=1, padding=0, bias=False)) + ( + "conv3", + nn.Conv2d( + channels[1], channels[2], 1, stride=1, padding=0, bias=False + ), + ), ] if dropout is not None: layers = layers[0:4] + [("dropout", dropout())] + layers[4:] self.convs = nn.Sequential(OrderedDict(layers)) if need_proj_conv: - self.proj_conv = nn.Conv2d(in_channels, channels[-1], 1, stride=stride, padding=0, bias=False) + self.proj_conv = nn.Conv2d( + in_channels, channels[-1], 1, stride=stride, padding=0, bias=False + ) def forward(self, x): if hasattr(self, "proj_conv"): diff --git a/models/face_parsing/resnet.py b/models/face_parsing/resnet.py index aa2bf95..e74be59 100644 --- a/models/face_parsing/resnet.py +++ b/models/face_parsing/resnet.py @@ -8,13 +8,14 @@ # from modules.bn import InPlaceABNSync as BatchNorm2d -resnet18_url = 'https://download.pytorch.org/models/resnet18-5c106cde.pth' +resnet18_url = "https://download.pytorch.org/models/resnet18-5c106cde.pth" def conv3x3(in_planes, out_planes, stride=1): """3x3 convolution with padding""" - return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride, - padding=1, bias=False) + return nn.Conv2d( + in_planes, out_planes, kernel_size=3, stride=stride, padding=1, bias=False + ) class BasicBlock(nn.Module): @@ -28,10 +29,9 @@ def __init__(self, in_chan, out_chan, stride=1): self.downsample = None if in_chan != out_chan or stride != 1: self.downsample = nn.Sequential( - nn.Conv2d(in_chan, out_chan, - kernel_size=1, stride=stride, bias=False), + nn.Conv2d(in_chan, out_chan, kernel_size=1, stride=stride, bias=False), nn.BatchNorm2d(out_chan), - ) + ) def forward(self, x): residual = self.conv1(x) @@ -50,7 +50,7 @@ def forward(self, x): def create_layer_basic(in_chan, out_chan, bnum, stride=1): layers = [BasicBlock(in_chan, out_chan, stride=stride)] - for i in range(bnum-1): + for i in range(bnum - 1): layers.append(BasicBlock(out_chan, out_chan, stride=1)) return nn.Sequential(*layers) @@ -58,8 +58,7 @@ def create_layer_basic(in_chan, out_chan, bnum, stride=1): class Resnet18(nn.Module): def __init__(self): super(Resnet18, self).__init__() - self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, - bias=False) + self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False) self.bn1 = nn.BatchNorm2d(64) self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1) self.layer1 = create_layer_basic(64, 64, bnum=2, stride=1) @@ -74,16 +73,17 @@ def forward(self, x): x = self.maxpool(x) x = self.layer1(x) - feat8 = self.layer2(x) # 1/8 - feat16 = self.layer3(feat8) # 1/16 - feat32 = self.layer4(feat16) # 1/32 + feat8 = self.layer2(x) # 1/8 + feat16 = self.layer3(feat8) # 1/16 + feat32 = self.layer4(feat16) # 1/32 return feat8, feat16, feat32 def init_weight(self): state_dict = modelzoo.load_url(resnet18_url) self_state_dict = self.state_dict() for k, v in state_dict.items(): - if 'fc' in k: continue + if "fc" in k: + continue self_state_dict.update({k: v}) self.load_state_dict(self_state_dict) @@ -94,7 +94,7 @@ def get_params(self): wd_params.append(module.weight) if not module.bias is None: nowd_params.append(module.bias) - elif isinstance(module, nn.BatchNorm2d): + elif isinstance(module, nn.BatchNorm2d): nowd_params += list(module.parameters()) return wd_params, nowd_params diff --git a/models/face_parsing/transform.py b/models/face_parsing/transform.py index a28e9d5..d24f55d 100644 --- a/models/face_parsing/transform.py +++ b/models/face_parsing/transform.py @@ -7,18 +7,20 @@ import random import numpy as np + class RandomCrop(object): def __init__(self, size, *args, **kwargs): self.size = size def __call__(self, im_lb): - im = im_lb['im'] - lb = im_lb['lb'] + im = im_lb["im"] + lb = im_lb["lb"] assert im.size == lb.size W, H = self.size w, h = im.size - if (W, H) == (w, h): return dict(im=im, lb=lb) + if (W, H) == (w, h): + return dict(im=im, lb=lb) if w < W or h < H: scale = float(W) / w if w < h else float(H) / h w, h = int(scale * w + 1), int(scale * h + 1) @@ -26,10 +28,7 @@ def __call__(self, im_lb): lb = lb.resize((w, h), Image.NEAREST) sw, sh = random.random() * (w - W), random.random() * (h - H) crop = int(sw), int(sh), int(sw) + W, int(sh) + H - return dict( - im = im.crop(crop), - lb = lb.crop(crop) - ) + return dict(im=im.crop(crop), lb=lb.crop(crop)) class HorizontalFlip(object): @@ -40,9 +39,8 @@ def __call__(self, im_lb): if random.random() > self.p: return im_lb else: - im = im_lb['im'] - lb = im_lb['lb'] - + im = im_lb["im"] + lb = im_lb["lb"] flip_lb = np.array(lb) # flip_lb[lb == 2] = 3 @@ -52,47 +50,52 @@ def __call__(self, im_lb): # flip_lb[lb == 7] = 8 # flip_lb[lb == 8] = 7 flip_lb = Image.fromarray(flip_lb) - return dict(im = im.transpose(Image.FLIP_LEFT_RIGHT), - lb = flip_lb.transpose(Image.FLIP_LEFT_RIGHT), - ) + return dict( + im=im.transpose(Image.FLIP_LEFT_RIGHT), + lb=flip_lb.transpose(Image.FLIP_LEFT_RIGHT), + ) class RandomScale(object): - def __init__(self, scales=(1, ), *args, **kwargs): + def __init__(self, scales=(1,), *args, **kwargs): self.scales = scales def __call__(self, im_lb): - im = im_lb['im'] - lb = im_lb['lb'] + im = im_lb["im"] + lb = im_lb["lb"] W, H = im.size scale = random.choice(self.scales) w, h = int(W * scale), int(H * scale) - return dict(im = im.resize((w, h), Image.BILINEAR), - lb = lb.resize((w, h), Image.NEAREST), - ) + return dict( + im=im.resize((w, h), Image.BILINEAR), + lb=lb.resize((w, h), Image.NEAREST), + ) class ColorJitter(object): - def __init__(self, brightness=None, contrast=None, saturation=None, *args, **kwargs): - if not brightness is None and brightness>0: - self.brightness = [max(1-brightness, 0), 1+brightness] - if not contrast is None and contrast>0: - self.contrast = [max(1-contrast, 0), 1+contrast] - if not saturation is None and saturation>0: - self.saturation = [max(1-saturation, 0), 1+saturation] + def __init__( + self, brightness=None, contrast=None, saturation=None, *args, **kwargs + ): + if not brightness is None and brightness > 0: + self.brightness = [max(1 - brightness, 0), 1 + brightness] + if not contrast is None and contrast > 0: + self.contrast = [max(1 - contrast, 0), 1 + contrast] + if not saturation is None and saturation > 0: + self.saturation = [max(1 - saturation, 0), 1 + saturation] def __call__(self, im_lb): - im = im_lb['im'] - lb = im_lb['lb'] + im = im_lb["im"] + lb = im_lb["lb"] r_brightness = random.uniform(self.brightness[0], self.brightness[1]) r_contrast = random.uniform(self.contrast[0], self.contrast[1]) r_saturation = random.uniform(self.saturation[0], self.saturation[1]) im = ImageEnhance.Brightness(im).enhance(r_brightness) im = ImageEnhance.Contrast(im).enhance(r_contrast) im = ImageEnhance.Color(im).enhance(r_saturation) - return dict(im = im, - lb = lb, - ) + return dict( + im=im, + lb=lb, + ) class MultiScale(object): @@ -101,7 +104,7 @@ def __init__(self, scales): def __call__(self, img): W, H = img.size - sizes = [(int(W*ratio), int(H*ratio)) for ratio in self.scales] + sizes = [(int(W * ratio), int(H * ratio)) for ratio in self.scales] imgs = [] [imgs.append(img.resize(size, Image.BILINEAR)) for size in sizes] return imgs @@ -117,11 +120,9 @@ def __call__(self, im_lb): return im_lb - - -if __name__ == '__main__': - flip = HorizontalFlip(p = 1) +if __name__ == "__main__": + flip = HorizontalFlip(p=1) crop = RandomCrop((321, 321)) rscales = RandomScale((0.75, 1.0, 1.5, 1.75, 2.0)) - img = Image.open('data/img.jpg') - lb = Image.open('data/label.png') + img = Image.open("data/img.jpg") + lb = Image.open("data/label.png") diff --git a/models/optimizer/ClampOptimizer.py b/models/optimizer/ClampOptimizer.py index cfcb907..aa53ec6 100644 --- a/models/optimizer/ClampOptimizer.py +++ b/models/optimizer/ClampOptimizer.py @@ -3,28 +3,21 @@ from torch.optim import Optimizer import numpy as np + class ClampOptimizer(Optimizer): def __init__(self, optimizer, params, **kwargs): self.opt = optimizer(params, **kwargs) self.params = params - - - @torch.no_grad() def step(self, closure=None): loss = self.opt.step(closure) - for param in self.params: tmp_latent_norm = torch.clamp(param.data, 0, 1) param.data.add_(tmp_latent_norm - param.data) - return loss - def zero_grad(self): self.opt.zero_grad() - - diff --git a/models/stylegan2/model.py b/models/stylegan2/model.py index 2fdd5ac..bd4f3c8 100644 --- a/models/stylegan2/model.py +++ b/models/stylegan2/model.py @@ -10,15 +10,17 @@ from models.stylegan2.op import FusedLeakyReLU, fused_leaky_relu, upfirdn2d import torchvision + toPIL = torchvision.transforms.ToPILImage() import numpy as np + class PixelNorm(nn.Module): def __init__(self): super().__init__() def forward(self, input): - return input * torch.rsqrt(torch.mean(input ** 2, dim=1, keepdim=True) + 1e-8) + return input * torch.rsqrt(torch.mean(input**2, dim=1, keepdim=True) + 1e-8) def make_kernel(k): @@ -37,8 +39,8 @@ def __init__(self, kernel, factor=2): super().__init__() self.factor = factor - kernel = make_kernel(kernel) * (factor ** 2) - self.register_buffer('kernel', kernel) + kernel = make_kernel(kernel) * (factor**2) + self.register_buffer("kernel", kernel) p = kernel.shape[0] - factor @@ -59,7 +61,7 @@ def __init__(self, kernel, factor=2): self.factor = factor kernel = make_kernel(kernel) - self.register_buffer('kernel', kernel) + self.register_buffer("kernel", kernel) p = kernel.shape[0] - factor @@ -81,9 +83,9 @@ def __init__(self, kernel, pad, upsample_factor=1): kernel = make_kernel(kernel) if upsample_factor > 1: - kernel = kernel * (upsample_factor ** 2) + kernel = kernel * (upsample_factor**2) - self.register_buffer('kernel', kernel) + self.register_buffer("kernel", kernel) self.pad = pad @@ -102,7 +104,7 @@ def __init__( self.weight = nn.Parameter( torch.randn(out_channel, in_channel, kernel_size, kernel_size) ) - self.scale = 1 / math.sqrt(in_channel * kernel_size ** 2) + self.scale = 1 / math.sqrt(in_channel * kernel_size**2) self.stride = stride self.padding = padding @@ -126,8 +128,8 @@ def forward(self, input): def __repr__(self): return ( - f'{self.__class__.__name__}({self.weight.shape[1]}, {self.weight.shape[0]},' - f' {self.weight.shape[2]}, stride={self.stride}, padding={self.padding})' + f"{self.__class__.__name__}({self.weight.shape[1]}, {self.weight.shape[0]}," + f" {self.weight.shape[2]}, stride={self.stride}, padding={self.padding})" ) @@ -164,7 +166,7 @@ def forward(self, input): def __repr__(self): return ( - f'{self.__class__.__name__}({self.weight.shape[1]}, {self.weight.shape[0]})' + f"{self.__class__.__name__}({self.weight.shape[1]}, {self.weight.shape[0]})" ) @@ -217,7 +219,7 @@ def __init__( self.blur = Blur(blur_kernel, pad=(pad0, pad1)) - fan_in = in_channel * kernel_size ** 2 + fan_in = in_channel * kernel_size**2 self.scale = 1 / math.sqrt(fan_in) self.padding = kernel_size // 2 @@ -231,8 +233,8 @@ def __init__( def __repr__(self): return ( - f'{self.__class__.__name__}({self.in_channel}, {self.out_channel}, {self.kernel_size}, ' - f'upsample={self.upsample}, downsample={self.downsample})' + f"{self.__class__.__name__}({self.in_channel}, {self.out_channel}, {self.kernel_size}, " + f"upsample={self.upsample}, downsample={self.downsample})" ) def forward(self, input, style): @@ -386,7 +388,7 @@ def __init__( for i in range(n_mlp): layers.append( EqualLinear( - style_dim, style_dim, lr_mul=lr_mlp, activation='fused_lrelu' + style_dim, style_dim, lr_mul=lr_mlp, activation="fused_lrelu" ) ) @@ -404,7 +406,6 @@ def __init__( 1024: 16 * channel_multiplier, } - self.input = ConstantInput(self.channels[4]) self.conv1 = StyledConv( self.channels[4], self.channels[4], 3, style_dim, blur_kernel=blur_kernel @@ -423,11 +424,11 @@ def __init__( for layer_idx in range(self.num_layers): res = (layer_idx + 5) // 2 - shape = [1, 1, 2 ** res, 2 ** res] - self.noises.register_buffer(f'noise_{layer_idx}', torch.randn(*shape)) + shape = [1, 1, 2**res, 2**res] + self.noises.register_buffer(f"noise_{layer_idx}", torch.randn(*shape)) for i in range(3, self.log_size + 1): - out_channel = self.channels[2 ** i] + out_channel = self.channels[2**i] self.convs.append( StyledConv( @@ -455,11 +456,11 @@ def __init__( def make_noise(self): device = self.input.input.device - noises = [torch.randn(1, 1, 2 ** 2, 2 ** 2, device=device)] + noises = [torch.randn(1, 1, 2**2, 2**2, device=device)] for i in range(3, self.log_size + 1): for _ in range(2): - noises.append(torch.randn(1, 1, 2 ** i, 2 ** i, device=device)) + noises.append(torch.randn(1, 1, 2**i, 2**i, device=device)) return noises @@ -475,21 +476,20 @@ def get_latent(self, input): return self.style(input) def forward( - self, - styles, - return_latents=False, - inject_index=None, - truncation=1, - truncation_latent=None, - input_is_latent=False, - noise=None, - randomize_noise=True, - layer_in=None, - skip=None, - start_layer=0, - end_layer=8, - return_rgb=False, - + self, + styles, + return_latents=False, + inject_index=None, + truncation=1, + truncation_latent=None, + input_is_latent=False, + noise=None, + randomize_noise=True, + layer_in=None, + skip=None, + start_layer=0, + end_layer=8, + return_rgb=False, ): if not input_is_latent: styles = [self.style(s) for s in styles] @@ -499,7 +499,7 @@ def forward( noise = [None] * self.num_layers else: noise = [ - getattr(self.noises, f'noise_{i}') for i in range(self.num_layers) + getattr(self.noises, f"noise_{i}") for i in range(self.num_layers) ] if truncation < 1: @@ -539,7 +539,7 @@ def forward( i = 1 current_layer = 1 for conv1, conv2, noise1, noise2, to_rgb in zip( - self.convs[::2], self.convs[1::2], noise[1::2], noise[2::2], self.to_rgbs + self.convs[::2], self.convs[1::2], noise[1::2], noise[2::2], self.to_rgbs ): if current_layer < start_layer: pass @@ -566,29 +566,55 @@ def forward( def generate_im_from_w_space(self, code, noises=None): latent = torch.from_numpy(code).cuda() - I_G, _ = self([latent], input_is_latent=True, return_latents=False, noise=noises, start_layer=0, - end_layer=8) + I_G, _ = self( + [latent], + input_is_latent=True, + return_latents=False, + noise=noises, + start_layer=0, + end_layer=8, + ) I_G_0_1 = (I_G + 1) / 2 im = np.array(toPIL(I_G_0_1[0].cpu().detach().clamp(0, 1))) return im def generate_initial_intermediate(self, code, noises=None): latent = torch.from_numpy(code).cuda() - intermediate, _ = self([latent], input_is_latent=True, return_latents=False, noise=noises, - start_layer=0, end_layer=3) + intermediate, _ = self( + [latent], + input_is_latent=True, + return_latents=False, + noise=noises, + start_layer=0, + end_layer=3, + ) return intermediate - - def update_on_FS(self, code, initial_intermediate, initial_F, initial_S, noises=None): + def update_on_FS( + self, code, initial_intermediate, initial_F, initial_S, noises=None + ): latent = torch.from_numpy(code).cuda() - intermediate, _ = self([latent], input_is_latent=True, return_latents=False, noise=noises, - start_layer=0, end_layer=3) + intermediate, _ = self( + [latent], + input_is_latent=True, + return_latents=False, + noise=noises, + start_layer=0, + end_layer=3, + ) difference = initial_F - initial_intermediate new_intermediate = intermediate + difference - I_G, _ = self([initial_S], input_is_latent=True, return_latents=False, noise=noises, start_layer=4, - end_layer=8, layer_in=new_intermediate) + I_G, _ = self( + [initial_S], + input_is_latent=True, + return_latents=False, + noise=noises, + start_layer=4, + end_layer=8, + layer_in=new_intermediate, + ) I_G_0_1 = (I_G + 1) / 2 im = np.array(toPIL(I_G_0_1[0].cpu().detach().clamp(0, 1))) return im @@ -700,7 +726,7 @@ def __init__(self, size, channel_multiplier=2, blur_kernel=[1, 3, 3, 1]): self.final_conv = ConvLayer(in_channel + 1, channels[4], 3) self.final_linear = nn.Sequential( - EqualLinear(channels[4] * 4 * 4, channels[4], activation='fused_lrelu'), + EqualLinear(channels[4] * 4 * 4, channels[4], activation="fused_lrelu"), EqualLinear(channels[4], 1), ) @@ -723,4 +749,3 @@ def forward(self, input): out = self.final_linear(out) return out - diff --git a/models/stylegan2/op/fused_act.py b/models/stylegan2/op/fused_act.py index ccb031e..9995c7c 100644 --- a/models/stylegan2/op/fused_act.py +++ b/models/stylegan2/op/fused_act.py @@ -71,7 +71,7 @@ def backward(ctx, grad_output): class FusedLeakyReLU(nn.Module): - def __init__(self, channel, negative_slope=0.2, scale=2 ** 0.5): + def __init__(self, channel, negative_slope=0.2, scale=2**0.5): super().__init__() self.bias = nn.Parameter(torch.zeros(channel)) @@ -82,7 +82,7 @@ def forward(self, input): return fused_leaky_relu(input, self.bias, self.negative_slope, self.scale) -def fused_leaky_relu(input, bias, negative_slope=0.2, scale=2 ** 0.5): +def fused_leaky_relu(input, bias, negative_slope=0.2, scale=2**0.5): if input.device.type == "cpu": rest_dim = [1] * (input.ndim - bias.ndim - 1) return ( diff --git a/utils/PCA_utils.py b/utils/PCA_utils.py index c4ea063..78054cb 100644 --- a/utils/PCA_utils.py +++ b/utils/PCA_utils.py @@ -1,14 +1,18 @@ from sklearn.decomposition import IncrementalPCA import numpy as np -class IPCAEstimator(): + + +class IPCAEstimator: def __init__(self, n_components): self.n_components = n_components self.whiten = False - self.transformer = IncrementalPCA(n_components, whiten=self.whiten, batch_size=max(100, 5*n_components)) + self.transformer = IncrementalPCA( + n_components, whiten=self.whiten, batch_size=max(100, 5 * n_components) + ) self.batch_support = True def get_param_str(self): - return "ipca_c{}{}".format(self.n_components, '_w' if self.whiten else '') + return "ipca_c{}{}".format(self.n_components, "_w" if self.whiten else "") def fit(self, X): self.transformer.fit(X) @@ -16,14 +20,19 @@ def fit(self, X): def fit_partial(self, X): try: self.transformer.partial_fit(X) - self.transformer.n_samples_seen_ = \ - self.transformer.n_samples_seen_.astype(np.int64) # avoid overflow + self.transformer.n_samples_seen_ = self.transformer.n_samples_seen_.astype( + np.int64 + ) # avoid overflow return True except ValueError as e: - print(f'\nIPCA error:', e) + print(f"\nIPCA error:", e) return False def get_components(self): - stdev = np.sqrt(self.transformer.explained_variance_) # already sorted + stdev = np.sqrt(self.transformer.explained_variance_) # already sorted var_ratio = self.transformer.explained_variance_ratio_ - return self.transformer.components_, stdev, var_ratio # PCA outputs are normalized \ No newline at end of file + return ( + self.transformer.components_, + stdev, + var_ratio, + ) # PCA outputs are normalized diff --git a/utils/bicubic.py b/utils/bicubic.py index bf1cc31..bf5fb7a 100644 --- a/utils/bicubic.py +++ b/utils/bicubic.py @@ -10,26 +10,42 @@ def bicubic_kernel(self, x, a=-0.50): https://clouard.users.greyc.fr/Pantheon/experiments/rescaling/index-en.html#bicubic """ abs_x = torch.abs(x) - if abs_x <= 1.: - return (a + 2.) * torch.pow(abs_x, 3.) - (a + 3.) * torch.pow(abs_x, 2.) + 1 - elif 1. < abs_x < 2.: - return a * torch.pow(abs_x, 3) - 5. * a * torch.pow(abs_x, 2.) + 8. * a * abs_x - 4. * a + if abs_x <= 1.0: + return ( + (a + 2.0) * torch.pow(abs_x, 3.0) + - (a + 3.0) * torch.pow(abs_x, 2.0) + + 1 + ) + elif 1.0 < abs_x < 2.0: + return ( + a * torch.pow(abs_x, 3) + - 5.0 * a * torch.pow(abs_x, 2.0) + + 8.0 * a * abs_x + - 4.0 * a + ) else: return 0.0 - def __init__(self, factor=4, cuda=True, padding='reflect'): + def __init__(self, factor=4, cuda=True, padding="reflect"): super().__init__() self.factor = factor size = factor * 4 - k = torch.tensor([self.bicubic_kernel((i - torch.floor(torch.tensor(size / 2)) + 0.5) / factor) - for i in range(size)], dtype=torch.float32) + k = torch.tensor( + [ + self.bicubic_kernel( + (i - torch.floor(torch.tensor(size / 2)) + 0.5) / factor + ) + for i in range(size) + ], + dtype=torch.float32, + ) k = k / torch.sum(k) # k = torch.einsum('i,j->ij', (k, k)) k1 = torch.reshape(k, shape=(1, 1, size, 1)) self.k1 = torch.cat([k1, k1, k1], dim=0) k2 = torch.reshape(k, shape=(1, 1, 1, size)) self.k2 = torch.cat([k2, k2, k2], dim=0) - self.cuda = '.cuda' if cuda else '' + self.cuda = ".cuda" if cuda else "" self.padding = padding for param in self.parameters(): param.requires_grad = False @@ -42,8 +58,8 @@ def forward(self, x, nhwc=False, clip_round=False, byte_output=False): pad_along_height = max(filter_height - stride, 0) pad_along_width = max(filter_width - stride, 0) - filters1 = self.k1.type('torch{}.FloatTensor'.format(self.cuda)) - filters2 = self.k2.type('torch{}.FloatTensor'.format(self.cuda)) + filters1 = self.k1.type("torch{}.FloatTensor".format(self.cuda)) + filters2 = self.k2.type("torch{}.FloatTensor".format(self.cuda)) # compute actual padding values for each side pad_top = pad_along_height // 2 @@ -53,23 +69,22 @@ def forward(self, x, nhwc=False, clip_round=False, byte_output=False): # apply mirror padding if nhwc: - x = torch.transpose(torch.transpose( - x, 2, 3), 1, 2) # NHWC to NCHW + x = torch.transpose(torch.transpose(x, 2, 3), 1, 2) # NHWC to NCHW # downscaling performed by 1-d convolution x = F.pad(x, (0, 0, pad_top, pad_bottom), self.padding) x = F.conv2d(input=x, weight=filters1, stride=(stride, 1), groups=3) if clip_round: - x = torch.clamp(torch.round(x), 0.0, 255.) + x = torch.clamp(torch.round(x), 0.0, 255.0) x = F.pad(x, (pad_left, pad_right, 0, 0), self.padding) x = F.conv2d(input=x, weight=filters2, stride=(1, stride), groups=3) if clip_round: - x = torch.clamp(torch.round(x), 0.0, 255.) + x = torch.clamp(torch.round(x), 0.0, 255.0) if nhwc: x = torch.transpose(torch.transpose(x, 1, 3), 1, 2) if byte_output: - return x.type('torch.ByteTensor'.format(self.cuda)) + return x.type("torch.ByteTensor".format(self.cuda)) else: return x diff --git a/utils/data_utils.py b/utils/data_utils.py index 3c33b0e..ff626ce 100644 --- a/utils/data_utils.py +++ b/utils/data_utils.py @@ -7,8 +7,17 @@ import torch IMG_EXTENSIONS = [ - '.jpg', '.JPG', '.jpeg', '.JPEG', - '.png', '.PNG', '.ppm', '.PPM', '.bmp', '.BMP', '.tiff' + ".jpg", + ".JPG", + ".jpeg", + ".JPEG", + ".png", + ".PNG", + ".ppm", + ".PPM", + ".bmp", + ".BMP", + ".tiff", ] @@ -16,10 +25,9 @@ def is_image_file(filename): return any(filename.endswith(extension) for extension in IMG_EXTENSIONS) - def make_dataset(dir): images = [] - assert os.path.isdir(dir), '%s is not a valid directory' % dir + assert os.path.isdir(dir), "%s is not a valid directory" % dir for root, _, fnames in sorted(os.walk(dir)): for fname in fnames: if is_image_file(fname): @@ -28,7 +36,7 @@ def make_dataset(dir): return images -def cuda_unsqueeze(li_variables=None, device='cuda'): +def cuda_unsqueeze(li_variables=None, device="cuda"): if li_variables is None: return None @@ -53,11 +61,9 @@ def convert_npy_code(latent): return latent - def load_FS_latent(latent_path, device): dict = np.load(latent_path) - latent_in = torch.from_numpy(dict['latent_in']).to(device) - latent_F = torch.from_numpy(dict['latent_F']).to(device) + latent_in = torch.from_numpy(dict["latent_in"]).to(device) + latent_F = torch.from_numpy(dict["latent_F"]).to(device) return latent_in, latent_F - diff --git a/utils/drive.py b/utils/drive.py index 62ae698..8820e46 100644 --- a/utils/drive.py +++ b/utils/drive.py @@ -11,6 +11,7 @@ import re import uuid + def is_url(obj: Any) -> bool: """Determine whether the given object is a valid URL string.""" if not isinstance(obj, str) or not "://" in obj: @@ -27,7 +28,13 @@ def is_url(obj: Any) -> bool: return True -def open_url(url: str, cache_dir: str = None, num_attempts: int = 10, verbose: bool = True, return_path: bool = False) -> Any: +def open_url( + url: str, + cache_dir: str = None, + num_attempts: int = 10, + verbose: bool = True, + return_path: bool = False, +) -> Any: """Download the given URL and return a binary-mode file object to access the data.""" assert is_url(url) assert num_attempts >= 1 @@ -37,7 +44,7 @@ def open_url(url: str, cache_dir: str = None, num_attempts: int = 10, verbose: b if cache_dir is not None: cache_files = glob.glob(os.path.join(cache_dir, url_md5 + "_*")) if len(cache_files) == 1: - if(return_path): + if return_path: return cache_files[0] else: return open(cache_files[0], "rb") @@ -58,14 +65,21 @@ def open_url(url: str, cache_dir: str = None, num_attempts: int = 10, verbose: b if len(res.content) < 8192: content_str = res.content.decode("utf-8") if "download_warning" in res.headers.get("Set-Cookie", ""): - links = [html.unescape(link) for link in content_str.split('"') if "export=download" in link] + links = [ + html.unescape(link) + for link in content_str.split('"') + if "export=download" in link + ] if len(links) == 1: url = requests.compat.urljoin(url, links[0]) raise IOError("Google Drive virus checker nag") if "Google Drive - Quota exceeded" in content_str: raise IOError("Google Drive quota exceeded") - match = re.search(r'filename="([^"]*)"', res.headers.get("Content-Disposition", "")) + match = re.search( + r'filename="([^"]*)"', + res.headers.get("Content-Disposition", ""), + ) url_name = match[1] if match else url url_data = res.content if verbose: @@ -83,12 +97,15 @@ def open_url(url: str, cache_dir: str = None, num_attempts: int = 10, verbose: b if cache_dir is not None: safe_name = re.sub(r"[^0-9a-zA-Z-._]", "_", url_name) cache_file = os.path.join(cache_dir, url_md5 + "_" + safe_name) - temp_file = os.path.join(cache_dir, "tmp_" + uuid.uuid4().hex + "_" + url_md5 + "_" + safe_name) + temp_file = os.path.join( + cache_dir, "tmp_" + uuid.uuid4().hex + "_" + url_md5 + "_" + safe_name + ) os.makedirs(cache_dir, exist_ok=True) with open(temp_file, "wb") as f: f.write(url_data) - os.replace(temp_file, cache_file) # atomic - if(return_path): return cache_file + os.replace(temp_file, cache_file) # atomic + if return_path: + return cache_file # Return data as file object. - return io.BytesIO(url_data) \ No newline at end of file + return io.BytesIO(url_data) diff --git a/utils/image_utils.py b/utils/image_utils.py index 61516d6..12a501f 100644 --- a/utils/image_utils.py +++ b/utils/image_utils.py @@ -14,11 +14,8 @@ import scipy - - - def load_image(img_path, normalize=True, downsample=False): - img = PIL.Image.open(img_path).convert('RGB') + img = PIL.Image.open(img_path).convert("RGB") if downsample: img = img.resize((256, 256), PIL.Image.LANCZOS) img = transforms.ToTensor()(img) @@ -27,38 +24,54 @@ def load_image(img_path, normalize=True, downsample=False): return img - def dilate_erosion_mask_path(im_path, seg_net, dilate_erosion=5): # # Mask # mask = Image.open(mask_path).convert("RGB") # mask = mask.resize((256, 256), PIL.Image.NEAREST) # mask = transforms.ToTensor()(mask) # [0, 1] - IM1 = (BicubicDownSample(factor=2)(torchvision.transforms.ToTensor()(Image.open(im_path))[:3].unsqueeze(0).cuda()).clamp( - 0, 1) - seg_mean) / seg_std + IM1 = ( + BicubicDownSample(factor=2)( + torchvision.transforms.ToTensor()(Image.open(im_path))[:3] + .unsqueeze(0) + .cuda() + ).clamp(0, 1) + - seg_mean + ) / seg_std down_seg1, _, _ = seg_net(IM1) mask = torch.argmax(down_seg1, dim=1).long().cpu().float() mask = torch.where(mask == 10, torch.ones_like(mask), torch.zeros_like(mask)) - mask = F.interpolate(mask.unsqueeze(0), size=(256, 256), mode='nearest').squeeze() + mask = F.interpolate(mask.unsqueeze(0), size=(256, 256), mode="nearest").squeeze() # Hair mask + Hair image hair_mask = mask hair_mask = hair_mask.numpy() - hair_mask_dilate = scipy.ndimage.binary_dilation(hair_mask, iterations=dilate_erosion) + hair_mask_dilate = scipy.ndimage.binary_dilation( + hair_mask, iterations=dilate_erosion + ) hair_mask_erode = scipy.ndimage.binary_erosion(hair_mask, iterations=dilate_erosion) hair_mask_dilate = np.expand_dims(hair_mask_dilate, axis=0) hair_mask_erode = np.expand_dims(hair_mask_erode, axis=0) - return torch.from_numpy(hair_mask_dilate).float(), torch.from_numpy(hair_mask_erode).float() + return ( + torch.from_numpy(hair_mask_dilate).float(), + torch.from_numpy(hair_mask_erode).float(), + ) + def dilate_erosion_mask_tensor(mask, dilate_erosion=5): hair_mask = mask.clone() hair_mask = hair_mask.numpy() - hair_mask_dilate = scipy.ndimage.binary_dilation(hair_mask, iterations=dilate_erosion) + hair_mask_dilate = scipy.ndimage.binary_dilation( + hair_mask, iterations=dilate_erosion + ) hair_mask_erode = scipy.ndimage.binary_erosion(hair_mask, iterations=dilate_erosion) hair_mask_dilate = np.expand_dims(hair_mask_dilate, axis=0) hair_mask_erode = np.expand_dims(hair_mask_erode, axis=0) - return torch.from_numpy(hair_mask_dilate).float(), torch.from_numpy(hair_mask_erode).float() + return ( + torch.from_numpy(hair_mask_dilate).float(), + torch.from_numpy(hair_mask_erode).float(), + ) diff --git a/utils/model_utils.py b/utils/model_utils.py index f49fff7..25759e2 100644 --- a/utils/model_utils.py +++ b/utils/model_utils.py @@ -2,16 +2,17 @@ import os -weight_dic = {'afhqwild.pt': 'https://drive.google.com/file/d/14OnzO4QWaAytKXVqcfWo_o2MzoR4ygnr/view?usp=sharing', - 'afhqdog.pt': 'https://drive.google.com/file/d/16v6jPtKVlvq8rg2Sdi3-R9qZEVDgvvEA/view?usp=sharing', - 'afhqcat.pt': 'https://drive.google.com/file/d/1HXLER5R3EMI8DSYDBZafoqpX4EtyOf2R/view?usp=sharing', - 'ffhq.pt': 'https://drive.google.com/file/d/1AT6bNR2ppK8f2ETL_evT27f3R_oyWNHS/view?usp=sharing', - 'metfaces.pt': 'https://drive.google.com/file/d/16wM2PwVWzaMsRgPExvRGsq6BWw_muKbf/view?usp=sharing', - 'seg.pth': 'https://drive.google.com/file/d/1lIKvQaFKHT5zC7uS4p17O9ZpfwmwlS62/view?usp=sharing' - +weight_dic = { + "afhqwild.pt": "https://drive.google.com/file/d/14OnzO4QWaAytKXVqcfWo_o2MzoR4ygnr/view?usp=sharing", + "afhqdog.pt": "https://drive.google.com/file/d/16v6jPtKVlvq8rg2Sdi3-R9qZEVDgvvEA/view?usp=sharing", + "afhqcat.pt": "https://drive.google.com/file/d/1HXLER5R3EMI8DSYDBZafoqpX4EtyOf2R/view?usp=sharing", + "ffhq.pt": "https://drive.google.com/file/d/1AT6bNR2ppK8f2ETL_evT27f3R_oyWNHS/view?usp=sharing", + "metfaces.pt": "https://drive.google.com/file/d/16wM2PwVWzaMsRgPExvRGsq6BWw_muKbf/view?usp=sharing", + "seg.pth": "https://drive.google.com/file/d/1lIKvQaFKHT5zC7uS4p17O9ZpfwmwlS62/view?usp=sharing", } def download_weight(weight_path): - gdown.download(weight_dic[os.path.basename(weight_path)], - output=weight_path, fuzzy=True) + gdown.download( + weight_dic[os.path.basename(weight_path)], output=weight_path, fuzzy=True + ) diff --git a/utils/seg_utils.py b/utils/seg_utils.py index d570279..d178b25 100644 --- a/utils/seg_utils.py +++ b/utils/seg_utils.py @@ -1,27 +1,31 @@ - import numpy as np import os import PIL + + def vis_seg(pred): num_labels = 16 - color = np.array([[0, 0, 0], ## 0 - [102, 204, 255], ## 1 - [255, 204, 255], ## 2 - [255, 255, 153], ## 3 - [255, 255, 153], ## 4 - [255, 255, 102], ## 5 - [51, 255, 51], ## 6 - [0, 153, 255], ## 7 - [0, 255, 255], ## 8 - [0, 255, 255], ## 9 - [204, 102, 255], ## 10 - [0, 153, 255], ## 11 - [0, 255, 153], ## 12 - [0, 51, 0], - [102, 153, 255], ## 14 - [255, 153, 102], ## 15 - ]) + color = np.array( + [ + [0, 0, 0], ## 0 + [102, 204, 255], ## 1 + [255, 204, 255], ## 2 + [255, 255, 153], ## 3 + [255, 255, 153], ## 4 + [255, 255, 102], ## 5 + [51, 255, 51], ## 6 + [0, 153, 255], ## 7 + [0, 255, 255], ## 8 + [0, 255, 255], ## 9 + [204, 102, 255], ## 10 + [0, 153, 255], ## 11 + [0, 255, 153], ## 12 + [0, 51, 0], + [102, 153, 255], ## 14 + [255, 153, 102], ## 15 + ] + ) h, w = np.shape(pred) rgb = np.zeros((h, w, 3), dtype=np.uint8) # print(color.shape) @@ -38,6 +42,8 @@ def vis_seg(pred): def save_vis_mask(img_path1, img_path2, sign, output_dir, mask): im_name_1 = os.path.splitext(os.path.basename(img_path1))[0] im_name_2 = os.path.splitext(os.path.basename(img_path2))[0] - vis_path = os.path.join(output_dir, 'vis_mask_{}_{}_{}.png'.format(im_name_1, im_name_2, sign)) + vis_path = os.path.join( + output_dir, "vis_mask_{}_{}_{}.png".format(im_name_1, im_name_2, sign) + ) vis_mask = vis_seg(mask) PIL.Image.fromarray(vis_mask).save(vis_path) diff --git a/utils/shape_predictor.py b/utils/shape_predictor.py index b7c2528..0831abe 100644 --- a/utils/shape_predictor.py +++ b/utils/shape_predictor.py @@ -23,7 +23,8 @@ # http://dlib.net/files/shape_predictor_68_face_landmarks.dat.bz2 """ -def get_landmark(filepath,predictor): + +def get_landmark(filepath, predictor): """get landmark with dlib :return: np.array shape=(68, 2) """ @@ -40,24 +41,24 @@ def get_landmark(filepath,predictor): return lms -def align_face(filepath,predictor): +def align_face(filepath, predictor): """ :param filepath: str :return: list of PIL Images """ - lms = get_landmark(filepath,predictor) + lms = get_landmark(filepath, predictor) imgs = [] for lm in lms: - lm_chin = lm[0: 17] # left-right - lm_eyebrow_left = lm[17: 22] # left-right - lm_eyebrow_right = lm[22: 27] # left-right - lm_nose = lm[27: 31] # top-down - lm_nostrils = lm[31: 36] # top-down - lm_eye_left = lm[36: 42] # left-clockwise - lm_eye_right = lm[42: 48] # left-clockwise - lm_mouth_outer = lm[48: 60] # left-clockwise - lm_mouth_inner = lm[60: 68] # left-clockwise + lm_chin = lm[0:17] # left-right + lm_eyebrow_left = lm[17:22] # left-right + lm_eyebrow_right = lm[22:27] # left-right + lm_nose = lm[27:31] # top-down + lm_nostrils = lm[31:36] # top-down + lm_eye_left = lm[36:42] # left-clockwise + lm_eye_right = lm[42:48] # left-clockwise + lm_mouth_outer = lm[48:60] # left-clockwise + lm_mouth_inner = lm[60:68] # left-clockwise # Calculate auxiliary vectors. eye_left = np.mean(lm_eye_left, axis=0) @@ -89,45 +90,76 @@ def align_face(filepath,predictor): # Shrink. shrink = int(np.floor(qsize / output_size * 0.5)) if shrink > 1: - rsize = (int(np.rint(float(img.size[0]) / shrink)), int(np.rint(float(img.size[1]) / shrink))) + rsize = ( + int(np.rint(float(img.size[0]) / shrink)), + int(np.rint(float(img.size[1]) / shrink)), + ) img = img.resize(rsize, PIL.Image.ANTIALIAS) quad /= shrink qsize /= shrink # Crop. border = max(int(np.rint(qsize * 0.1)), 3) - crop = (int(np.floor(min(quad[:, 0]))), int(np.floor(min(quad[:, 1]))), int(np.ceil(max(quad[:, 0]))), - int(np.ceil(max(quad[:, 1])))) - crop = (max(crop[0] - border, 0), max(crop[1] - border, 0), min(crop[2] + border, img.size[0]), - min(crop[3] + border, img.size[1])) + crop = ( + int(np.floor(min(quad[:, 0]))), + int(np.floor(min(quad[:, 1]))), + int(np.ceil(max(quad[:, 0]))), + int(np.ceil(max(quad[:, 1]))), + ) + crop = ( + max(crop[0] - border, 0), + max(crop[1] - border, 0), + min(crop[2] + border, img.size[0]), + min(crop[3] + border, img.size[1]), + ) if crop[2] - crop[0] < img.size[0] or crop[3] - crop[1] < img.size[1]: img = img.crop(crop) quad -= crop[0:2] # Pad. - pad = (int(np.floor(min(quad[:, 0]))), int(np.floor(min(quad[:, 1]))), int(np.ceil(max(quad[:, 0]))), - int(np.ceil(max(quad[:, 1])))) - pad = (max(-pad[0] + border, 0), max(-pad[1] + border, 0), max(pad[2] - img.size[0] + border, 0), - max(pad[3] - img.size[1] + border, 0)) + pad = ( + int(np.floor(min(quad[:, 0]))), + int(np.floor(min(quad[:, 1]))), + int(np.ceil(max(quad[:, 0]))), + int(np.ceil(max(quad[:, 1]))), + ) + pad = ( + max(-pad[0] + border, 0), + max(-pad[1] + border, 0), + max(pad[2] - img.size[0] + border, 0), + max(pad[3] - img.size[1] + border, 0), + ) if enable_padding and max(pad) > border - 4: pad = np.maximum(pad, int(np.rint(qsize * 0.3))) - img = np.pad(np.float32(img), ((pad[1], pad[3]), (pad[0], pad[2]), (0, 0)), 'reflect') + img = np.pad( + np.float32(img), ((pad[1], pad[3]), (pad[0], pad[2]), (0, 0)), "reflect" + ) h, w, _ = img.shape y, x, _ = np.ogrid[:h, :w, :1] - mask = np.maximum(1.0 - np.minimum(np.float32(x) / pad[0], np.float32(w - 1 - x) / pad[2]), - 1.0 - np.minimum(np.float32(y) / pad[1], np.float32(h - 1 - y) / pad[3])) + mask = np.maximum( + 1.0 + - np.minimum(np.float32(x) / pad[0], np.float32(w - 1 - x) / pad[2]), + 1.0 + - np.minimum(np.float32(y) / pad[1], np.float32(h - 1 - y) / pad[3]), + ) blur = qsize * 0.02 - img += (scipy.ndimage.gaussian_filter(img, [blur, blur, 0]) - img) * np.clip(mask * 3.0 + 1.0, 0.0, 1.0) + img += ( + scipy.ndimage.gaussian_filter(img, [blur, blur, 0]) - img + ) * np.clip(mask * 3.0 + 1.0, 0.0, 1.0) img += (np.median(img, axis=(0, 1)) - img) * np.clip(mask, 0.0, 1.0) - img = PIL.Image.fromarray(np.uint8(np.clip(np.rint(img), 0, 255)), 'RGB') + img = PIL.Image.fromarray(np.uint8(np.clip(np.rint(img), 0, 255)), "RGB") quad += pad[:2] # Transform. - img = img.transform((transform_size, transform_size), PIL.Image.QUAD, (quad + 0.5).flatten(), - PIL.Image.BILINEAR) + img = img.transform( + (transform_size, transform_size), + PIL.Image.QUAD, + (quad + 0.5).flatten(), + PIL.Image.BILINEAR, + ) if output_size < transform_size: img = img.resize((output_size, output_size), PIL.Image.ANTIALIAS) # Save aligned image. imgs.append(img) - return imgs \ No newline at end of file + return imgs From 493d78a941cd083fd3958e333f296fa2b5e88ea0 Mon Sep 17 00:00:00 2001 From: soumik12345 <19soumik.rakshit96@gmail.com> Date: Wed, 30 Mar 2022 17:46:33 +0000 Subject: [PATCH 08/15] fix: updated wandb table integration --- inference.ipynb | 148 ++++++++++++++++++++++++++++++++++-------------- main.py | 4 +- 2 files changed, 108 insertions(+), 44 deletions(-) diff --git a/inference.ipynb b/inference.ipynb index c662594..fee061e 100644 --- a/inference.ipynb +++ b/inference.ipynb @@ -11,6 +11,7 @@ "import wandb\n", "import numpy as np\n", "from PIL import Image\n", + "import matplotlib.pyplot as plt\n", "\n", "from models.Embedding import Embedding\n", "from models.Alignment import Alignment\n", @@ -45,7 +46,7 @@ { "data": { "text/html": [ - "Run data is saved locally in /home/paperspace/Workspace/Barbershop/wandb/run-20220330_150026-2j8lbj0d" + "Run data is saved locally in /home/paperspace/Workspace/Barbershop/wandb/run-20220330_173858-133snw7f" ], "text/plain": [ "" @@ -57,7 +58,7 @@ { "data": { "text/html": [ - "Syncing run flowing-field-12 to Weights & Biases (docs)
" + "Syncing run skilled-sun-16 to Weights & Biases (docs)
" ], "text/plain": [ "" @@ -265,29 +266,25 @@ "metadata": {}, "outputs": [], "source": [ - "import matplotlib.pyplot as plt" + "def plot_results(images, titles, figure_size=(12, 12)):\n", + " fig = plt.figure(figsize=figure_size)\n", + " for i in range(len(images)):\n", + " fig.add_subplot(1, len(images), i + 1).set_title(titles[i])\n", + " _ = plt.imshow(images[i])\n", + " plt.axis(\"off\")\n", + " plt.show()" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "metadata": {}, "outputs": [ { "data": { + "image/png": "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", "text/plain": [ - "Text(0.5, 1.0, 'Identity Image')" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAARAAAAEICAYAAACXj6vjAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOz9eayt65behf3G23zNnHM1uzn9vVXXdpWV2MRShGSkNAIpJMIiiPwByOnACGLSIitRgiFKIMhWHIkATogU24LgRIBxgDggIeEkihU5imMEaSzs2NXee9rdrXbO+TVvM/LHeOfa+566VXXrHOrWPeX9Suesteecazbf/L7xjvGM53mGqCpv19v1dr1dX2W53+g38Ha9XW/XN3e9DSBv19v1dn3l9TaAvF1v19v1ldfbAPJ2vV1v11debwPI2/V2vV1feb0NIG/X2/V2feX1NoD8Jlgi8h0RUREJv07PvxeR3/rr8dxv1zd7vQ0g35AlIr8oIn/rj+B1/pyI/INv3qaqO1X9+Xb/vygif+hrPP+P5HO8XT+a9TaAvF1v19v1ldfbAPINXCLiReSfEpGXIvLzwN/+pfsvROSfF5HPReRTEflDIuLbfb9PRP58+/trEfkFEfk97b4/DPyngX+ulS3/XLtdReSnROT3A/9l4H/Q7v+3ROS/LyL/+pde/38pIv/sD/E5fp+I/N9F5J8RkRsR+XkR+U+02z8Wkeci8ve98fi/XUT+XyJy1+7/J770fH+viHxXRF6JyP/ozWxHRJyI/EER+bl2/58Wkce/5oP/dn3/UtW3/30D/gN+Efhb2+//deD/B3wbeAz8XwEFQrv/zwB/DNgC7wJ/EfiH2n2/D0jAfw3wwH8D+AyQdv+fA/7BL722Aj/Vfv8XgT/0xn0fAAfgsv07AM+Bv/GH+By/D8jA39/eyx8Cvgf8r4Ae+M8B98CuPf5vAf5j2Mb3u4BnwH+h3fc7gD3wnwI64J9qn/P0Wn8A+AvAt9pz/zHgX/mN/l6/6f+9zUC+mevvAf5ZVf1YVa+A/+npDhF5D/g9wB9Q1YOqPgf+GeD3vvH331XVP6GqBfiTWBB476u8EVX9HPi/AX93u+lvA16q6r/3Qz7FL6jq/6a9l38VC4r/pKouqvpngRX4qfZaf05V/5KqVlX9/wL/CvA3t+f5u4B/S1X/vKquwP8YC3yn9Q8B/0NV/URVF+CfAP6uXy/g+a+X9fbgfTPXh8DHb/z7u2/8/pNABD4XkdNt7kuP/+L0i6oe2+N2X+P9/Eksk/kTwH8F+N/9Gv722Ru/T+09ffm2HYCI/E3AHwH+BizL6IH/fXvc9x2T9rlevfE8Pwn8H0SkvnFbwQLnp7+G9/t2vbHeZiDfzPU5tlOf1k+88fvHwAI8VdXL9t+5qv7OH/K5fzV59g+6/88Av0tE/gbgPw/8Sz/ka/1a178M/JvAt1X1AvhfA6co+TlWngAgIiPw5I2//Rj4PW8ck0tVHVT1bfD4GuttAPlmrj8N/MMi8i0ReQT8wdMdraT4s8D/XETOG3j420Tkb/7lnuxL6xnwK3E+fsn9qjoD/xp2gf9FVf3er+Gz/FrWGXClqrOI/G7gv/TGff8a8Hc0ELYD/ie8Di5gweYPi8hPAojIOyLyd/46vc+/btbbAPLNXH8C+HeA/w/w7wP/xpfu/3uxFP8vA9fYxfXBD/ncfxTDBq5F5H/xA+7/54Hf0bomf+aN2/8kBnD+WsqXX+v6bwL/pIjcYxjHnz7doar/AfDfAf4Ulo3cY2Du0h7yR7Hs5c+2v/8LwN/06/he/7pYJ+T97Xq7vtYSkZ/AOkPvq+rdj8H72QE3wE+r6i/8Br+d37TrbQbydn3tJSIO+O8Cf+o3MniIyN8hIhsR2WJt3L+EtY3frl+n9SMPICLyt4nIXxWRnxWRP/ir/8Xb9eO82sV6B/xngX/8N/jt/J0Yp+Uz4KeB36tvU+xf1/UjLWEaG/KvYSfbJ8C/C/wXVfUv/8jexNv1dr1d/6GtH3UG8ruBn1XVn29knz+F7Rpv19v1dn0D14+aSPYR309o+oQfgIQ3zcXvB+j7+Dd+9METYx8IPPwi0np08uU/f2Pp9/34FR/z8DzSfn3j5xvPY8RuBZTXLO833/ybP+T0eX7VV3/zc4gI0l5fvvT5vu/fIj/wttPfK9reKzxkmg/H7UvH5vveo77+rG++tjw83a9picgbx+31S3z5qzvRo1+/fvv5cJu+fk8Pv9v/Bfvcp88nztlxEEHEgZz+/eXP+qW39aXv1v6pqNbv+75VH06GX3p6yZe+NfnyI/QH/P7ln790/eqH/suv+wP+Vn/pA168uOHu/vArXUi/7PpRB5Af9CZ/yXFR1T8O/HGA3/adD/R/9o///QhKRcE5vHOA4MQhPgBCrfZUrr1IVQEqUtuXLyAqoGBkxAIqb7y4Q5xDEUQCOIe4diG2C6DWTMmVopVSCqDUWqmiLdYoXgQvgjhw7TmdOHtfztnJpUrR03uEqkqxSwAnjhh7vIt4F1AqguB9gFLx7eT3vsc73y468LEn9h1enF0RqpSUyKWggPMO5wRqpeZin01Or1/btyBUBecc7pSbiuC8R8QhcrqgagtUrl2LbwQIASfu9eXQYpiIXWqqkEul5gy1BYYWHKpWaqnklCglUUuhakXVHl9youZMrYVaK1rbfaWgVQk+0I894jxOPN04EruBEDu6YSD2Az5EnA+I83amOKhVqaWi2M+U7HUUpeRCSgt5Xe391Np+FqoqWop9ODkFsBaQhLYBqB1rByIKoogUoLb/2u96uu2NIGpH7EuhRdGHXcpeROT0Ym3j+b7N743v5/XR/r5z/x/9x/7YL70qf8j1ow4gn/D9DMpvYYDXL78EHGoHSZ0FcwWkhRStoK6duwUVhzr7Ppxa9iCA1tdbniKg3r73N3YZasVgmmKPa0EIfPsbRbWgtbbfFaU+XCGipxMGnDp77wq41yeBaydbi3icrl1Ru8iDj1ArKoWqgnMOUaGuC4Kj4unGDU4ctVTEe2LsiDEgSrvAlFIyCsQQ0FqoObPkgvMe793rACJCkPjw74ddWms7/O0kfDjm+hA87HYBdzpp9eG2U9bh3OkkVgs43tHL6XBXSi5oLZRSkFpRMq5Wu7AVdLWLSpzDh2CBpta2SRRqyhZEVFmSBZlhM1BcRCf73lVru8bl+zIVEKj2CZ1zlFLtMU6oLfKpWlApuVBrpubSNg97Tdp3Z5uUtMzHPQSQU7ajLTCIVvuDhxP54TR/IxM6BY/X65cGkTf+7lfIPL7/r+UHPEZ+wON/+PWjDiD/LvDTIvJbMP3B7+X72YQ/cKkDhwAepNpJe4rERYFkt52+rGpBp54i9EPqWbB7QHDta6ht85X2JVYEZyfzKUg5hWrX/ClzVZHXZcFDvi9UFH86SV37et/YIbyLbcdSPErFPezSzgm1KuICXhy1ZEq2i8DjCD4Q+w5yoWjFxY6+73ECmjI5ZaqqBQnnKCWxHBeKQjd09Ntox9FZluScR+R0sRQLoPUUmPWNwNAOX+UhgNinPZUPr/8n7fkfLlKxY/1wkqpYxuQcEoQaa8sA7L3nUiipo+SM+JXkFvK6UNYZasucvEdracHEsgFQqirTtFJLZthuyFpBqwV9Pb0714Km45RmWTCzi7olUfjgySnb89ZiGVHOpHXl9T4uqPDw3M77h9LsoZxydgxqzS3wFZyAOB4CbgvLbSN5szB7OK0e3ufp36dNxzJrteDF69sf/uj7KvDXm+jD+hrBA37EAURVs4j8tzEWpQf+hcYg/GWXAA5vB0gcohZvS8s+5PsOS4vE7eRXtf/EFaR4LJto7wX7W3mjrtb2RZyyEZy3OypQC06VLHranEErte0yHkvB7fUFpOCqR4LDO28BS04XnXsoH5wWi4EI65pxIRCcUIplOlUrQSOhi4TYkdcMztOPW7q+R1NizYlaa6vz285eCuqEsBkZu2ClT0t3TtmD0FJwVWopiCpVoLbbTkeK9p4fapFTun464qeMxDmc8zjvwOxHHvbGhz1S1Dbgas/vncMFAe9QVTqU0nWknAldR+o70hyZj45lmqAmvHdo8XYVegu6NRcLFijTbMeu327IKaE1U4t914hlX84JTiJCKwOrZRTycHUXnHfUYt+vamVdF3JO9t6lZYfeSlRtxxBVpCo+2PlWc8tqvLSSVKiakWqZqp0u8jp509cZgb5RrqjWN8qP0318+eh+f0CQ00b7ep3+6uG5H6LSV1s/cjWuqv7bwL/9Qz8eqE7wOBTXdpSKl0pVoZAsY5CISHl9klTFaSHr64N7+jKkqiUx7cC7U0h/I3V0ipUqIlAdSqG2EkpoGYnQakk1HOS0o2ixvxFFarRelwdXhSoZ1NJgLYavEDqqKiF2iAglJzuhcyX6iPee4DtEHXHs8LGjCx0Ue55SykOKr6pWJnQB59RwIgGKlQpaaXW6BQ8rxyq1ZCt1ykpJyQIL7XFqwQkndqzE0nRxr/9zzuNCwPsO10WcC4gP7XEC3rcyVNrr2wHUllCesCtQggi+i5TgiV0kdz2xHwj9gf3tLTXN+ODI2co7UR7wE2k/D+uKUgldh9ZMpwpS23u1ABjE4fzrEgNsc/BeqNVDrThv72GdPSllSsm4luVVVUi1ZZsNqMUygpKzZR6lWMwt4L1v2Zm3C7goItWwpV9y4ks7R9+4xvV1OLA9p91xEhir4wS+v/k8p3Cjp2ugbZT6pWznq6wfezm/fdH2oQUsha1wQqqkOqCiLuPq65PBKmdweoq48FBBWtFqqb84pAGVJ8DyAfqQ2lJeRaunUikKqr5lQM5e7VSCPGT8rXRqYJ2iSElobXiGK6g6xHtC11GL1Uc+9qS0UvMKFbpuw+B7vI/4bkREiCHgfKCmlZoLlWo7f3iNbbgTeJwKucwP9XxVRWq1dLok8rJQ1oW8zKRpYV1XUkpoLeSUKW1XVtEHQDg4j48B8ZHYBUvbxRuGI0IIPf12ZNhuiOOW2I+ID7jgH4BLcadwoYZRtPLjIetp8SoEhw+R6CNdF4l9h4sdh5sbynxPiJ6S7Ds4ffM5WyAsVZknYUCprjTAVnASLIh4j/ceda5hXQ1bUSxQilhmqAYKd0NP13dMh5WihZLAe0shnA8GlDvPqfulegLWH87khvPQgpagSEvq6sPm86Wzv5U/lTezhoeCR0+3ysMZ/gC+yBv/fHOD1PYc9c2g9dVDyI99ALGU2w6AfwgADmoDJFktkta2m4uzg6oGhlqkDQilHWxvGQLWlvPiqfiGdgqqHhFFvGKYi3uoS0UVh1JUHlqa2vASxKFSCS2nAbE6nYJKAGmAYrDuinceXCCtM1UsvT3u7yz1dY6x2zB2W5wE27lU8T7gnRg2ojx0pCKGvpAXtBZSyZQ1W5ATrOBLK2VZWKcj6+HIOs/MpZBzJteKj5HQR1zvqSpoHxBRnBgu4qqizo5grhXHgpYVqQ4fIy52JHUc8oxczYSrG7rYsdltGc929NstoR8s2DQg1zmHBmkBWCg5o6W2jMl2b+cdzjtEPK4biJeBcTOwv91yvLlCpxVVZ4GOSm1BBIVlnoGKC9HKCzH8RJyzYxkCMQRwAdtGaN0dbMNq+JCI4HwkxEA/DKR1ae/fgqcLAUGsY8QJXG+YiwhaCrVlvaKKK1bSiG/gPFZeWnewbX1igbGewPbTRvX9WyFVBNeCgsgpQDxUL9+HgXDKPh4CEW+Uql9t/fgHkLajizuVLy0qY0HDibMvrmZUbOdQMTCzQWSgq+EhBOye9iWpXfTWrvWWIXzp5R/qTMGyB5TiKr5a3a8tKFVX2gP1IeBJUUR8AywduI7genBQUHKesdZvYF2OKAWRgbPhDE8kODvx07rSjQPBOUuxYyBooawrmhMlJdK6UHJp3ZcKJVPSQpmPzMcDx/1MLpmEQ72j2wzEcWDwQhAsnS4VpdhJ7U9YgKN6A3pLLYYleI/iKFRyKciaCM4u1DBG+u2IjxaIprwyX72i2x8YNiPjdkMcNtTqqSduhvM4L0iMZLFgp2oXW07JulPRAqnzkTB4+hgZdxskdtw9f4aUTE4rDssIypqoWslrQtcEfW2wVsCJ4H0kdB0+RHzXLmThoT2fU9twqnWAYt/h40gvQugG68popRZFl2xlihPrFDkLJqVaeWOZTG04kbRAYkHz1LGx0uPUJChW4j2chN+PeHw5d1DEOo7C69DQHq6tXau8LoUeshh9ExX8auvHP4C0gyWi1tbU/NAnL1S82s4hnJKIQq1vdAHUgkIW2x2cWqT2Lchb+nc6kQGprU40Hke1FAhVxU4twamjoKi0YHRqVTpPpuJPwUuwHUoiznscAS0zXnpKXqAWvIuUuiJUxjjQxy1BOkKM1DWRU6YbR7q+x0sD+6aJmhPLdGSdJ3JOVgbURE0JzSvz/R3HuwOLCm4zErYj49hxFiPRB5BKTZmUcqvJYW3lEHjcabf2Hi/gnJKzZW0hRMRpS8Jbd6q2i0lhXRJ+zfjg8V4gCFkXjnMlrYkYZ4ZNTxwHXIhIrUj1iFeiFxKedUrUknHtoi65EPuAj52B0uKQwRE+fJ9+7Hn5xecszz+nrDPixbpbJUFWalaohVIr4fCamxO7gPexBUT/UILSwOtasmEs4vHBE4aB+Wahi4L0PaXaNlVKJa8LKWfSvOKcELuOEAxQ9kGp2bpDdsUKRbM1BU/ZbktcRayV3eC1Vt4BbVOEN7C8h8ujRSRaYdRaSd8XPHgj2XjA7k4dza++fuwDyOvmlJ6qZqoUQHBqX7SopX7aEHURS+1ETxkCrzMSrbZLPTAVLZV24lDnH1I/VQtYUgWVjK+5FUFWJ4s4AyB5XZ1qOznUt+DlwTsxjKUR3XzocS03Or2fqtCHkRC29MMWL55lmgkhsrsciV7Q9cA8TeR5Yp0m1vVIzsXwHCfGiViPrPuJw2GldD3h6Ttc7raMrdUrWalaHghtOa+EOOCGDu8io4MQIy5Ea3K393xKwy0eWnCtpbRjYQgSpwBbK6UktCipFNZcLECT8LKQg2NNgXnu6ccNm7MtsRvsuyyACj56xm3PsnryshgPY5lZZxjGkTAMlok4D77nyeMndENHjJFXn3xMzROhj6RcrAODY54WhgrHAvgAVXE+4ENP6CISTniEkHLBh2CcGs2QjaPT9z11HCk5EX14OBaxE+rQkXOmpJW8JtZ1xTuhiLespFq36ITRCKCaERF8J9Rg51TjRbY2up23pwtdTiFb6kMIecBc2qYnYhubtIL/AShtGMjrkknbc3699WMfQMBKB1UrEU4AqBF5rBPToLmHiItUnBrfo6riRBE8QkFxr1vCzoGrBqx5Z4+RBsrWChVKQ82L2Gs6QKXgXTAmaas5a7WgdEoQLTBhX2bjhLgw2GdpRCjnI7kWgg94t6XrzqEKWTPDpiPWTDnecJgn1uPEPM9MN3fMy2SZwWagHzcEX8j7I/tjQvod28sN/TiwHQdreabCmrLlWiGCBELX4/pMcA7vPd6FBhYXyrKS14W8JNK6WjnQOjbuRELzHhfEui3Ov94xG9YTYqAPDpXYsiNLmee1kO9viSFw3N9z/9KxPTvj7PEjXDcYGF09MQb6zuNdzzrPlFo5TivzNLPdbBjOtkiIjagW2Q4b/EcfErqO559+Qt3f47tgpVkU1jmDVAqCPx5xHvzBM2x2lLzB+0jJ1nmq6ghUUlK0ZkIUfPF0MZC6zjIzha4PVIWcMpILkrOVEs4ZZ2SaEYTQhwdgOHYdaV1J62znh1Y0KcG5ByBUTpmIWgARDMiuDdA/YSuvg4i+DgSqD/jcA1JyosYqrXxv/WM5gatffX0DAsiDqoMTIuTUWUBBcLXipLZuiuKoVNvzjaKNWPtV2uXfyE1IS4N9MKDUeYTYmKjJcA3NDR0X8B5XH+I3pRac6wx0UxAx4O6UXjsnCLm9RkcXBlSFWlKrlz21QJCe0J3j/YATwdUVSTN5XlnXieP9PcucSPORZalkAsPjx5xfXNKHwnx7x/3NjPRnnH20IwRHHyIBWKaVpAVRSEXx3cDmbGPliQgQqMvKepiY88o6J9Ja7ThFSAVqFrp+g3Ni2VQIVr413oh37g0ujQUgqVCXhZJWAiBBjN/iHf0Q8GGDVqVU5X5/z+3tnrObex598IR+3FF9o9gVT/ACfTS2Kcrx5sA6HTnLC5vLC5yLVAQvgb4beOfdd0Hg5tNPSdOeqoFaMkux1qpjZl0icQxM+3uG3TnduKWPoTH0BR8MlwhdJC3FCH6lEKOn63qTB9RKzsblsIASLBOuGe8FGSJFK2maKXVFc0Vi69S01ndKCedOmV61TCQJLgri6qnR8vq/UzesSQVOQUSkviG3aRvpw0Z7wj70oeR54JScCI5fY30DAsgbyLLaRWoHx1JjgFOSjDiq2K4PFVE7uTP1IW6AIOpttxXXLqZoYOypW6K2G0uo+EaVLyqoVDyOopahFFacOHJdDRMQ442oYWW24/uerjuDukItBpKJ7VygxOGCoT/Dl0w+XDEfDyCQ15X93Z5cMyUVlqzEJ+/ywbc/YowwPX/Gy198Rg6B8fE7jJsNsYu4kkjzyixCJVg7tB8Yh4Hglbqu5CVTUqZUtUAaR7qzSzrviJ0neo9DrETSau3uVq45cZaGk3F4QFtru5VHJZsQoCrrPDddSSKVgpZKdI6Ao5SMeLh8vGPNlZvbmeXjZ1w8OhLHkX6zIXYDZQUfHbHrEFHyNnF/fSQ9f846r1w+fYzvLThLcXQ+8vTxEzSvXH1S6CRTXWW6m4BErUpKC2kJqGbSPJHWha50iERysexQC3RDoJRASSvSBwNUEbreWu8nzkVVZSqKk2xZkdo2Vgfbr0qa2V8fgES/3VqnTRTnpWU9lZwKvXokeLTa+WysX9pZ236KNIKzYXeuIfyms2mgbAP73xQAasMKLXA8QCY8CB2/4voGBJBTlnVqr1l+8SAAc1igkNN9FoGrCDgjK0k7wUWclTNiCKpzBSe+kYA8DzoQrLRBA6e2mndK8Q5JrrU31fgAJZuOgmIkppYhVZTgO2I3UMvaUHgQAhWHd0LoRiOE3b9ifziCh7wuTPs71mrpaykFtz3jw5/+iMuLC+r+luc/8z2ub27Q7RmP3n+H7fYM0Uo5HJjXisSI7yJj7BnGHtHCfDgyT4VSHXGzY7zorBUpluE58ZSarRZL9aF2FvFNtGhptKp1RGqx7KqWgnft+GJEsoCgFJwIsQtQe0prgddaTMznC3ktsCRcF9icefK0cn93TbfOBgh3mW7s0RRwEaL3bDYbUl6ZXr7i+Sefko4zT771HhJ7E0NWCOI5P79kvpxZbvdEl9md70jLbPT0KtQlk6SyHO8ZljPSOhKia0Q7w7e8fTDm48ImOIhKSYUgDQMrVn7GKLjzHdPesx4PoFYqhqKIrxQv9OeFw/Ur8s0Vw3ZD1w2oA0QoqSC+kpOVK14FuoBztPZ0oyw8tFKMtObEWQZkbQJeq7AFV5TSpAfGfrXvzzIUWnbj3rzAvtL6RgQQh2kVjBH5WoTWYGxUHBljlBrZ0SPqqU205DCg0jITobqmGHUOkYDgXweQBlIpRjqqtbXUnLUvqQrV2J5oQcnUmow0Rss61FJ2HzwlHY1nICfOwECUiEfJhwPzzR1VBK0rx1c3HPb3aIi4foDY8fij97m4vCDUzP3HH/Pis8+ZqzB+8BGbzUiIEZ9W5uNCAfrzM/rNjqEL6DqzHCZyBeLIuDVCFmCdhmIaFLRSSPZZS0KrktNix6wUaiqUmixY4oyEVAqCNxDbq11s4sFhrdFgPBKtCUTw4lt3oCAhILlQg32np1JINx15WlivrinLkXW7Y6wX9H2Prx5xgeAc42aDni8s6ZrPP/mCXFeefPQhPvTghCSBPnacPb6w1uxxxsfVtDfTjKtKXlakj6R1piwzOa/42AFttxfXGL7yoJkx4DmRp4nh0RnrkiAWqIEYA9vdhjhEjvcH8jxZF4aIq0K/6VnTwP7mjrq/o26U0PXWQvbRjncq9FKorX5UreCtzV1bGeJOvdjW/hY5FfknQam2bLC1DrRliDwgIpxYrtL0Y1+niPnxDyAte9AGYlrkTI3F22q4pn7VRhE+ZSSiAQ8UWVud6CwQAIg0oNU1nMO6OGAUdSuP1OpfcSbkampSh6NoadR007hQMgRHjCM+jHjvqOkeF3uEQPA9IY4WoHIlHSfWlFAHy90d99evWLLitjtit2H76DGPnl7SAcv+wMtPP+PV81ew2fDo2x/RdZ4o1p04pEK3PWO3PWMYe+qaONzsUecI445tH408VxJ1nliXhZIMJM0loyVTSjX6dTVF67Ks5GSamtLk82uuBjD2PSLGqHS2+YF35Np0LlrpBIztYp2BfmOci9DbMS7LYidvELxmnMuMu5581jMHz35eWModpWTSsMGpZ7zcgTh8rQzbkVxWynrN559+gY+eR++/Ry4OFyAtwjiOlLWQRNBSKcs9Eo3jkUuiV8+6LizTgWG9QDuj/hcMJ3AoXirBC6EJD+MQWRY7/8LYU6bZsqqUCH1HEM/mbMfRweH2Fi8V7wUvkWHckkvheHWN1juGzRk1e3wXDPBNK2mpBDLiIFfDlHzscC4+4HieViI3DENaGfMAmmDYjOFzDcOTUxfTHquNzvA1eWTfgABCQ461PqhB7Xid0rHX/W9FWpAw7Qo0vQomvztxRXxVwgmtFmncDUFOuEoj92hj+BnbY7Xd1fWI7yhppmrBiaLOyitVRww9tSwUhHE4o/M9netx4o1a3nwt1uORtE5Mhz3H23uWdcXvzrl87yMuHz2m94G0Ttze3XD92Wfsl5X45JKLd94lSiBQKMtCJbB75x3GccRXZbo9kBDGywu6GMjzzHJ3zeHunjTdsyTz4RBnnJKciu2qxWTrptdQqjq0C6iPOPF4cZa6O+ickOZCKSs5FySCEwOzT7qaSWGaV9Zpwdds+JD37LYjKp51nlmnhaiFbhwYNj0h9mwvzhjOz1hcT55X9ndHcsnk1TMf79k+vaRkwQWl63uGi4F1LVx//pLxbIsftmhqGeIK283AfcrsHjkOz4zCH/vAOps6tqyJtE6U1bIQ+zC+dY6sLI1dT4w9oevBB2p1lApd35OBWhMlG2nNtC6wHQacF6a7PSkdgEoMkc12y7SfOOzvybkQ+pEuRfqNR0I0Tk8qSBBj44qiJdE5B9rel4JXsNaOtWsFA+ZV9UEaIxSQYoDOKbbgXqt4X19NX3l9IwJIKdrAotYyVQPvrKUKtNYsmEnPCSzVB6aNICrY3uIfShnF4VUt/TvVipj+pbSkr2WL1nGRDEVx3tHJSFBlLQm/rtQgbIctNRd8MNCyw0Ou5MZSrXklH/bM9zcc7w/M60KuBVVPd/mUyw+/xdN334c1M88T06uXvHrxjForcbNlszujA4JXclLC9px+syW4wLo/kooynm0Zg7Dc3fH82Utur68pbjECWB9wIeK9UIq1wGuMhKFD04JLTRncQDjvI33XU8rCepxIWckoKQRjXfpIN3Ym0ssnbEApjXLfnw+WuaTMPM1oUVZRlv0BH2GWzIvre+TFC8Y+sD07Z7g+cPHOzPnTM4oTpjWTXq70Z479FNFrCLG3b68LBOfpd5HpauHFx894+pMfogRqTaR5IURld7Ylr4lykUkl4SVRfUBDsAsrWUZWW7lFyyisnSo4H5oFgsNFh7/wLXO1blteFGpqzT1HUSsj+hgJj8443kO62SNq/izbyzPWZeIw7dk4O8tqFutQxYhWJa2VODorK2sh12B8pVoozrxupAknOLV1xSNSUDxFBTTiS9MaUa38Fjvvm+zuYQP+qusbEUBes+WyhQ0x6rk8XPSn+03voI09eMIzTiCRNHOg114Mr1tbp0eo6AMF+bVqwEoah5HEtDZGaCk4FUK/MQWpKq7r2XQDrppdQFHjEmhaWG5ecri9YVoS1XmIAXJgvHzM0/c/ZLc7h5SoNXF4+Yyrqytyk/tv+p5h7OiGnqKe7dmWYegpS2J/dyCOHWMsHL74lJvnr5iORwN2XSX0gTB2xNBRsvEpSspWflFIcyLnagyBGHA4ggfNE2XJFOeImy27ISIolJW6JNY5QQHnIoSIBOj7yGazwUc7zs4JLnhSzk35WzjsF9Zl5ThNdBc33D57zv6wZ//8FZvtRNZkUGBnPI8koLfQn8PxWBmGjPOeIErNpszGZw53t3QvO7aPLkFt9z7ez+zON2g30J1lYkocr1/ivCNKQKSwpsSyLMR1sfa8N3A4xA51Dh89SGiCScE7o+n74HHO+D9VJsqaCaU0/rLpZ3zoqFtlTZX5WKBC30X63Ya0Hjkc9mzPIGdHrZk4mLTCOwPwKyC5oq42AmU17Uu1Dk4ImImWIYUN3xDMwubUHCimLpfT5WSbZkXf8Mr5auubEUAoLVI2zoY2oxawroEXUNeyDz1xZgBTn5p9IYZcYw0Ww/tOpJrGtmykeKlKbTR1baCTOGdUdK2oE2oQxEWGOBBCQGqh8wGvmVAwY5xWR+f7O/avXjKvK8U53GY0b5Fc2b33Ae+8/z6bvifPM4frK25evOI47VnWFe1Hnrz3hKEf6GNHJbI5O6PvAumwsOSVGAqHz7/H7fNrDvNM3Pa4nSf6jtgP9h5y5XgozOtix0YUl1fWNUHw9GeD+YEY+YOyCt2mY9gMD3T2shbSvJJLMs7LsOHsyWPOz88ZtiN9NNMjH4Llb7kBzLXZFWolryvbbqLWlTmtvPfeI+4+eIcXX3zG7RfP2d8dmT+ekTpz9vQp66oMZyNTEuqxkUjnhWHT47ygNZHyivjMcjdz9wJi7/H9CFIpeWG6rwy7HZt+S95mprs7QmMvi/NWfqZEWRdKSRBjsyKQh25HrYU1S7OnbOZBtbRMzsqZVSHlmbQkpEKMBekCXTdw+TRye9txuL6iiz3b7UA+bDnub0jznhBHlnWmasX3nXmk1Ij3Fc2mq/ElU52QKaCeKNZRwvnXlgsnfVZjKKvqG1stjbNzkh22NubXWN+IAOKcNAikqVzFUmitpQWUZm1IhKZYsSykPCDUSEGkPpCoTCbWjH6Q5upE668npFqHwdzIKtCdrCwatyNQi0JRQoVOHG5dzFovJzQXdJ24v37JdDhQgyNsL/BBIBkgefbOR7z7rY/oBKarK66vXnLz4jnLOnNzs+fRhx/w7rtP6PqBGDe4fsd2t8OVynx3RAOsdy+5+vwLDtOMhsj47iO6wToWWgrpMHNzdzS0vxar81MhtRN/sx3wXYdXyKmABLqLkXEzWKdoWVjnhVRAnGM43zHsdmwvLthuR/p+pPP2HZR5pswLVZbm4mVdnlLM1Md5x7om1vmedTZWqdbK2cYTP3iPPgb44gXT3S3PX1wRokf6c+bDjPpAuV8Zdj1VHcuLmcddS+CL4h1MkjhcXbPZjoyPQUqi1JX1kAnBE8czYvSMw4guxTQoalyKvCZKztRqnY2TIxyl+eyGaB02sXK5tm6c9wZN1nJiIptaWpcVrZFAR6mC7zyXj87RnFkO1/R+ZDxPHO9v2d8eOb8wDVDKezZ0ZEYDys9GirMeozYcz1S/Bap5khgrwY6Fog9UBN82znJKMPTBf886iNpY11/j2vzxDyBCS7ektbHsRLZr3cBR1SY5dwke2lkn4EiB8sD9ODFQnYuGbBvf3HCOhqXktluqGvnpRJ1XZxmLVEHzSsGIUa5ZAaZizNWyHFju9izLkZJWdByNOi7B+vG+5/G3vs2Tx5fIMnHzxRe8evGM/f0903LH7c3EOz/1W3h0eU7f93TDObHbMJ5vH2jptSZuvvsJN1dXHNeV4WLH5mxr4FpRlv2edV5Z1mSFX1FyXq30kkgcAl3v6LvO0m0X2VxG+ujQtJJLayF2HePunO3ujHFzxjgO9H1H7HqkJNJ0ZL6dWI73HO8PpDWxrhOqlTiMSPDUXEnLjC4L3S5QBfKSKDUx71fSVaLvI2d9xL3zmJdeSfdH7u8P7ELkeKicnQ8U7ZjvJzbnA4sox9sDod8QY2AVxceFeZnY397SbzsUC5rruuKODhcDfdfTdyPLPONPu7QT1GnjXRRqBUmptUoboI6CVpZUjX8B+Ogb9b7J6sXjQ0RiZH9zYCwJ7xRiT14LXd9x+fgRL1Ki3h/o+4Gzd59w++qKdV2NfuAqJTkWSYTDwrgJ1gZ3QnGBpCsGoWeSRrSUlolY80D01NJVVAon5bmxQ074CI093ZDE38w8ED2BonJSvLQP3kyLjadRLDA06NMed1IIpPZExv1ApNWtzelcQrPyE8y0SJqF4opUU/5WAafZOjxaUWdZTu8cvUS7TaCuC8vdS5bDkVwVv+2I/Zl5XaRktWm/4/L9DzjbbcnXr7h68QXXzz/ncD9xf9gzpcy3/6P/EZ48eUwXAs5t6MYtwzCQ14LmxP7FS66ev2Ba9mjf8/idx+Rp5nhzMMm7Uw6HhZITEj1jEPKyUrLixw3bnZVQmhOIp9/0RDGq9zI7uhDohkA3jIy7czMHGkZiHOi8g7KS54np/p7Dfs+aZpZlMlVqWUjpwLok6qsXxE5QH3BeWFZleXGLj0rnPfimGUmZw721HL2H883AvlaWQ2ZIM9U57u9X3v3o3LpDc6KLJlFYlwVtDmV9dNQorPPEYX9D6LdoWUlrwjlH1/eEfsR3tnGEAM55A4xjZ7t3NZlECabJMUGlxznbwrwzioCWSknW5td23ogXnHr6riNdbDjeXLO/vmFzsaHfXZAEfBfs+1pX9HBNkGi+tqXio5DXhaqZukwszhOnBbftSWU1HxoqxRfERyP+gdlVNoGgh2ZnUdHmNH9iruIcThWpmSRWuj0oyb/i+rEPIMCDQP7kHGa+mqUxT4GTnK5a7eekGYqJs3JHcyOZWfCQFoyQxvMgEFSplOaGYQrdqg5y8wyVTNP/49Qx+IFOzf28pJVy3HO8vSJNB9x2S99vKGkBF8mlgAuo63ny4UfsonD/8cfcXj3n7nBHWmfu727ZL8pP/K6f5unTx/RhBPEMux1d8OR1JeeVV9/7nMP9HbV3nF08IXhhubOAFXpPnVfmvOJCoIsdaZ2ZrmemNbO5PGfbB0iWXfTbM7roKdPCUjHOyLZjHEbisKUbNwzDSNd1hOCgKmWaTBWcC9k7ZDTylBs6lnkip4WUlOM8c3u7ZzksVC8MgycEWKZsjmtU6uHIuAmEMZKqo5Zm4EOh7z2qA5qFzWi6kfXuSIyRw3Eldo7YDeRSOLy6ZXexMcGjVjRn8jGBTGYPmWfyAssh4JzHR4d0vQHImgliF2Femm+MCsE7Sq7gWllTA6rSQFQDLos2/9lqps2hMXtD1zNuK+syMe/vWV9e0d/t2Vxe0p9f4GPg7PE5pU5s2DGtE/urW8ZmZGTerJVcEiVFcvJIsMZALY2FTQVXHvxxooB3UDQYxnECTNVsCvwDoay+Jo+JyTS+zvoGBJDG8W8I+In/IdIYoSot+zgBQ4YyS1Pj2ngF4SQAEHwTNEVEAs4FPN5yl/owwOHBqbyKkYqkGDgrAlEcXc1WN6fMcn/LuhzJvuLOzonDSEmV7uwJy/6eEAIqPZcfvs+GytUvfsr1i+dMy4E1Hbm9vidL5Cd+52/j3SfvEFyHC53NNQmBWpX5cMvLjz9lToW48WzGnrocuZ+L2SCWQjjCMi+4riOExH6/53BYkG5g++iCIRg20g8D/dBRc6VMmTBu2Wy3DMOWPnb02x39dkMIEe8cQRwlLSyTgXyEQBBM2wOkRZvCWPF9JJ6f048dj87OmA5HpuOR2LpJsoXltuAks58XXrx8ydkQGR7vcN1oXQRVZFW2nUcpzNPKcsz0vjOZPhXWAuvKeNZzcJ71uNBterwLrNNMnDwSK2SFklDnqTWx7id8EMbdhlpmNFtpWwFSxUX/YJosYvyeNC9ob4BqCB1gZY+oPgguBes0mRLbpA/b8zOUwt2zF9RlYr2Gc4F+t2Pse5bNGbquvP/Rh7wQ4XDzCifC8X5id3ZG8J7Sun8lLfh+MB1WqXgq2Q+Ity6jFJqSPAHegp1K6+MYpa9g5Ekar0qBWt3XqWC+CQHElnnWuoZHyGuFoRTroGgxHcprFg0PDuh4Tg5MKtKUu68l0doo7NJadYIaiCYQ/UqpydSgmol0hGkmlULJifn2lrlm4sUF224grxldV7phQ80ZiRHnRx6/9w4sR55/8imH/T0LVq9fv3yFDju+/VM/zZMnjxANuDAw7M6gVNKyMO/vuXn5kqWs+M520Xk/M61mSpTSRF0WlizQRZxmjjcTqRS6sy273cgwjGy3o4GrVSlLQnzP9p1HjNsNXb8lhEi32dAPA9Fbp0uTyfurFnwMaDEP1Xw8ME170jyxrivrsrCmTF4WUlrpOmEcOnpGeorpUEpi7HrGd7YcD3vSWWGdZ55fHdimxOWTSuw7pMB8KMwsbDaB8WykOijTAXe2ZTt2aFZSKvg1s9nEJna0LpAO1bgpSwOzpUkhSmlYRyDGwrKUZhMZzR9ksIFULpzgsmoSBDX1bFVjsNbqjajmBFyAWh88PpwTcinUZOTE7bhB33nK7RdfkO5u6Rx4Kr7bshlHtJ4DKxe7c8q0B01o6CgKKSX8JAybjgWP5ERRhZpJ2ROkELxrxtTeGpKN1KD+5PHrSPXErD5Bps1NDdeymd/kbVwN0USs7tRxaR+41YBQcaL4Znl4AkwfyLsijWGaH2b6iLNfjBB0ogU7apUmGhOiD5b2CRQSHsGvK+u8UNaJ5X5CYyScXTCePUZTRqoZ9hzvb+nPn3B+8Q6b7Ui6u+b6i8+5v79Ha+Jwe8f1ixcsLvKtn/gWl5fnIIEwmIdoTWbRd7y74u7qinWaUO/pukBeV0pa0HUhrSvz4Uh1EGOHaKGuleH8jFEgBmEzdITQEX2kFigSGB7v2G139P2Ajz3duG2lireugxjeU7SAWyGtrMcj6/HIYX/P/tUrpv0daT7aAY3O3MUirClx/2KiLKtdhNGxruZGFpjZXW45e3LGZjsQO8ddfMXhfsFdHdjtso1qWG0+zpwUtwZE4P7+QOhv2VycI8ERgqA546oSO6E725BCh59mqmYDgovasC6sayeu4pwjr7lhBzZ6Q5yziYKIeahUpcwFoRD6gZqSWWgGIDTjiKJ4wcyrQmicHyWEQMqJupg6dzw7Q7Xy7Bd/gfuf/Vkunzzi/MNvM5yfE/sN02HFB9PvzKlQpglxE65/hGYhTzNuN6Cu4ot1bm0ezoKrxgEpzigL1mAwn1RpqnIn0rqUFiyKOtPWqFLJv7lBVIPAG34hZotvuVdGT5PqpKBVmlbgdYlzsvw33sMpM2m92Nfssod+v28EM8tCAkWgeodvM0x0mlgP9+TpwDIv+LMzQn9ON46wFuo6o2UhlUzYXHB++ZShi0wvnnH1xSdMaaE64eb5Nff3V+QYePrRT/L+e+/j/MhwccnY9dRUSevE4eaK2+fPuTsciMPIuOtZp4WSZ/b3B9K64mJkc3lh7Mma0ArDbqRvVGrvHd73dP1AVYi7HRdnZ/RDb/qcrqeLARc76y7UZv5MpeaV+e6G9XDHMk/MxwPLejQqvh5ZypH7+2vm6YhWIZdMQ6hxnfmc3h0Tui54DwRHxjE/u+HsbGD3aIte7Oi8Et0t67GwrMq4C7jR4auVDM5Fwi6Cr6wFRhOrGGMzFebDBHsDQLtth9/sWA8rWjJrWXFSqc7bKeBd88Mwgl2tQvC9keGKg2CcFWqiJEU8+OLI1VqlORdCrMbxcLbBlFqgZTZGOnOtw1dxzmbEyPmO/tElzz/+jGXaI8F8Z8LmnNiNzHKHi4N194Jjvl9wYYJzjztmQlep3uwOm68Q2jKizgdo+YaqsWFVwKlvdHahaputpErBIdLc/E6b7FdcP/4BRAz0dNSmt2jalBOX/5RdUJpLmz7oZkTqg1O7k2bp3zw/wL4Ex0mZ22i9ajThqtaN8aIIPZILaU2oJlIuxPPHDGfWXtWcyXmlrJlMpD+7ZHP2iL53HD77lGeffoJGKKlw8+wz7g8LNToef/AtfuInvoXzG86ePKHznrJm1nnmePeKm2efM00zw/k5w2akzjPTceF4d8e0ToRx4Hzbm3CvLJSsDOOWYTM0P86BMAzE2COqDF3P5vycrh+Jw0gfO1JqRkiiBG8Dl7Qk1vs7jjdX3F29ZNpfM+3vSYcjq5o5zloKa0nc3d0y3R0oaUGip4aIhEC+yQzB4TcjycP+/p48r8QhEvueq6sjOU3EccNuu6U8Um7rnjUl5FDYbs3JbD3O+FzZXJ7RB4+HB/mBF0fcbajFU/NMqbDcr2y2wjBYWZOyGUGHECwLc+ZSFoeOuoAP7sFVXaXg8A/0cResU6el4oLiO5DoDXj33rxinFk7OBFccI367uhjtI5JqaS04PE8fvKUu5/4kJtf/Dmun32GiNJtEtv3HjFtd7jbK3ofcOMOXa2EiaVQUsbXivhAlUKU5mZfGjGs0QxOVpnmhhibIteyN8REixlrVTvEgNbm8/JV1499ADnVlWYC1HAP9YjmBhqdmKS1tWCbb0X7W2nkM5znZEh24nXYdgsnXU0VwTc3JxHBqwMJVOeox0peZ/JhIddKN/a4rmOajshprqt3dKHn7OIRoRauv/uL3Dx/ifaBnBLPPvmMNd2xaseTD7/Dt7/zE4SwY/foKb131oqd9kw3N7z4/HvUovTn52y2G9I0c399zf1+D1R2l+fEGIyslReqOrrzc3bbTXPFGum3W/PIUEe/tY7KMO4Yt1uC96xLQlwg9pEYHJBZ7w8cr6+4e/Wc/dUz9tevuL56wf2rG/b7ift1pSQl9p5+O7IUZUkTL17sWQ8HNkPHk8dbNmdbjkvFzRl8wHtHCp7pbiK5ic3FhvkgrNUxBM/l+ZbgPPMxUUslOPMdKWCmOzkTo8MplHUhDCOSCy4l+ihU8XhXwUdqFUgZHx3j2Rl1tQw1xggE1GUoGRcc+GDfn6vN5Mnc033o7RwpmKNaNCtDJ9DFDteNqCopJUpaqSXhSyV09vpVzYJQxIZQrXNm4wPf+W0/wc+smevPPkHcF5w/dXS7gaGLrBeXyC1IWdFdMsVyVjRm6rLaHJsQWJnwJRDFm2M+Fa/WWawIQcHY13Z9qCiINysAkTag3ciXpYlOv+r6sQ8gLYS8lsOcJpurs/9cwbDmFkzUIrGCqXLVwggnZe2JZIbVgYY82b8dlomIGvJNsFKoTHv2L75g2r9iynDx4Qd045a0JLRkNCVyqowXl2zPHhOo3Hz6i9zcXOO3I9PhyIvvfkxhJeN58lt+Kz/5nZ+kCwObi8dEEdKycH91xXS85eqLZ9A5Npc7hn7kcHfP/c01h/0RusjZbgStTEshdD3BCZvdhqEL5uK+2RDHvvlvBLZnZ3RDz7jZMgwjUpWlyc+7LiDeqNzz1UtuX37O3atn3L96xvXzF7x49oJXtweWUpiqkJxxDvxakOM9sQ+44Oi3I7jKYX9k+nThbDiy2fU4F+hDIOx6NpuBHD13L++or+6QC6HvI7U4gnecnw/0MVIUXFGcVsbek7IpTEVNzJ6yx2VFvVAWG6LlXc8yJXyn+KC4KJTJgoSP0bwzXDQ7Bg3YJEPr+Dhv3RRQnPY4abt3bR4wYmWPiEA1xzCpiotGHCtDxzovD4pXbVqqru/s92y0gHlSdJ751k9+yCd15eUXnxO3O/r9hhoCMQ7o2KNzYkXxoUOjTekjGRgXaiU7k20U7wz0df5hpInzDfvTioo3YqGCYhuwa4TIXG3b/DodGPhGBBAawetk6NNauWKRU1qKJs7GSZ7A0FPr1lS62oZQGTKt6h6k+qZ3MZOd0spBbTuR8U4ry+0r8nLHOs+cffu3MJ5dkpN5R+Bc63ZcMGzPkLJw+8VnvLq+wY090/0dX3z3U6pkahHe/a0/zfsffgtfPP35JaEqOR+4f/GKu7tr9rf3+KGzlmTsuL+54/bqhsNxTxhHnrxzyf3Le7LznF30bafuCQp1ycYbGXs7Fv3AcLZjGDZsdlu62JFXRZ2n30TjLWDcjsOLZ9w8/4S7q+dcv3jF9e0Nd8tKefSIx++/j48OrR7VlVqUshRSSaxroaaFzTaTpo5rJxwPM1NakGNm6Dv2KdBrYSw9YRvZXG453B+ot0ce+8BwZhdAcI6u82hzTrdh4ULXN/0JSuhO/qoRiVZylTUTe4/b9eTFSs1Tlik4Qm/6HJuXkvAEm1N7AiPzitOM72PTj6xQfSuFvZUmzlGS+XSUWfGpEIeOEALeOTabDaczKpdinKRixMYw9JRqz12qIrPj8r0nrMc9mcLzj7/H+aNHuN2u2QUoFU/JK3qY2e42iLO5OD56goutg6h0zjXDLDHbTI3EZvosrUY3wZyDKoahYCW9GYz/Ji9hLGoaicv62p7anMhoAJChzacBUaCYA5ggFOdx5bUZsshJyFxNVSulSfhPAG0BNbFUbWKwPE9M+wP+4h02F49NHyGwNgv/OGwZt1ukrNw//4Lnz17QXZyx3t/y4uPPWdKMhI53fuq388H7T0E945PHOK3ktHD78gX7uztuXr1kOBvpuoDiSNPE/fUV6zwTho7HT89Z9wvS91xsB3ofQSo6HSldYLh8RIxt8l0cGbZbNtszNrsNHmdBr4s2MlIKUgvrYc/+1XOuX3zG/tUXvHp5zX0pxCfv8H7XoVRzZs+JUoR5AXQxwtWcKIeVVBLdALvtwDg+5nhYmfZHdFoJCC46aq7UlOhrz6Yf6X2kLErJQl4LfYxodWyCR4ZIbnNzQYkOG4uZcxswZaM1Tx60oJTkiJuA76GmRF4zsbO5Nq+V2c0VzdmM4KrVXPODIBqpWRGfQILt1CLE0EH0SC0WSNoepg5qrqYcdg5XbZaONqaBAbwZ78wS0jvH0BvPpesjlYIvnv3tM/bLhL5SHkXHOIykw4G+U6aaKHllOUyMFxHNdh0kMXsI5xTnFNSwOuPQnBq5ldyGWQkBjzbiW0E12+evapjg11g//gEEOA21tDGDbYA25oZV2/yMkyOZB3MQw78GWF0DW4U2uQ6qutOzUtsB9aaBRk6ljvNoXljmCeLIcLYzwKpZ8Jc1oQjjdsSlmf3VC149e0nY7Zjvr3nxvY+ZamXz+IInH36HDz78kLzA7vElogUtmbsX1xyOe25fvqJGh7iAhB7NK/urK9b5SHGOx08fkafCWgvj9szKgflInjL9bstm0xN8wMWREEd7zG7LeLbF4cip4LtIbHGSklmO9+yvXnD17FNuXl0zFZAn7/I4Ci4XjvuFw/HAfFyYp5l5mc3NLBeCGPch+kgYYhtYrUgRzrcDZ2cbZIGUE1EqSEQRpHh8FPrQ40abN+y9w9dACGbd10llGLZotVapaLF5KSHgMF8ML4KKUczNPjLgEQh2HlTncKFDfDQpQal4l0iTEgJUF5rdgMe5rrGNLcgJ7bWCqX3rkvFhMGFlUnwnbaJhE21qE3Y6MRpAMWAzdOYFW0tpGZRj7Ae8b/ONq+BcNqLcPDHd3bN55HCbAZYjdU10Y8c8rcRdgfYdWshMVNe6jmLgqaEhK6m6psD1b3jbOrRKMwM3bMcml/ymx0As4gea83rrnNgMEm3UXzuZWj7yQNU1X1O7zwipJ6q7aQpeKxGLMVervO7sNOf1dToyvXrGnFYG9w5VYexHpvu9mSaPnbE0D/fcXN0RH52z3N7wyS9+jAuOR0/f4dG7H/Do8oI6VzbnlzhVSlo43Nxxf3fL8e4aNwa6oTc4tyr7F9fc3d8DyubRufEBFIbtjt12oK6Jmgvj2ZZhHPBxoNue03UbthcX9OOGvot4jP78MBrSATWRpgOH+1vu9vek0LH54D12sbPxEfuZNa1UKfixZ+wjcdfhp0g3BdY1sy4zeVHWecXvC7GPDKO5ouOxIdxbIYbR+BNSqS6242rKVedseDYOggs4dTbiUo2m3bkO9Wa2E7yN9LRJca1r4kzsJmNnfM3aZqdUx2bsqOItQ6naQPg2E7k6xFcTvoXOMk6xQFBFjO4eDEAX54jRU7RSso0qRbJ5uJaMOtfoFdouUpNChDYOVCs4782xLBWcQHQmUtyenVHznsuLM14ej9y+vEai0J/tKLtL9vsDZV3QzlNysnk7KVhJxEkNZ02EqjZqtFJAM1U81tzNiEQUy3rUWVfqhH1Ild/kPJBTwyQ4Tt4cliqaK5kWG3SEVFQtZVU11L0JbVGJuDcMlk9jL63F6zn5n4JlJ6oVLRaiDy8/43j1BcO3v40L1sVI04xiJ4IeDqwlcbzbE893pGnPF7/wCS5ELt97h4tHT9mc7ajq2Zyd4wJGxrq+5rC/Y7+/JSs8ujxjPSRChPtnn/Pi1RUiju3jC8a+Y10TfewZtzuCL6xFGc/OjCTlBoazC/pux/b8gs12xMWIOLHhzE04GINlVGmeWOaJlLP5hXSBdV053N1xvL1hPSbSOnOcZqb7PcuagWqdL00MLtB3Ee1H8BVNmd5bF6ALHtd5c4Ar2NzdNs8kOHP2OpkBFxWi80g0+bzzgSACLpvZj7O/DdF4FRZAirUvm6hNsE5Kbd+Xd44aO/A2qoOqxtPQGRVpu38PzkaNWhuUNr7CSlfxoY0FNuxDqif2neEyBZaUcMn0Vb6PEHtzqj8xRfFoC5APhuBSsY9vAc0h7HY7cn7E4f5Ifz5ZmzytxJTZbnvuNx3LlNhER6mZQLRxErVSvaNzvm2qNi6kanm4RlSFQsYRwEOpa2sg2AZc3WmGrp5Akq+0fuwDyGvzE29yFhfM2aplEe4hgxNj1YFFXAfq1RzRtR1osQnoZlFo0v6qJ22MN+fxqoQwIl7Iyw37F59RvBCGS4adMQMFj5QjOc3k9cA6V+h68uGe7/2Vn2H2jvc+fJ/ddsdmsyG4jm7c4qOnpJX1cM/93TXrOrHmzMXTJ6S7CTzcvbzj1YsX1M4xbHaM45bpuBJjpN+MuJrJxxkXA7EbcW7k4r13CD4ybjZsxuH17i7mOu+7YA5jaSUd90zHO5b9PfPdNce7O/Z3e/a3B1MDTxPrPFMd+D6wvzvY+ILOUbOSy0ItAtmAuG5rQ6xUKn0MxNAzdB2hjfAUtNkIYqWKczix6XjFO6S04NKBx0oTgnXCjEUeoQqdi81AyMocCdYijc7sAZRgGUmM5vamimaHuorrXQM77fJx3dbgzjbGQmtBmhu6EzsXXIigAXEVCQEK5JLw3iF9sHGbVSwTfD0tu5EWC049EI1EdiI8Ws1tI1K1IKVwNoyUp+8iTijTPbVmcs50URg2W6iJIM4yqDYvxnRh3jZFPLVaOWV+pyvS3MZwNnrCOyzwtJkxhhua7KOEr9eH+bEPIEA7UJYiemM9oaehSM4OhHVMwoP8vjY6u8jJu9KbPB9tvh/u9WAplFozJvW3ejKnmeXuipRWxne/w9mTD+m7gfV4YD3cUdORsq4sS6b6iKwTn/zsd0l9x/sffURwge32jG4YCcOO6L1Jyw83vHr+nEpif3fP7skF+XBknReUxBfPnqHBsdlccPbonLJkfOwZtwPRaVO7VsZtRELP+btP6eNAP4z0XWtTBo+UajNvY8Rroc4z62HP8f6aw6svuP7ic26eP+Pq5UtuDgtzKuCtJ1WB42IucMthhZrQUhlcoNtEa//2WAdIxLpA3tGHjm4c6JzgFYKL+OgYpEerObkF723EQ5MauGiZh4u2GYZG/KOxJi27tLEQTkCilRkPGYM6c6RDqKujlAa+CjZ6cxgt00+ZqjZM27s26e40dlSFohBQKEoNrVz2GNUdAdfGmpLx1Rm5sbPs1XfBBm3n0iT2p4FPM7GLzQvG2t9IMUC4GD/JV2W3Oyenlf26EHBGUsPR9ZHlzmYDhWJnuOYENdjIo2pm1qW9/86iV7MX0DbW1UPNzYnMPIFtWwatDlh/c5cw8qWfryliWN3ptAUJA65OOhdrUJ7meymUZmystFm5oeljBPUncZ2j5Exejg2pVnbv/STjo3cJcbD5IdOBupit3zotZB9wOfPFz32PHCJPnzwiVs/2ySOG7RnduCP4QF4m1v0tzz/9HI2wHme6oUcUa92OnpvnryhVGbcXnF9eUueMOEc/eIYhUJYZTTA+2jHsLjl/8g5D1xO7nr7v8N4T+sG6RJ3Nl3VaSNM98/6Ww9VLbp5/wbPv/gLPPv2Uz794wX6ZCUM0xi8B5w10HscNfhzpNyvz/R7Jic5H8/PsR7o+0DlPEE/fd/T9SIi9BQTn8diEuxCcpcvSskDfdtHgbFwoDgltJk9rfSLVCJLOOBjRS9Mr+VY6+gc+z0n75CQggzf7LbGLWmsxcaMKIQRi7OzUqbltGG2eTejxGjHRpX8YdWAOdnaJnAB6dW10qhoL1Hfg2gQ4if5hJnPOKylVUsm4aSEGT+yjBXQXUIqpwGUgRgdcEr2wv77CUQlDT1wX4rCjpIWihZhX2F02x1X/muMEplsqYthMbb6pKC4Ec3anGSGJtgzevmdppstfdX3lACIi3wb+t8D7GIz0x1X1j4rIY+BfBb4D/CLw96jqdfubfxT4BzDfwX9YVf+dH/K1Wsf2pDA8kTWkkWTsBFX3epTfybsDVZxrMn89DZkKJqR0p51OXtvUieD7AUmJpVRcHC1AqY0/SOtELSs5V5I6fC1cf/4FR+Dxk0esGc6fnnFx8Yhh2Bl4VhaWww0vvvtdcghIMlVo7Dqm/RF6x3R/y/Wre84/eJfHjy+RJZGrEruRzdgz39vEs3674+z8EZvLJ2w3Z/hgw6KcC/SbLc4HpBPrWqSV5XjPdLjn/uUXXH32XV589ikvnj3nZl6Ij0YeMVClklNFiuESeV2Z7g8MU2Z71vH43UeUrNRsvq/9sGWzG4xHkqV5r44m5e98q/0doQ0wwrkmWDNNk0pzOPce9a+HI4kEUJtNU7O16sXRxkrUFjQCXgLeK6UBgCdMxXvBd6aa1aw2WBtn9gbRGVDedmLBzKIQ44c4HyygdR0lP0CM1LXgo6OIjQypSS2R8LY1pXmmLsnGYfgA3tkAchG814fuVC6JulbcuhCCHSf8qWsYONucU3NmmWeGGJDg2BRlTYU82SyedS30peL7YOVJwz8dIFVJYhdikDbM3K4EcrVszatvJZZrJlr1NUHzK66vk4Fk4L+nqv++iJwB/56I/J+A3wf8X1T1j4jIHwT+IPCPiMjvAH4v8DuBD4H/s4j8drUp2b/8OgFlzTRWaP6l1URC7nTfiWwGJ0Fzox6Z3NnLqeNy0i+A1ow4A5m0nohhVj/XdXkQJuWy4DpHTgt5ntG8MueK1sy8PzBr5ezJBVTP4w/e4cnTp+aAniq1Zsp64MX3PuaomU3fczzMOC/UlKhSqNPE8y+u2bz3lIvHF+a4XQUfHbszCx6pKufnO84uL9ldvkPXj4TgCc7MnbtxIMQeHwPklbLMpOM9y3TH7Rdf8Oqzj7m9fcX1fk9ylUBlf3fgeDgyH5M185ynVCN09b0nh0Rde9gkxt2W4WxL6HqGfkvfvELiNhD7wYZ4BRtlKRJa58y34K9maxBDa5G3tqZzDVQF51pnRS1zKOWET1S8j1aOlNKIXcYBETW+DKeqB6OQk62EFefajlygONS3dmbzkvFiw9RVjNnpq+Kq4DZ9I3qYWrUmG7GgIlBfXzJSik22Wxeb1OcMVC2pkFYbNYn3lJSgViR2hMZe1WoAcr/pccHKs6Hf8vT9gBdhWQrnvrPhXuNIcUKSCXHW4areUZyBq2aF9bojWdTOfH+SfjiP950RKMGA6EaahN8gIpmqfg583n6/F5G/AnwE/J3A39Ie9ieBPwf8I+32P6WqC/ALIvKzwO8G/h+/8iudlLVWf+qJBqYFcfGNtu3JRKi2jowpDk80+IoDjxF7ipr7dhgIzoPajFwrhTxoZl0Wlv0edz7Sd2eQMuv9HSVNVNfhXeVwvWfVghdPTsrZe5dcXD7Cu0jNmaK2011/+jGHeWXzeMN8d8CLEAhM8wSucn88sLk8Y7PZ0nejjakslcePLlgPE1kNUBsunnL+3gd0/ZYYDeeQ0DFsNwRpbdpayMtMmvakec/NF5/w8pPvcbi/4f72lnl/z3GeORwWrq6O3N3cUxGi9wxbYdwNiFjHZuwC55sd3dAxDAObcUc3buhjxPlA9Kajcb7DOcvqvA9tEmS1oCDm6E6IaAxNWm5m16dmu3EqnJULgoGa3lNqaYChZYDighHDnGEEtSoanXWaTh0GcWi0HVYQm8Nb23iO1vkMvqOK4p11XPwwAIJJbm0bD17wIVC7QFqMsxMGT8BaqmleySkjslqQUKGmI5FEzjAdZvtMXWBtbvYuzhYoukgce26nSncvXFye47qOGCLRRRzCdtdxvb9jvJvonz5BpfLq08+gLKSpIjriehN+eh+M45FXVISC8WBiNxB8NNauClLNIMthmE3NUMi//KX3Q6z/UDAQEfkO8B8H/p/Aey24oKqfi8i77WEfAX/hjT/7pN32g57v9wO/H+Ddp5fWjsW1us7Mjlu/tWUoNMAUUN8k/rUBpcZkxMWHWS74iPcd3kdUFB8GCxwYWl7WhfVwS0HYbi9AhHl/x3I84DqP5sx6tydj08tW9Xzw4QecX14QY493zeGsrNx+8gkvr16xeXJJOs4sKbEZOkqpuOCZ15mUlLgNbIbIej9xmFaevH+BHibmdWX36BG7R094/MGHDMPWfEnUEYYNYehAHb6PCJl1msjzgWW65+qz73H1xSe8unrF9fOXXL14wTQfOd7P3N2vqPdsdiM+mutYFx1933G+Pafb9oZ3xJ4h9ISho+s29NGYssE7wxpCQFw0Z3dvCmYxCqllAMGCizjzDLVxrLHNeDXwW53yMBHwgSQYWqv2ze/VbP0MBjT3/FqKZY0ewFinQdscZYQsDq2uEQmddVicvKGFAV2TDdfqfCMSWoaStRKCpxsDaYWyKBKUkpVSlVROg8IrXQzgR1LOLMeZXI1k6NZiOpVY7eNV5e5mQW7u6M8GFu3Z396yu3zEsOusCZAUp8LTp+9AVmo58vL5M1JKVBwxOkpZkRRZa8XlU7vcxml0zkqoWjLLmineMm3n29SCkqnV+CJy0s58xfW1A4iI7IB/HfgDqnpnWpQf/NAfcNsPRG9U9Y8Dfxzgt//Ut9VOl/og4TcFcnNpB2iEoYd0uZqtXK0VldhqPpAQrAVpk6WoteC8N4VnzTRuGXlZqbUyXF4yDDuO1y+Y725sk1rMRWuaFyQG0iJ8+J1vc352biBks9wXKsurF1y/fM5wfo6kxHQ4ImIjH7fbHfk4c/dijwbPbrujlML9/cz500vGWrk5HNg9vmR78Zh3PvpJdtsd1DYjxwdr5UZzSHcU0nEirQt5nbl6/hlXzz7j2RefcP3yFVfPb1jzxM2rO66uJxwQOk+UgT44dpstwxjo+o4uBIbYMQ4DwzAaa7Tr7bV8R4wdvnNtYLjDu84YnSG0sRnalKvmnubEjIqp4MIbkgEJbce3AdsVK1lEad601Tw8nMP7BvRqE1I6BzXiFBDXnrfNeGlWhCB4n9FsjnTOeZw30yMtrjEUBV1W8lEJQzSAshjFXV0gTYXQB8QF8jpbcBFFQqATpQRHSkfWaW3HwNOdDWhy5JTogtEPsmBDqlD8EJj3K2UpnD2K5rZP4f7FMyOedSaGjOI4227Yz5m0rKRlRRG66pEiFF+hZhaUtUL0ns4F5pSNrEa2bNjwapyaE1nRYoZLdWHN5WuEj68ZQEQkYsHjX1LVf6Pd/ExEPmjZxwfA83b7J8C33/jzbwGf/VCv0z6ijfMTqlTrFki7V8CsC7ET0lWESHRCUsgN8fZVCD62i9yUnZoTRdfGAYiIF6gF8T27iyek6cB094o1J1zwrGtiWWfCGLi/W3jy4UdstzvE9yY3B9DK8eoZzz77HNltCU64e3ELobBMlfOnT5n2d7x6/oIpFc4vLlEVpmWl23RsXOX66sjZu0+4ePQO73z7O2zHDeRieEGMeOcJ3i54UZuTm9aZmhZuXzzj5tnnfPa97/Hq+XOmu1vWtHL/6o7rV3skWItwHDq2Q8d2M7IZR/pdRz/0dH6gGwaG0bxEYm+GRG7o8S4SfWjvwUZDuoJ5iQaPl/CwwzsP4rs2i7VCyU3dakI1lWrfqStmQuQcNSe0JrNSwCwmfSMPNpMXOxdcQKUaWOis86POFKcnQF3wkITqknUaRBCv5sbvgvmhNsZpKYWiDsGsMbXmFizE3Ow7D31gTYW6rqgzzCPGSGWg6Io6mA6TZQrNpDtpoazmmKcCqwgex/mjLX1vbvjzqxfcvLyhHwfCMHI2Wus5L4sN3k4mMHTBU8vKSmHwXSPGddDMwFNdKaXY7N+SrS2tIGoSfwscBTRRdLaWN/FroSBfpwsjwD8P/BVV/affuOvfBP4+4I+0n//HN27/l0Xkn8ZA1J8G/uKv+joNIdPaZrLQwE51OEpT1hpYp42gY7teoNRCcB7VTC0zIh0eT0bRXAmSIDiqBJwEQjDBkmgl9D3UzHq8Z54Wwhgs+0gz6oTD/sj46Cm7sx0xjIRmB6hp4f7lM25efAG9Z+gDd8+v0WA8gThsyNOBq6vn7JeZfrujEwPLcIGL3cj9fmb37jtcPn2Xy/c+ZOiMR+G7znbWYu3HfhxwYEK3nKhl5f7mBa++9/N896/+DLfHl8zHA2leubm65/ZmJg6BTd/Rjx3b7ZaxH9lsRsbNSD/0JsbrOoZxQ+wHYuiJQ0fsBpx3eKz0s9LFOBISG/bR2rImOrMh1dKo3kKFJqc/OesrFa0JFWuhnng7tZxKGm/ZSc2GlpzKVgAxpa33rdkG1JzBGRX9tO0470CtpHRBjCfjDHytNdmxjM5IaN4DJ96EQBNtltmGRLmuJ3SBlUyeVrQsppfCAjkUct+zikMXI9wVEdxgbm9ObKxD9ME6g3nmuBamJRF2BqaGocOpUpfZtMQx4J1vfrYZlQHfBXIqjD6iXccxTXhJ5OqNU4NA7MzgQkx3I+opmslq4ztKdsQ4kvNvHAbynwT+q8BfEpH/d7vtH8MCx58WkX8A+B7wdwOo6n8gIn8a+MtYB+e/9at2YNpy3pQrriiWs/YPnA6B1qERUyX6SG2zOnBWNxtTz5MxPUMIxuKrFKSaX6j3zdl9PnJ8+Yzw+AlaE9PdrRGzFPKaERep68rm4gmPnjwluEDsO7phJM9H7l4+49VnnxsZbDtw+/KKpDNaMvOibDeO2xfPmecFFWF7tm3CPeHR+QYWZbx8xOXlY7ZnlwzDBueD2S0W4zV0/UC33ZiNf0qkNZHXI8frK5793F/jF/7aX+VwvGU53DHnlaurOw73M8PWsxsGtn3PsB1N4t/1jKPN2Y2ducDHPhC6gThucV1PFz0iVqbEOOK8NtD01D610gDn8eJQ37Ql3nAMm/xn35O0LEJFgYDT+ODPafiIZSLaeAwWgNo8ID253DbehcjDxmKitmLU7UY6rKXgm3+plGInTFU0rYRxA2repZLNRb1msyZUbT6iIjZbxSlpSfiKDdf2gvaR9TCzTnNT1zbjo1rZdJ4SRhSbc0NVMzVSQZYFYqVGIVcDajc7xzQJy5xxzKQQmWcjNHp6KAlqwqmR29Z5BvHUtLLWlTmnRrZ05HVhPy0MvemqhlBbsDWHN6mVXAOx6yk1t47lbwAGoqp//ld45f/ML/M3fxj4w7/W1zJSmLWrRBs9WW3gMZob97+lsShOnZkMu8C6Hpt6FitNxCz7nO/wYdPwE3Nul1o4Xr+Evsd7z3x7TSbjYmSdJ0unATZnXDx6TOci/WaLD44y79m/fMH1J1+g0dFvBu5evDAj4CisS2Y8v2A53LE/3DLPysU7jyjJUOBHl+f0IqydMO52dNsLdo8es+ki1EJJlZwyftiwfXRJjOFhHGNeJqb9LV/8ws/yyc//PHM6cjxa92Z/deQ4JfptYDP2nA8bNtueYdgw7DZ0/cCm39BtNwzdxpStMSAxEocNvh8IeLwLSIiEtrNRBaete+IDLgQI8YFbY6zeNgqyBXr7admBnuwmVXDa7BnEGYGPSK1mN1BzNrC1ZlwDVWklBmLjMjgpgZv9INm+VjBXF3FiHJdspLKK4rpkGZUNEGrtz4zOqflSKdr8U2uxyW8pr5AMfxFx5iOrnmWeUafWtakFzdbbKKUSnVBKYl0yOTVbToR+8MTNQMUTPezOdqQxIangXGE+7onB29+mGbwQx47D4UAmE6NymBZkCEgVwjBSc2LKhSyZnB1ePEkEtypFMkWUmjLeR9Z1YsnZBqr9RhDJfmRLTuMXmtCtqW4r2oR1Vrea9Y/tSuK9BYS2C6IFLTbx3dq7hsqrKkG8GeCKo0wHSsl02zOjrC8Hm8TeVJ7qQPzA5eUZVMHvdvTjiK4rh6srrj79hKUWzrYXXL94zv3tLc4X0grqB5wox5sb1jXRbXcPDtq7x+eMsWPeT4wXT7l49JTzx08I3pGO99CYl9VFLh9d0vcdZUmkZaHqyjrfc/XJxzz//BNSncnrTLcJ3H52zeF+ZrMRMxXajOw2PZuNzYAZx5FuHOmGDX0/ErsOiR0u9vg+ELqREAz38LgHjYhrUgKvoN5b9uYc4u2kPW0rNpBcTnw/aFMGrQT1FDkpWE9sBDGtU7NoqI1VLM6DhsZzsPJCfIe4Di/e7irV1NS+WvBRK3VrrjZIXZy5p0tFC5RlxY2DZTplBfWW3TZdVdYCa+YkUkMdpSo1N0K497hoTNt1hrxkRFfUGw9JayVGey6iOa5vnLT37jB7/NRMrztEIHYdbjTjoTwtUIWSZ2qa6frBrDRzRgokTZwGfW/HkcOycDwcUIeVZJjyvGolVR5KRocFxcM6Yz4Yr6vCr7J+7AOI0HBR6ahSGhFGOFktncgx1uitJtSyShwBootkPDa/wyomrRna2D+bs2OTwMq64LuBnMxdvBbjk6RstW4/DEgcKVXY7rb0XaDmzOHlK55/7+c4LAvn7z/leHPL/v7e9BPiWUum23Ycr66Y7vb4ITJsN4jr2F1ccH55Rj5U4tkl2/MzttsdvXeU+UDRgteOopHL9x8z9CO1FDSvlpmsM7fPP+Pqi89Jy57DfsL3Hcv1DYfrA10fGEfPZjOy3ezYbke2mw3DcG4zbjc2OrOPFjx8FxDXEfoeFzozJ3L2U7BWrPMemsJWneCaFsUC8+k7M+GWtjmyYN4bnLxspZrVgArqwkMirWKkQJtpro330eT4BQNK9eTradiYloJgylktphrWpBDMB8Sp8YZcNL5E8QlSpoupAaaFmuY2uKy1NX1jOdfTGJFq2S7mAZLWRD4WnHfE3uj40zGjSzYfETCLO6c29bCYX8iDgbNmVDPH/REUYozEYSB2NqN3s9uyLgnVjISBs91AqZa9zAtoDebgNkT2+3umdSKXYjT24omjp4rRHXIjmXk1seJxPmJlHtTqv9b1+WMfQLTR0hWzk5MTg72qeUugr6nuxk833cWpzhbBV6M3l7oAnuB8A+0UJOGkQ1NinSfCuKPzken2BaUmqjicj8TQ4eNArsru/JLoAk4ch1fPefbdn2XOC+ePHpPvJ65efMashT44pkOCrifUzLPnL5nxPDq7MDPlJ495dHHBcn9A1XG+NTn+sBkp64zmBRc9y5y5eO8dxnED68q6zqbzSDP7F8/54md/lrvr50zTEec8ZT5w/eqOgNCNgWHs2Ww3bDcbtpstm3FDN2wIg41/iN2G0AV8H/F+QIIFEe8707cIrbzQh9kpPIChFtCNCGZUaScnct8DSeeNTMRm0bqW0dgys2QTyBnGYSppMWNiNdNs9c2PQ098Y22MSt/qextD6loXprbzxWaoqJkoO2/tzJJMRa0exQaH5dIGa2tFgoG5tWYUe15qpajxO2qFUoR1rvhoRIMQmpCz1laKBZMy5MzdzR3RFbZnO7twSyEEZwEyeDJmyD2tleCVWA+IEzbbM8RHKzXSzDQpVOHy/JIlJebpwJwXglQmkwwjvo0ILa5pv4TgAt7D4ThZn6kZLIvwYDr0VdaPfQAxjYTH+WxsOwyNtxEOxqpD2g7U5OuINOBV2t9UUAsGgYAN5s5IrTgZcC4wHe/QkgjxnJIz67I3lN+4w3Rdz5oT24snBBepVKarF3zx3Z9jrTP9+RkpTdy9esmqmeBgnhbmBI8fP+bm8ysO1fPog/fYPnrM5vyM83FgurphWROPPviQi0eP2J2dIRRyWQleKEth8/gJ27OduYhNE7Vmal7YX7/gs5/5GQ6HVyRNUArpcGA+7MnTyjgEus3IOOzY7bZsN+aPOm43xH5D128I/UgYbCRkiD0h9s3pyzAPyzZak/x0nvmTUN+Ct4iVL3DyjrNd3MBTYwebwNaIZpUmS3AOr9qm25sniNZTJmLliy805TWcXLVoA8RMpGeaJm1DlSzQWYBxTeth5W4hp4QPFU1mgFyW8tozhfrQfam14ItpWiqKFstYK9Y2rim/pog7pawWfCxxEevUzJXpcEBioBsjj9+9YFlWUsqs80rRjPOeVISzizO255GSViKOZZqZVdnsdoziHnhMrh95+sFT9jeQjgs+mmAyZEetHrMUwgRz7drxCLEBQmldjPTe/ELsYH+N+oVvQACBhmsQrLff+F4ipoik+SBUOfFETER3QvaDeKqchMzN7cpwfEIYiGELy0KaD7hhS8Vo7iUlSzkJhOiYDyubJ0/pwgDAcv2K5z//M2QxuX0+zKzpSCURRJimlf1UePLBe3RdJIfA+ftP2PY9WipRYP/iFfvDzOX773Hx3vucXVxCzuQ847xnOc6M54/YXpwTvGNtu0ctK8fbVzz/7nfZ318b56AoN89vUVGmw8QYhX6zZdzt6IeOs3Gk7weGfkPXbYmDBRA3dHR9TxTDPk6CN3MwD+AUL6FJCdTk7f5koYfhUO3fNKNqEQV1J8pGa7HbxW6+pE0j3QhkZujTJspzEj5WI81JG7+Be915EcMQpDmNn7KcU7A4SfRRw8tO4Do52/nSzgEtdluhIllRsgWIE+obhKK+lbLZzimU6rC/LYWSKykl8J6qhVQrMq+stdjs6rWyLrNhb14JfcfZdoOLpsEJIRBiQIqScmZeF3IqdJsNYRhQ7ymlsE4HfAz4tND1gSLNUrNi5DiUsetYklkx9j40lwPTHtkQmDZ1serDv6v8dTDa0lajJzdU36E49U1j59oIgwo2Qph2VnLSyaBNLi4WoX23Zdg8xuXEPN0jIeD7DQ4hTQdyKtZLFzOq2T65oOtGnHccr17w4ns/x9o6NGlOlHVmmVckWEvP7wYuLz0XFzte/sJn3F/dcn65Jbmex08G0uGO4+FIt33Ee9/+iLPdjpwWyLNdJGsmDAPj5SO6fkNJZsdXc2Y+3HH38hnH/R1ER10T15++QoNS1xXJhbHfMo4bhiEybkaGbks/jAybjWkkeitPfDAvVWnMVnGhdTu84RvOtU6KPgCArYq02xtmYM3T074nDyQs06DYPbW0HU8FsIySU7u0YRFYwWC/K7RdorUioYFWDRA38pdrF4qWptRuPh/5NK+2ge+VSsnmeVqqoiWZv4YoSRVKxYhkQhJBFsC3rCRXw3TaSFQaMUudTdur82y7e1XmeSXXiqaEqtk9htib5WLNSDYsbrMbEa0s68J6nK3TlwtCIDilzJ7jUknzTD92zIeJ42GPOat7vBRciOQ62khtTTjN7RgJRZtyOETLzrKjF2XVTMEgwa+Xf3xDAohqs52sxbgEGttQ4CbMqtYerFWRUvD+jXS7TZs7gV8+mhHPdrwgOk9e740vEDd4EdI0kZbJiFLeEbrRzHkxWvbti+fcv/qMJCD9QE4rVTPVO/rzDcs00fUdeb/Qn3uuPv6cF89eEHY9oYvsnpzhSuF4PFAJvPeT32a72UJr3ymlAa+V3aMLNpsRyZmUVtI0G1B684r7mxviaNqNTz95TpWEI7Eejmy6yDAOjJuBYTMwDFuGcUu/2dFvtoS+x3e9tWgbB8Z32zbekgdM6RQOLKvA6OPYGAE9ZSQtO6itzJE2wEvrawsF1ZODnGUGRls/DV+yv6tkRO2MPonjTHRnfBCv0uKJqXQFpTprQWp7vAWshnVatDEs4ESHD560rGY2RYETM7NaKQMNWzu1cZteR0Kwz5QTNVWyCnlZUKn40NP1nlUCmoWiBdd3+JLIUqnqmHPCF2HoPYPLiFiH8HBzQ0qZUis5K2HsKS5wuRsomrh+9oxlgc1ZR6k9WTPTYTLyXAyG13ibupeLp5OKHzf4vjePFRWiE3zoqcFRnX0PRRO+VhK5OZu5r3xt/tgHEG3Sfa3VUstSEfHWkiODmrBJpEKJONc4A2KSq9rsDxGP78QulNOulmbW6UBxnhADOScjl/mI682kN/Q9Kh1e4HjzjGl/Q6Hi+8FYq6UwJzOMmV7dMC8z1QVjsuaVq1dX1KB0fUfYnBNix/HmjrUK73znOzx9/128eoREKQXvHdOxMFxesnv0mCBi+pY0sxzvyPMdx+tbQu9IS+Hlp89Y1pUueNKsRGxY02aIdF3HELf0w4au7+m6zjKt5pLlYwTfAxGR3hi8nLK018mCNFDiYc5wte6VnqKMVtRZxuJbOVGk1dhYyeEeLnBrJ0LDNTh10ZoZg9bXwKcWTqe2meIIFNNyGD7uoCZKqYgE0z81DEawEkdcpVTa53ItMFmnR9VsMRWFtYAotZpq9fQeThQA84uxUSCoIt4eU+YjVR1ujG3OWSU4JeDpnJBSQaPQdR1elVKU4+3e8JauJyfFR4i7gS5Y2XG83xtjlmqeKQr3r+7NDHmMZBXKshD6iCV1jRhWbIN1gK+erh/pus48YEUosbB6j3fWQq6xGMflN3cJo8aYaztPVVBJ2EnvUTH0vZm0AY1ToNYDP/kK+TAQYgcIod8QHZTjRHWR2I/UvDTatDESHILEzngJaWZ/c8Xx/pbj4YCgpGVhmQ5Mk81sWe/uWfNiCHeu0FduXu3JJbPZbdmcXXB2eYEoJBwX73/Aex++jyuC5hlpVnfzfkK7M84unxBQluNM0UKaJ1I6ctzf4beR9dUdt58/4+bqmtgcwF0xk6JuG4hDT98PdP3GuizDYFlHiDhvOhZzCfMGPOeGM3SnvANTkXKKGicwul3upaLeul6NGoYqlIdZJK8Dgp4cxLQ8IP4PplCn4KOlYShN09iYqEUrXuUh4wSHO/EailpW1OYhl1ofwNbmDfWgzDazKDWv08ZILW3cBLo2HxEDNqmJ2gqxWgt1TtTgKKWVyCK4lqG43uFqZTnsydW6KxUhVWO+Bu/pughqg8VyLaSUmju9aZJcZ+/pOC3klBmGQB+U2PekOfPqky8InQkKg1f8uKUWZZ3mNswbfBB89HRhw5Ry8/ZNbXN1eBlQHEGCMWurjXyQRvv/quvHPoAoWNehpLYD2If1D8rvJqpTTI0pzbW9tpS5zRDxDVhTdXTek/f3rGmFrrfSZV2ppTIf78lpRbyn3+xIxwP3L1+wLPesx8lq25yYpz3zNBmRta6s85FczDSm84FlzSzLxLjr6cYNm92OoYP9zZ7xbMeTx4/pxJy8OynWrj0uJPU8evqYvgus02Stw7KyLkdjPHpHOUwcrq949exF41M4qiacFFznCKEndCaCC30g+mjeKb6pYw2bJ/rebhPFBThROE8ZrRS11F2AarNPTPuBMT7VOiXqTiBpoAh410YuIOAsM1A182KnTa5WmxYGMRp2G/dQUWpZqam0dq+YVEwqJtdvRj20dms7H2rr9Ggx1bbtGjaBXhWaJ0QLXAkRs3JQzAuX4K1Ezkt7bLOMaMQrK2nMGVOpJvxTZZ2O5Fys5VwdzhUrUTzW2Ckz97eFEAWk57hMaBWqOGKoLKUQV6GPgbNNTyKgyXQ+NWVurq5YpwOj9Ih3zNPMruvN48OPjV0N85px3YBTwTUPEOeNIGncuFbOuUCIlp0VMZ3Yr6Cg/1XXj30AAUANSbZUtWs1uJG8QHDirR6WNvqhGvIuviN00YZiF6XrzFS3HI/m5CSCVFiPe3Mi10ReZ7yPdOOOdHfL7YsvyFrI08y8zoCyznvmeWZZEptdZD4eWJYFiT3RC+tSSMkczdRHus2Ovo/kpdBttzjfM4ydicQ8SOhI68qyrAxPPuDsbNfmviTQTJpn0jRRc+b/T96f/Nq2dml+0O8t55yr2sUpbvFVEZGRkcqMhmnRQUIp0QMLWiAaSDQsuYMEEkLY+QdYSgkJ0XYPCSFwD3pIILmHlQKJhu2MkJ2REfEVtzhnF6ua1VsMGuNd+36IhExupJ1ffizp6p677z5nrbP2mmOOd4zn+T0yL1yfn5jOLyzLondjQFLGe0cXtqrtCEFJ5E6jF/0tjImmhrSq+jQ24Bqp3oh6JfR9tI30LW0tWt5k6bqNsW1O0o4Ct4EpDerU8koAhVlX9LiJCsTktq9tLFt5O7YIJRcVyzU9yZvWB4stWY8vrnU3ekWriKx1Sqa2TqgU/VxI06qIaolsDSAF5zxJKpIEYzLVeuqSME6/rwptcFqpRTsxqVr2Usnk3LYwpSBFB5rFgPEZBJZVGOeEqZVYhSSVpehxrPPtCaxQS+b1eGLTRbYPB4wzXK5Xzi9nnC/EQTkfKuLz5LIivoMCvgvUuirxv1aWpKJHV1AWiwmIV9aNE0GqxbpOV+ZS9Aj0+zwDAXQA10b/QmmdxwoS3/QfzvIWY4hRu7l1tsVTim4cbMBRyeT2wQqk8cx4PiGmYK3HDVtCiIwvL5w+fVarf0pM80K1wnq+UNJMySvWCDklxnHBOF33jucF1wWWeYEQ6XdbDnf3hKDpbcfnK1//0Xt8k9hb65Ciea5m2LF/2GOyMkcslZJW0jqSlxnr4XI+sswXnp9etYi2OAFTK9YHXOfpGt3Kuah5Kl63KzcGWGsh9ENPbgR7RQrTEta4HTFad6EDSXQ+YG0rFkYl56j5zLVWWAArbWtBptTyw0BWqt7128pdTXS1raKLbmpKfbsrSk2Kb6hOZ161DW5FVafSDhvU2m40WdfIxrdJy83IdytcTeLeZiTORwTIuSreMkSkTIhYclUNSM2ZtSR07amQqoJp8v2IN5bkNDKEashLaU8ID4ctmco0J0QsGwc26s9DSiE4i/MWf7fD1sR4OlOqUBDibst0PZPWmSF2Gi7lPcZFgkB2Tt3YBJxUjCzkmnHOskiiLlc6yfRo8PmNwFZxuoqm4mr9/S8gQm2Ta3TELk6n5UahtRiDD8quoN4Y000+LEYpYU5XYzVlfROXhXR+VVlvaDRvH/HOcf38PdfTiUrSFtUIJliml1fSMmMxeGeZLiPLXDFicNGxziviOrVIe+i2PZthTxcD1nvOn54ZDvcc7rfUkgjdgJXKNI0UE9k/vCNaZWgayTqQLYllmrDRk04npsuJ0/OJecqYKsQhUOcZ5xyd6/DW6wzCRrwP+Ogx3rXAJKfFJDrwbfFaUtN9OKpT2LFp8GpVd1qsvQn42gykzSdu2y2NWbghJMFU/UAW0aJzO2LXWmk0KOWd2t9elrVnvIF+DS1pDmzVG4dek6UVIjUZ6sykqr6n6PaoUFtEhXZaFZ1tCVZDmdoRqpUXjPfY4ilkNdCZTrUfTljmlbIsKn4Tofpbop5HcNzyWFxeyVn1OMaUxuHNjJdrG5Tatr9ysCpKInaW6rSzSjmR8qpeG2Mo2bDbe/rdwOnTFSszYeiwRbNeqi0Er3oQWpBarSqkrOtK6CKpLJikm6sYWwqfdRjplAiHIJL+RtfmvxYFRB+3Xa6uCdt4A2Oa/KgUiswIjuA7bbdrxYVIcC2MqiZKM36mcWSeL/gQSLniu56aMteXJ66nI1KyGupELdrzaaSWQtcF1mXi8nokJ4ONBot+mHMV4jaQxoW+6wmhJ/ZbqnHk4xkRx1c/+YBZLXGj7uF1nKli2N7fsx0GPcPnQl5nak2slxMV8FTOT59ZrmeuL69IWbFGs1nWWgidAoa8D7gYiJ3HhV7NcCHivMNZq8HUbch5A1VjXbtr2zc7wBvZTdq2xfC26qxWRXuWlu7XNipF1KthjLbG0jJ25FbUpVJq0RnVrapY8zY8fRuvyq3RaE5caB2L3iyyCKyLDm69Mm2N+in1dUrTYEql5BmN8NDPijRn7m3ti1GflfNQzYrJQsktwF0S1TXochKKLLoNzEY/hkFp+CXDvCz6/I36LmJZ1kIqlbVkyjFpbGenXi0vYE3lMiZ639HvIxICy9RiQjvLMo3kvGKDuoVrKhr+UiomQilZB7cI3qg2zDXgci6Cc4ZSVnJVBIEzXt8kk/RnI0VvCr/fW5jb+dpiyE2+3mTrltZK+6YUDE00JJSUFOfvNfxIBOZZtzXT6ZXletIPYwP1lGVmupzJ80JOC2ta9OhUYLpeyJJwpjJPV6aLzlCKOGK/w4ljmibifgspsSyF7d0G7zr6LlKWK9cx8/O/+7f0p9xZXAyIMaRU2dw/stlsqKlQJFPzSqkJyQvrvNA/3jF+fmKarkyXK2mdMbXSbTpkLbrCtAHTOZx3eBdwjQBunXujfVnbgpDav/X411ilTcGLQbdX3ORg8jZbUB2IKJPUyNu2y/2W1qO2s6bOl3QToarp2jwtrZsxqIkR2pBS5em3zoCSFZx9qzO2zQykDXNR5KC5KVtNxqIXuzG8qVpNk6mLde1oZKlvWADDjQhqfMCWQjWh+TSFsurmozpPzZoHI0JTA4PNGVymOt6m+lUS07S2C1io2RIcxLuOaUrUccQGT7WWda68jivTdOHwGnj/1TuG/Y5xnLlernSdGhGHvqcUIc+JbpMpCZWwb3rqKs2BnDCl0nUd45roosP4DoyQRahWR+fKQ7upU+X/HwoIqO1YzVfGVn6LSa/nbaMqxxvqsBqtuCHokcSUwjyPZIGyXJkvR22V5Qb9Naxp1giGNLEuIzZ6cknM1wspzVAqy7KQk1BzJZeK7zf0Q0+aEn6zxRnL09NnhocHvO84vLun5InpuvLu5z8hosOsrh9wfmCdR2znFegrqrSsZSWvC9SV6+tZwTclc319piwzyzSRqVjb4WMknRdsWxV673G+a5Z71XXQYjtvNHsVarRAp5sEHIOxop6SW+mobUCqV/jttKKp72/zUV0R6hurxG9jTbPN65Wva8SmIZFWnBoYB36YS+hqtc1lqpLUG42ncVDbz7utc4233PAAt6NIRZC86Fq41jfhmxjB1sxtQa+D21aZWodlnNXEuqo2+GyKyvaNobhMMYk1a+aKMfpyMxqd4Goll8TpslLzrMTzZMBlirG6ijYq6LKhY55nXQnbSIgBnOP1fOb05xOPhw3bx13LAbakkiEJ9+8PUCGVQrSekjLBVExU2FUphmJgmWZssCxLgmlht9vRdxFpgeT27WdbqDVRa/obmel+/PTkv8THLdJBc22VfCWtnb5N6Zs3GetMy2D19P2AKYnxclK133Tm8vQ9axoRahusKmeipIKplTUnfIyUZeHy+sS8jiCGcRpZ0kpaJnIuiPPE7UAtOkiVmrm+nAnbge12w3C4I1jPdFrYffjA/d0dS6rs7jYED3m+MI8jcbPVu5xUck2UeabmieV8JOdMiJ7x+ZVlHrlez0zjrKwLp7MhqYtS0n0k+qgfKBt1hecdzmrOi/O3OIS2hTG6uTBNPKa15JbQd2Ov0MxyTYjVZFpv7T8GKa0NFvTXSYnflUpp3cRNFFZrbslxb5OPtj0RcslvUnaxRl2ztH+MZvU0LaqWCgFpv+et2/BG7yaltNygllrIzZarAipKwwPUdkyrCm823mootml5yT5CI69hDaUK62pIa8EW5YRcryPn80RaEt1gIDT8gEsgFY9oUBSGPCUMlX67hRhISQHYvgqHuw3u0PEyrhyfL6RVjXeb3pONYT5dEamktGKt4IaIdx2H3RYXPNZ6ahVmgc/PR8Ay18rpcmIZR2zNOAvBts69JnKZmZfp99uNC7Rdvv5ziwzQO0vBoKGq0pR9xqlzMQ4dMk+MlxPrmoGiStLrSc1gKmokSEdNs4J8o6frB9ZpZFxWquuQOpPHRVd2JWnmRhfptx3eVcbTzJzUgk2I7O8eGHYHdvsdzhjuv/yaxw93rOeF3d0G8kqqiXVe6fo9fbd941XUNJOWEUkr4+lKf/9Amkau51eWcSQtI8u84A14b6jXrGHV1uLfBGKWYEVXs9zml6qNcbbZ6q0Syqtep29ZK7duA2g2b/2FGPXB2NqOGDfdh9xqicrT1aOrEnWpP3wo9QPaNBWmHYmawIlSVUFZb94a1UBIWy2r3V43Q6at3am1dU3oTENsQx+24iPgRHUaWMdtkmuco5byNiTWYoR2IzljrQaAV3E4G1UHUzMpOEyOODuzLCu0garpbsbD1mkVXbPWNYFxjEvCGSEYQ7UOiZbrrMl7/X5L6AbWSUHIx3mFXLHRkF0zBXrLkoTdfsNyHfG1gZvPV+qa8TawG7bsDo8cz69InrB5YS2Zy/GV/v6enBfEqMnPrxnXNZ2/seRSKCn/vheQdoYm6Ioup3bOrTrtd0mLiDUKwHGRQMDmhfE6klMmp4laCuP1zDLPbO7eNaK1wzpheTmzjBNlnZnmiz6rMfTbDXIVcqh0zpJTwfdbSkk4FKNlOs/2EAk0nkbwdL3HWkGKYbsLLMcLth8IAWrJrFOiimO3P2AMlGUGU0nLxDyfIRWIHXGz4fTpW8bTC9N0Zj6P+GBVLu2FOmvkgG/ZKy5oJINrjAklpVuspQ08Ffhj27DRWT1S0dgqtkhLqGvf1LJfVGUqKOPCcOvh36z0AvhWGKSoyMx4PS61I4zOVTTeEtdWuAYk346d2sFYY3TA1xy3UlToZdrRS4ehbaVsfmstjVBLAmPbVkaHqU1FBtJSDCltNqIkc2v0NUk1ukauVUOs3o5oKkIM1pNtwFq1xOdaqbOKxhJFU/jE0DtH2QzMS2YXIutcSeuqHiygHwJZlJQWrSHut4hz+LSyLIXLeWapmdNxggLb/R0iwvZhT75M9LtOwcjrTLicwXTsH+/Z9UPL+7VsSmGcF/w0EvpAKhaTVNuytJlIqSsl57+RDwb+dSgg7dxcxSI4qmhraDFUGxv1S4ihI7iodvt1ZBmvynxcV9Z1IeUFvGe4u6csM34YCCEiy8T1cqFI5np8IrcLK80Tc4tKYEkstRK3O/J5pKCisWVZyQKdEbKt5LQQ+g01bChG6AZHWVac6zjsN1hbSPPCOiU2H74gOMNyPuKtp8rM+PqKDVDmwubjB+q6Mp9OzKcRqZl1XIkbTy0WKwYJCuV17VrFasarMUEVp2+W/NsMxGCqHmGoAkGLhKk617hlqcjbNuM2ZNMVrGkbF9M8IbeZhx5/bsegm6GuAYl1/6uFocGW36ZXpa1srW2F42asa4wQtV1zq1nWqPitlhuWoapupJZmuFRPlLmt/W+D4Xb4Uid/W+FaDW+Sm/emqU2NEYpIU9rm5qtq7BKrcKmaKsZqwJQXIXSBlHR2U9u2wxpDqhPeK74xL0XVvhW6aHFBae7OWZw39HHA30fMTzrWpjOazispzXpT9LoptGLpYySXlbwsrJuZ8+uJftupnKAKve0I+43Ol9TbrKjJWsgZkhRSnknLzA+y3R/3+J0vIII0XwRkVEykTk+dqEsGG4PyIX3A5IV1uurZzjlSWSllRdKk7WopEANhu1Vj2+mZNF2bP6AQh475fFa3rGRKWsmpYPpAni6MxythF8nTRDKB0A/gHJIXum7LcNgwxAiuI4SOWiu7hz3BWXLJrKkQ93v6vmOdJ5wz5Loyn84IGUlgY0/XRY6/+ZbryxOFxPw6Km8zqTHLlKJ0MGtQWGtb09m2ecGi4OPbMcaiyQnqnRBTMEb096s8Uy9+bspEvXMbq5obe9t43WIinW3t/235epOvVzCNEPYmH7+JlVpHYOSH7Y6IIgkdjXbW4EUW7Rqq18LTXp9U5WpQQaqFRgjTF966Ket1LtYS2hSGpBs4ayOStLMxTnNzSwuzohUpcV7VsDlhsEolswaxAbEz1SjBP4TKsgrmMuF7TzVGjXve0G8jJEtaMlEUPJ3zhPHCuGTc5IhdB97BkiFEfBVkzdi04BD6fY8NhrRUcioqRkSbw+gUuCzrzFQttSx0uw2XqyHnwjJPbIaeoRvUM9aORLkoJFrSQi0rRdzv9xFGUH2B3BhY4hCpVGOp1hD6Dd4M1KKekDyeWBfduNhcKPPMcn7BhhaCFDy+39JvdkynF5bxTC0Lxg10Qw95ZZkuWrmzSrCN14HJuiyYIEBiqpV+d9Bc0nmhiOfu3Q7vdEW33XXUlOi2W2IXdaDodJjnnBLNa9U7X8kjeV3UYTsJ2493rOPI8ftvGKcR6wrT6UroDRQhdJ48rvhosAFs0PwQbzXWwrTsWusM6m0JqlloBUdXu5rFcgMfi/HcrnGk5fBUHU++cULbRambi1sqYNuD3Pgr2rrocLTexErmRnhqKETle2ghq5jqmghNQdc6VxA0gKrNWUQLk3HqmEU83OYkt3waBFzjsNbGHjEGKW3TY2hj4NvQtwGMbsCiylvEhvHtNZdbx6RHLWMDYislJZx1hK6yGsP5PLPZaHpf0RUNXfA4o9m9UgpiO3xweF9Z50TNqxYl57FieHk+kmtptBMwYYEkvP+wVQFarWQDvmZi8MyrUtZ8L0zTwmHo2N/tyZLI1ql6umgou/GajeNvN7JcSVn/rj++fPxrUED0E61p7HjXksgiLkSQTJkTxhn6/SN1vnB9/Y7iO0LcsZxfuZxeiNE3N6bBhJ7t3Tvq9cJ6nUilgDPUNVGkUuZFVdFJKOuKmMiyzlgT2kXeUeZC7HqMMyrmmVYOP/mgdwijKDyqrgGH3U5bf5O5PL1QsGyDpZaEVKPxguOFXCt2ddg44Hzg8vrMmpT9sJxnci0qTTfmpqBrMxyFAgVvsc7ovMM3J3GLWzB9aNsW1+IdtagYgypDrWpDtNuXNgNpm4923WsWi/63ejhu8ZN6ZBEp2mVI/X/tTKx2Da0VadsU7XrEg6sGic0oJ43tcXsZuFtz1bQe7X1tRa8aqCYo7u8NFWBa71SptSoeqNL+XZtTp2iYbBUoqBHOAEawTabOjfSfF0QUFGTa0NViyAK5AZu7zpFy5XpZiF2m67q28Km4oMK3EBxD1+ncJVi2u+0tkYQqhlxg+LCHoEuBEAKbvqPUQr5e6Fwl9j3ZGMqsgWiu78nTlW47YDYdNQv39zuWmhg/PxG9w3eOJBWfEsapo9hRcMGTGhqB3+cOpA1B9JfGtDubtqZSKthKjBs8hvH4RMEQu0E9JMuVOHSky4lShc37j2zv30MpTJezCs7WlZJmqgSis0wYBKetsXMs1xEXPHlJb6rW2VviZo+pMM0Tm8Oe7W5AiuCsZ+gD1nh2hzv6zpGmK+vpzDIubD+8Q3ImZx1C5jIznq/EISJVc1XzODIeNY6yFGE+Two3cmqOM0lt4jYE7ThsgNqS5lsymzPaNhuvd0FrLY7GOqVBf4TbZARzk1q8kdW1s6j8MAfBtDu9bXLwtjon64AUS/PJoANmf6OXNQB2bZZ8pwNQpIJUBaDfPsO22Vite3PamrZOru31WaPZQIhCnjW7pbytpmnHrBt+QJoMQMoPuhajk2VwAVNK6150+6OzG2kFBQUVt7+TbmrUE5NTxjrBYYjRM06F8TJTcsF1HTStjfeBda3ksrTXqMdQ33XEEDVx0AZstbjgwVrmNXF9fkFK5jKemZ5P7DY9X/zBl7jYs+SFrh9YnCOPV+K+owiUOfO4PzCOF3KuBOMJJmo5bB3HWtRRLrWq3qb9rH/M41+LApIlN/BJJddKsJEyL4AwHLb4EFgvL+SaCP0Bg6WsV1zsqOOZZZrYfvjIsH2AXLiezhTrqGNiXSbEqOS3VsuSEuuyYhENc5KKF4XW7HZ7xuuCv9vjXGS5HDHW0u232oaHyN3HD7Dq0aXvLGkcqaUyjSNh6AnWkJcV2/dQM+PrBR90bYjviH3H63ffc3p+VeHQNJGXUXULxmG9pWRNjQ9OtQDe91jvNF4ydG9bKf1H7/i2trbctspRa8uFtTqzMLqRULSgbqH0Ym4sUzENytN0JBXdg0s71oAWEGO4ISXfQGHtGKSd2I3fYd6ARXKbebQRKmLb8wumPYfY202kCeAEpa8Xpa/LKj8AgBpf9db0FJTmLq55dW7l0Uhz/GpeciZjxGNNBatFoxpLrXq0qlawplJKwuuIiZKFzgYwmc2h43gqnC8T3VoJm6CWvWIx3jMtibyuWGpbu0+Evsf6Dh88IXrWM+R1xW8GLlMGyZg+MEbL06+/Yzqd+dkf/pTN4wGLELuOWoW0TNjesC6WznV8uPvA8zhjaiatK8ZBZwO1Vpz1ZBcxdoHb0fRHPn7nC4hBA7FTVYt3laYbQOjilj5s8LXyenrGbHaQs6L/0kxZJubTieHdR3aPXxFcYLqcsEEjGdax4nwgM6ipKFdKrrpBqJU8t8FrDfS7jpQzfn/Adxvm48haKtvDnrt3H/B+w8OHO2RcKCL44EjjiFhDukyUWjA5UZdFJeYGSl4p68qw2VPFErpesQHHV2qaUGjalZJXfBcxKetFX4uuBa3BR9viFn0bkJq2mUILjnFvebSit35uIVDW2SZjr9R20RtT31a33IRdVVuEN4PdTQBmbTNlqeKkzT3bD06/Zpor1xqjw2ZRx61kte6btoW5gZoVHNTWtVVX5Vjzw5/bTHuWNltwuj61QZPn3gKlRPUr1FtZauwReKO4vx2boOlMHDXlljNcoLQBsIM8aWJdKmBcgxkZ3eqkNUGngsS73YaztcznkTSPxG0HvaMLnsP9gWlduZ6vGKO2g66LEDzzCutl1g6Byny6MGyCMkaq42dff8Vpd+C7v/ol45/9E/74T35BHDr6oceGnpozJq8UY5lny3a/Q2zgOk2sZmzwaFW/LMuVYg2SNTv69xtpiBLJvLNU21FKAixGLP1whzeG5fQMvsPaoPj9RvAqeaJ7fM/hw5ewLFxen9H6IJSyIMuEqQVvDKaLEAp9UpXgfD6SjXJBjBXCVo8YYdiwzBNhE+h2Gz58+QW992rPH2emKXH/4YFghEkKtlZOr08Ua9g89jrRdwGphel81TOvdYjpCMPA+PTE+flFg5CvE+k6IVkIh9hiBBzOZbyxbcbhNKIx6F3uFvxk/M3IBrmKft0UXe02xqdp3YR+rJrLEPvDRXXTbL/NL5rADO1k3jICReMaMEULlLShZbPai1X4MujTGIHcZh3G6fzh9pymGt0OQeOM0F6rfdukUI0eNRyY0qT4zmByy0ORcvPstidUBYhtniqMQFP/GtE4hlrVNGmswXpLzUK1BUm0TRWUddUjF8qgCa5SU2HNGQE6pxuf7bbDeUtaC5kCy4TJlWFv+eLhnvxwz+vpynS8kOcj23cHYugZDnuMKK5zKZXTy6u+V+vCtg/c393j/07km7/6Nd/95nu+/MWX5KmyEUPYqGEw14othWWe6YKnRM36WarO0W7+pJQXRCrTkn44ov6Ix+98AQFACimtiGiCFzbQxwOdC5qVkmbicNAVmjGk6Uythe0XP2W7ucfUwvHyPWmdERqvsyTS9cK6ThpjWCtpWRnHZqU/XnDBE73VjqV6JFjW45lxnAih5/DxgWAc82lic/Csi2ez2zJ0kTRPeFO4fPcdJc9s7h8ITdDgXIM3F6HfbxACw2GHpMTp+TPTeCH2bXZSVqyDEFSWHmppRcPjbSD4hin0vhGobm5b16IP7ZugSjCNraHk74pgbNNitOpw24LQVqPmFlTeiFx6WVb1v5jfggI10xyoXkRud35rmt7ih7VtbWhDabMQc+Od0jZE0DqY0oapRgtv5U2JrHyidryptwGOCsWq3Na2pXVVesySJokXpAXPmQY6aoVO2kyn4Q+l6sbHok7ntMxIzUgxuACIUavBmGBNrM4S+0gMSrZPsTKNE2UtXNLE1DCY9+/e8e5hw2UIjKcL67QSHaQK/aAQINsF4sf3LOOqmbxAGDZ89fjA3eMjr999oghEr8P90G8QMXQhUERYl5meDidaLN3WMU9n0tL2UC1s3Dr/+73GhdaFoGpGWwqd6xmcp+aVtVb8sMd6fSPW8wXbd9y/+4p+2FGWifPrkxKuiioH13XC1UyRDEbwYkmlUNaCNaJYw2WFLpLzQjAG6TzL5crluhCHgd3DA3f3B2Ra1OnoVBux32+o68oyX8jTlWkeMd6zuRuoSyVET11WxvMV6zR9zUbNbDl+8w2vT89kUymjyqbrqlN9g8U5C2Kb3ydo+2kNzlowumkxJjTviFXFZ/N2mBYuJFWt6NSk31Md4n9wp8pt5nEDEP8WXf0NfWfA1ls0qNrmlaCu3YDIbbuAbkzfaMy/ddx508q3Uwr6sxGjcnlTCpQW/CS6vsbp67iZ/6W0UWnNSmYTtDCaG3ek6qq67WWs1LcYivo2QJZ2bGqakNTmbY2YJrWopZ6qx9Kkmzc1AVqcy8QhsF4nirWk7AjO0sUes66YfmAOlbwuLLkyPh+5jgsP7+7Y3D8S322Z08rleOH5u2cOh8h2v2e/eQATcATW5FjXhfE8UtfIdrvBf/EVoRb6rpLnmbzMxBAp60RxAdd1iLE4CimveBf0qMwVWRIBGGt5C536sY/f+QJiMATnNFndtk2E8Uhe1H9gIW7udPe+jPjhwND3bPqB+Xzkcj2Dg7qUtphTUVReNTjKO09qTs3cdAlpXinOMnSKRKxGfyAmCY/v9+QKwcN8PUGx3D2+I/iO4f4OyQvj8YzYxHg+kSmEMOCMpzZtQ1pTw8x5vN8St3tKKpxej0zTjAuGeZz1+7LFbH2z41sMHucMPmiOixah3wq4boNS0zQS1aLGsGZEVIyhHgN0R8qbErVVDF272vpbq1PRdHsjOKd36Hq7a5V2shYQVFFab4NY2tZFuO1i33Qd0v7TVKNQKNDnRu/8tmiHIdg3Ejr1xtpoJr5WSiiZ0mYx0hRht1iDW44MIu0Y1ZACrbqJNZDQPxdUrl8zNau50jhBed7a+bgQyClhUlU9SFXjXhh60qqydf3cWsIwUE1Czlc8QrcZYLeFKixZMONE3++43+7Z7rakdWUaZ06nGVsv3L2/5+6wIcnAsiTWdWWZFi6nkf3DBosWJnGOZbyotKALOoiuqp8qbdMyryMmRroQSNsd6bjgLJS0/I2uz9/5AoJUyqJmtjDsIReCAQ3/0JVuzQUfOuLuUc+rJTFfRpZloUxn/SEX9QkUo7b11HD2pVaF9lbBh8AynkmpEDY93W4LNrDd35PmSdWjbYVKEnwMhMOezd2BYbfHGWF6PZPyitQLyzxTpfDusIdScU6n/zlX1qlw/8UDvhtwRrgej5yPrxjXztqlkpvRyTqDWM18DaIDU4JSsaz1b54UNQmqIpSmRtV7bEZ/1AowlpuVX1okRpuR3Exu1Tmsa3wOBMk/DCBvUGuNWFDmqDO3gpF1uNrWwPKmTNOFUAWl698KCuhRQWgrXdVlSFUql/69tThVFBp0KyBFBKo+XzVQm6dGbnMOHeLoQNU00ZncBirSjmZaDI0zylDmhwJXKtScQcrbqlhbJYcNllJWrHG4uMGkFVkzxEBus5ScC8Z5tpsdNg58891n6mlku4244JiXlZJVXeqyJYZA1/fcbXdgLLXYlodb2Q4dh/2OimWZE8s6Q8o4bzCxx5mVFDr9fgPeOuac6dpJ1AfPUjLreIJSiSZgdnecp1eW8nteQASlfPfDVrUKzd2I+LZFCLg44KRSsrpu0zIhAnm96kS9SaQlF2wMSJ01N9UbZNaVbS2VsqwslxMSHPvDPf1hT+wGptPEfJ1ZziNmGHBdx9Bv2N4/sr2/ZxMjDmG6XpnnK5bEdLmCUeyc917bf2vI68L1dCQOe0KMQGU6H3n57hum8azI/2nCGYFc8M7SdXou9k1ApfMOjw8tjtLZpu+wurGwOnvQ8USjctPuuDnrPMDS7tAqZNJmQecJprFSMJZai3YotFmIvc1J2lD0VhgMzb/ywzC2nVYAR6lZX0VCO40GU7al6TTKTbGmv8l5vYhvu2ArLQmuYQzbcrqBikyLr/xhdiPN8n87jhljVQ4vtik92+s0DpGkRzdpR7KasE7IVQumypB0gyQq39R4jjXjQsE2DcmSVl33GrA1YKoOdTfbgT/8O3/E5+czp+++w4yJYWtICdZvPvPwsGfY7liKoQuRru+0/lVHqcL1PBLGkc1ux/1+YJXANC7kOWFNJViobmEaJzBCt7VgHUtSpVoI6jKf8kzOK10j0R+2ey7u91zKbowhdAMmazu26TdYG7A2Yp1Vd+yqqs88vpDWBamF+fjCMl3xXcCHDeKF4FNTTXZIX6mLxdi52cCFcZqofsfDh48Mw4Y4bEjXM9PxxPO3n1gxfLzbM+x27D98wW6/wzuDs7CMF5bLGWsy6+n0dieKQ9TZhXVIzZxfTmAM27utDm7Xhfl6YRwvpJJZxzNBCqSVmjNd12O8w4tROJKNmmvjPc516sL1op26bQFOVRml3Hwut+FnKwCmmcXkBh+1tzu2BlRLEXK7u+vI1EBRJ3GtYILDhLadEH1eJYQBtwv77cghqh9pRLLa5OO1VqxVoVptg0vBaGFqUaX1NlsR17oXfkAMvNkbePs7aMKJpSCIC+1Y1zqrNzqZKkqtUXpZkdsRrCCaqdmKhpYjXy3VlMYJASdF3wPrIC8sc76ZLNRgtyRSNizzlXVdCHMgli3e9zz2nu1Pv+RyWUnziDNVP3fzpOrqYWBOiWvK3O22dMNGGbbGktbMNK4sudJtIh7wvWddVkQ8/faAQZ/ThBETBkzwVDGcryN974kuYDpLyZoYMF9HhmHAuh9fBv7GBcTodO7/BvxaRP5NY8wj8L8H/gD4S+C/JyIv7Xv/AfBvoTvD/7GI/J/+BZ6BWivedyqccT0utAvHeqiWrjNcn75nXUbdy6eF6/WVvCZ88fQuUksiLSvDdkNes55lpysh9lAEuc6YLnL/+JEQNKx4ffrMd5+/4/j5leNU+cmf/ILduw98+PDA0O2IocNaYTyfyfNMyQvOLpqRG6w6L7d3+NCR10xaFmo1dNsdwUfEOrIsjCfFDNSyMJ9OuPsN6ZwwoqzTYL1mz1qLi775WcLbCtfa22zDQutOjGuYQ6cW0IJg8eqqbRc5zuqRoGpWq6g+XS+HmnTA6nzb5tYfOpAqsBZKcDrlbyKv24Dzlm4HtKLRgMiuzSiagxas0ruailTQrYDlh62N5udWilTFHKI6lVuhuula7NugVrkn1TcQkDSgsggY3yT3ob3e0o5bWmiwBfMmYrOaOEfStb80cJFTfYo1ujpnsVSvQ15rIPjCUisVjX3ACHa22G1AihCc5bDreWqaFRdhXgr1cuUQDHEYECLXeeL15chud2C72zNsOvq7LcZr/OgwGLVgS2FdM3mZ2MXIOJ6VvFaqdlnO4jo101mxeKD6nvF6JZVEPqa3YfaPefzL6ED+J8A/Bg7tv/9d4P8iIv/QGPPvtv/+d4wxfw/47wN/CnwN/J+NMX8iIuWf9wTd8AClYp06LWmTfusDeRq5XF/JaUGyshrS5UhZJ2oR3H6PC4G0zrhgKWmi1pV8XZkvJ7CB6+WqZrX9AWsN0/lE8JWX716ptrIYy8c/+QU//YOfse03dD7Sb3slqp8v5KxkLB+F8fNFIbgpMWwP7O4OpHkhr4l1XXDeMdw/UG2HqYV1GplXzeM9PR/JpeAtjGvCuYCLUW+wzhNshzEqZ/exx4QOG6Natb3K1HFqqJNmmzcGjIvcMirfbInGvuXiVNAOoOZ2JwVuGgrR+UCt0o47ese2tpnUqqGY0qJE0WNPs75UEVxt9DB1qVFquZ1NKPmHmEqVdVWkoIM/UAdsk8tLLW0QrHSvt/NRWz23N6kVBIU2GquUcqr6jlQ8pmY+7Tpc63SKCumsp/oK1eCtQ2KlrFlBP9D4z4JkzbN1xiKda++dmhqNDxiTSKuuqktKrCbgh4wxliCG7SbSD+8Yp0xaF4xTKfw8Z9Z0whtH6CO1t3x+/p7XpxeCh/1uw257YNgPxM1WZ0S14os6q3NRUr9zpsU2+BaEVQjBQbScxwWk0m8GlqkgdflXV0CMMT8F/lvAvwf8T9uX/zvA32+//l8D/yHw77Sv/+9EZAH+qTHmPwf+q8D/9f/7c9hmx6444/WisQHvHHkemU6fWOcLkjImBNL1xPV0ZFlmhvcfsV2vE/EQQBJ5mjFWyOuk2aIZrO/o7vcYgWUcCZ1jPl8oUpnGwpc//wVf/ORrtr7DGsf27oDNM+fnV6oI1ipOr0wjq6hYy8WesNlQS2a+jFhvyGulf7jHxw4jwvhyZLpqQt40j3z+7pn37wfqkkjLQrcZiKHDmYgLPeI93kVC6Bs8qblubRtYGmWdSkUNfeiQVKw0eJCuM6smYSu1/Le1FBgMhVqVnVFtO7qkhFRRSpcRqqmUqkNUEV2TFgNWqg5yxXFLoqwNJoSpDXfYPCq3gWU76hjX+CIYLVbcVrHqvraAiG06Ef17aMPR+KsNuOyaEVDnQu3/WYcUB7a0TkZAPMbrhsKg7mjtSJTOVqvmxFiXSeIxVJyNdL4ym4Qhk0vGG6Eax2IS8zXhu6AWClspS2KpClhK46pwpw4MPVvfsX2wJCkcTzOyJvq7A/M8IqkwzzPORu4e9kzzwjzPnL+9IsuvcC7w+P7A/bt3DPs9LgbSkiBPhBBIWXDeUZzgEOalcFoWur6n6waulwu2LOxih0al/avrQP5XwP8c2P/W174QkW8AROQbY8zH9vWfAP/Rb33fr9rX/t8exph/G/i3AT6+f1BbeRV836EtqkPSzPj6PWk8kZYLLu6o68J0PJFrpb9/T9cPeOOVZNaGiJbKeJlxPhLMhvN6UjXivJJSwg4DZc7MY8b1A/tt5PH9I9thSxcHtocddR15+tVvlPhlrW5EamIe5x+cmE0CLQh4T8kLvhvoNjtMrYzHF+bpwuV8ZZlGPn/zmbQUvTOMI2XNdI+a56ur2ogzHheCslyd122CEcBjaC07egG3sbFuD0oTf1ndnYq5IYj17sStC5Gia0wUB2iqB5PV7m4gkeBtH6OU8xs9zIgK4k394c++OXtVsFWpN/CPFKSsutW9WfFLbd6b23GqzW1a7oqa4Ix2J06LpLvFZ6IdmvgbeBtVpkqT5IuupUV0tVtvGhGDwoKchZIR47A+U7JGRVgRqvFYrxdYSejPoRfsVAmigWDWVWJw5CrkdaEmj1jY7DyWLRRL2AREPGlduayvbDYbjIn4LvDx3YEpCSRheBgwVYlh61qwRcOp6v2O8ToynUeWceLlcuJ4urDpt9w/3jE8HnDxQD8ETFGAUHaV5XomOBhzYr0UtjshDJHLacIulVLTDxuxH/H40QXEGPNvAt+LyP/dGPP3/0V+yz/ja//M0ici/z7w7wP8yR//XDCeuNnhrE6/ZZ2pRRPb1jwThg3Gea5Pr9QYGLY7ZWAYpx8kNG6g5EIqGRf1wh9fj5yPJwSrhO1+oCKM1wmco9/sMN2Wx4cv2O53bIaO+XLi27/6NX4I9FYVjrGzzMcVFzbkdaakFWMd/XZDWVLbBAQ2794RYs98emW5XKllZpnP5OXC8XiiPwx477hcR2If6GKgC15zUDvbwrN6jFPimAJ7GsjHWs0qserCVT1EE4dJoRSncKG2NlVuaQtIkfqDCvO24gWkLD9I0NEIRozORJyzDSCEprc1MDGueeukoShvR5+c1TWLmsUoKxinehOjUCEblFBujYWqXhv1tjh+ADHz5t+7+Whso6C9FQPqG3JAuHXoemyxxqmVv+j6qLatkmARsfjqEOeQoh2cdZ7Qa/GotlLW2o6rvq2UhXVNYCoxOkpxFEnMl5n5gs67hg3rOEFx+OConWUuieAMtRrcCEOMxLueLKpQsGHDUDMlC9OolP7DsGHTbZinmet1oswTqc4cL5aw2dDdH8hLwtRMlgWix/qIqYXMTCkZO17wnYK/53lSLOiPb0D+Rh3Ifw34bxtj/ptADxyMMf8b4DtjzFet+/gK+L59/6+An/3W7/8p8Jt/3pMYY+m7HcYZ1jlpi1oT0+WZvI44rxdJXmbNgVmgrJmwjW/ZsGUadRBXlOnpDMzjxPl61on9mnB9h/eeLBU3DIRuYHP3yOO7B7b9QAyO6+dPfP7+ExIM/RCQVOg7h0l6t8zLSM6JWmF7d4czhnktOG8x2wNx2DGfL5w/v2ADjGdFFZ4+nRjHlYcvD6zXE3mtHO4HbYddRFwkup7QBY2vbBzPtyLS/m1saFAu7bYMGroNokHTqYmtrA7fbtekXmBqd2/3bG7QYeoPHYEY7T3UWq9bJnXy1h/a4JqbkKy+acg0jCm3zJtKyUm1XWSFHjndCjkqRjzVeUimdUw0UVtjcRiDOBXOaauhfaWrtcWEavdkQbEDonhERQ2omdC2zRS3LkVaJ3LbHgVp0CCLy6qatdaBM6xFCK5iXEc2LeuGlXldkUWt+zZ2pLWyrCPzy5FwGdntd0zriqRM13ds7g/QJWzV6Ic8OuarruZN1zPEQLc76Oe1W1imSTeMpSg6YLFkEfK0Ul3gcr2Sc2XYbdlsN+Q0k6rqmyRV+q5nLCeu84SZE90wEGPPLSz9xz5+dAERkX8A/AP0A/X3gf+ZiPwPjDH/C+B/CPzD9u//Q/st/0fgf2uM+V+iQ9S/Dfyjf97zGOPwzikb0ltqWljPz0ynz2ANpRQdEpbKcj4R93c464kx0G92LOOJUmakrNR1Va2AwPh6pIhFQmC79aw34U7N3L/fMxzuGLZbutjjXOX88sTx8zNFMne7A7VUQqcT8ev5Qk0jJU/grDIeRJPeYxcQE9g+PlKWhXQ9aUiVwPH1DMx8ennFRcc2Bsbvz7joGHyPD4MS12MghB5nAla06zBt5kEzn3FDDKLrT1P1qJAlY2XVi9kavHhunEys1w1FLtqsVKFYhQ9L84KQdahqjKo7qeUH6XfTiRnefPt6REoKJ66lYLyn1kIpLTAbFfWV1v3UAnidc6UyY1YHPvKm6KINLqXiTMBYUfRA2zrZ3xKkgc5IpBqMZKxXtoZvjFbfOjdcgztb7cpqW+9a4wnSNREcGMkKGspt1dw2Lb7NScRFis+4ajC5soyZkmbiZmB32FJeF7Jo/sr5+IzvesTC+TQyzzOb/Z79/o6w3WAbonBZMnVaqMvCJt2xvduw+/COImieTEqkeSEOd7z0z5hq6KPmH5WSKOsMuw3dZk9NE+s8aSEpBms7kqwImbomhs4SffjBovAjHv9F6ED+IfAfGGP+LeCvgf8ugIj8J8aY/wD4T4EM/I/+RTYwBnTD0gRO6fLCdH7W83dR4U9eF5bxSjwcqEUIXVTQ7TiS1xkoyoKsQvCe88szl3HEDj2bYcCZyP5eJcZ5WpQBYiN96CDNHD8fGc8ja13ZP+zBmJZ1mpkvM7mM1FoJQ8c6r+R5pHadDu/EM9w/kOaF8fxKulyIveX0fCLVmevLkXGaefjyPZI0KW/YbvBdh/cRbMB5HRyq/D5DAjNZtYSHQOg6WCZKacwPUTBOrr8FQFa5J7ZabLT4EN+Cm2y9FQkgW5zR3B0pGvAkbXxCdoo+9E1/IU67B6eeE5qjVmqmpAYpFgXX1CJUydSyanFJ5Y3aTlLgUMo60DXWYIwCk2uuOhWpQtEzkabGNfm9dYboI7moBb+iwVbOGPrQ3jsbiUNk2GwIPuK7qNoibsc/NfxVwPkABkpd9ShWdBBsnUZn1FKwVZDicTbjnCcbixWPdYllSoxPK/08MRw6rmhcA86Q80owgXgI5FI5Hi9cTzPvPj5wuL9TN3VuhT8vTKcX0nJlu1vp9lu23YDdbLD3Dtf3/CQnTqdXvv3Lv+bp8/dM88gu9nwxLxw+PBL6jhwrlzVpxlCI9N3AtCRqzeRscfZmRPxxj38pBURE/kN024KIPAH/jf8P3/fvoRub/x/+7ErKGgCd5wvT9QUhKWC40FrbQNzsqWnGd1uGYYshs5QZHyxp1DWX9Y7xeuYyXukPD/SDsiK3dw/kkpmPJ3zXsdsNWCtcPn9DSRo2ZRzcbR5wMWJroqSRcVm0VfYOZyvLSTc3yzVx/5NfYM2Gzbt3lFw4ff6MQbctHq981VJ5ebngtz3v3u2Zv3kC6/SuECIY0+TwQrKZlDJTyVSpeGuIXoesGs6kQ0LrPFKFJJmKxWNbl5EpbcPirNHjXdcRO4d36vnxncZDFJeQXPXCxiLO4pu4VGyF1dz4P0hS7Ymz5Y2wLjk17IKD5ksrkhWhUPRuLqkqlU0KkgtpOjEvi8YtVGFdJ6ZVZwBibFN4Nmm9MSS5xTDApov4qEPlJasALLrIvg/EoQMxxOgIcYPDMPSR4XAgbg7EBvTRoQpUV9s2x9OCH6AdvZCKNYYYArm2nVVJOBObOVEv/mmZeTof2b523L3bYzaRsiZsk9Gvs+b6Rq8d0+V6Roxl6Lfs7ndsNxplKVNhmVfW+TM8PxFjx3a/JWwGNkXYDgP9u3f0fc+f/6d/ph1Hyby8fMKYSr8/YIJjsJ5LWXDWso0DFMhkUlo1WP5v8PidV6KKqFbAVmE+PWlbKkXZjl4Viuv5yrqu7N9/QX93D2Vlukz6fWtqzkkDNlAJdLt3DPcPxKAtbZ5X5tMVGwPb/RZbM5fjmbSsOql3Dt/3+NAhktTxmBYVGlnBlMTl6RlsIiXB9Fu6w4Fu+4B1juOnz1hbmF+OzPNCHxzVWKZ5ZJozX/7iA3JNrGuidw6HxxbhfDxznRLD3ZZgvdIDm3Arp4KRKzWryEuZIB5sYF4T85KotTTFqnnLOaG03BZRcHHfRTbDQBgGDnd7tts9LsSWHdMUlqlQHVgRbDE/qELVmqhzE1tvekzISQeuTmXfFYsU9X7kXKlppUqz6KfEPJ65vH7mcr2yLAtLrUzzilSDM5bUhHDgKSLkWgguKhrRWQYfNRvH6/eELpAprOtCnCeqgcE5+kFnLi/nSnx6Yuj37Hd7du/f4XcbcF7fl+rARQhtlVwU5ixVbQRUjXOodcAFBfl477FFAU9lMiwpMU8r67rS7TpC32mIF0qHi9FANVgyaU0cpysvxXM4bLn78Mhme0+32dJ7Rym61coZLpcLfdF4ED4ZjYTYDfzp3/vbHC9f8fztt/i8UGVlXc5Qe6grNSvzNw6Bw/6O4/mFJSeVAPyr7kD+i3wIIFlT6qXliOQ1U6QQYocphWIMhy+/JnYbJCdqWjUDRCq1JIyxeO9YxpmKYb/fUUuhiOhdD9jsHTUlvvuLf4JUw3C3UUGSj5ioObQ1rch6YVkXeu8Rm5G0Mp1fyGVEisWGHXH/yHZ/p9jDcWRZV0ydefr+iYevPzBfL+R05eXpQn8YcBRen484SUhxWClcpguvF40sWoMjhEBAJdYpa3tvTaEmNZMZ59VFWkcNZ54zIhkPZBSQoxRf1T3oMFqdqX00bIcN798/8O7DV/SbDbHr1IpnFXycqxJEKvZt3KHiTteOTbHNLKStgVFtjrGUKpQ1kXMll0LNK7VolOc6Xzm9PvPp82fO51Gxf/UGaxaqGNZGoBNRkHTC4Glu6mjJAWIPgw0MnWe73dJHjVmQasEJRSxzzngTCN4ylcrp+MT3n77n7vkT7z68Z/PwgI+DFk5TFW2I+oKMQbeARsFJUjzGgQ89NntctNjU4b0Q/IK1ljktvL4m/HVhs4+E4AhdYLPbko3XbY6pWK+JdrjC09NnTp+eONw/cPjikcPdHW4YVD1tI67vqQjLdNXs3gJ5rNirsBs8/ssvGV9fkaIpdrUsSPMhrUkxoH0f2G4O5Hom5+WfvR/9F3z8zhcQEObrM5TS2uMVkYILG8J2j5SiIilRaXJKM9ZoxosxRWE2VK4vr1zPV7q7O0REnYwO6pq5vh5Z1pHXpwumi3z4+A4rFusNYasbIEkrdZ2RlPHWsywT1lXWaaIWgw8b6Hfk3PHFL/4YF3ZY4xhfL4Te8vRXnwiHDVYgrWq2Ext5fLdhvl6Z04KZJ0LfcTzPTNZRxCgfYrvBxQ5JhggqH6eSU6LGSirqmF3nxJIWdR+LSpfXdWVcCyWvSF0RZYfhnUUaGiAlnS3YZ3XtPj4+UNct3irZzFvBZEfxyhUxNANeG7jWWrCmgPFUMlITIlmPGCVrmn1Wd3EqmZJUxp0kM45nnp5feT1dmKfCmFadZ6Bz0VwKFSEGh7FePUY+4qMldhGiDtmd9xjf02937LdbrLeIeJxBBWE+4IPK/6OucyjA+Tzy+XLl/Ktvub+ceHy4Y9jdawwGynE1zkBRv49xqkOqVFxWHqs1HdbOmofrLN4ZPWIGw2Uu5HWilMx269VPtCTC0HF/f4cER80Gbwy7XSA87Mm1kpbM66fvOH3ziWwtu+2W/ccvGCwsuZKmleHQ4Wyvcz6pzNdKt+no+ogsP0SS5DHjbSWVypxX8qmwfzgQfUfOcLNb/pjH734BaStAoeJdxFQh7npip7Cg6fUzJkSCIqKUSZVWQjCUtVLLwjKPXI5XbPwBKuOojK8njq/PTK9XTtczYbfl3cMB5wPOekK3wTf8YMoLNU0K380VZ4W86MXqu44skW7zQLc9sN/dEVzH9fmFkhfm8wtzKjx88YHzpxdwjjJV+j7gRbgWnQPkNTM7x+s88/jhnt12x6bf0m/39NsDXTfgbdTOQ9BIibKS1sycK+N1ZBwXzWRdRiRlVu+wMZPXwLxonISiAhJiMk4CqQgnuWENvscHywFDiQFTDMUKzkVqcS1/16ge5Cbjqq4RvwTySkmrekdKoiyV3ARkuVQkr40uVljXmXmaeTmduF405DnXTCmJ3ARrzjli9ATn8HGg33T0w4Zt19P3Pb7vid1ADIG+i/gQCC4QXETJqapQRbTd13kVahMIgf3+nnWeuS4j47RSv3vlMVeGu0MLrXZUF9XfIw6H+mK8MxgvlGIJwbK6wC0oXHBYrwe6aC1LqhwvC7kkNn3Chg6ZMufTzId39+we32HEMF5HgknEzinZH08WQ1kzr8cj33z7Pe8e7th+/ZF5hl/+8jfsu8jHn35BHHrwhpoKvrPk6qhLxvd7XFepNXOZZyXQm47pMtGFwNLsCz/28TtfQATouo22y9aSc8H7HplHlvMz4oQ4bLBWKNcjpWWhlPlCTTPLeGG8XMkGDrs9VoQyXnldLrx8/4nz5UTOEDYbHt/dMwwDwemxxYaINZV1vpLmEevUTWrywvn4xLSuBO+pZqB/2CNZ82Ks0+T16+sz83jhcrqyf/+esmaqF9Zl5XiZ9DhWBSNqtPNGyEV4fP/Au/fv2PRbhs29FpB+g28ttDWAB1OtErlVzUIqhbyqgnFeZ+Zp4XQ9k5aZlDK5FY9lnSml+TVSoUiiimGZEsd8IsYBFwJbhpac58CsVHF4DGIiwao7WIePt31rC8sq0rZkWqhS6yJK0cJRayKlRJoW5mkmr5mlCLWuVGDoeuzQ0286utDROY8Pnq7f0vUdMXbKzwgdLmoCoHeNF+vVA+Nt1HX1bdi6ZMQYvKQ3AZ5x2rmG0HEXA7K31HUlS2aervSmU1n+LdQqqGZEWTQJ8RaKR4wHr0lza1owbsabgLUJFwob41hWOC2FqVS8zeRi2Gx61vSZw/HCw8MD3b6nirDMlZoSYWMIvsPvHHXXsSkDy2VGvvuWEDtirNQYuU4za4ZSVjbDQG+V0l+yUup9DOSp4ruONF4Ru1IlUpYWeFV/n5mozZVZcgWTMU63MTUnijNsdo862R9HCpZu11OnkZRW1mliHGfGeWG4v6dm1TCcPr3w3a//muocBIftIl98/SW7zQYk4PqNhvWsC/PlxDKOuKjyx3W8Mr5+Zs0rNvaEuCHsHqkZwnbLZr/HdZbjL3/D+fREqgU3DHQh8vryjPPC5fVKlkyMHTlXrq8ja0246Nnu9nzx5Tu23T2h75WxicNWlcY7WoZLg/06CyItfsFBSpCuM0IlusAXHz4wzyPLdaZKIuWVkmKzsifSmvW9zIW6Zi0YJbHOC9EFLAFxQkpFM2coSiWztDt7qx9N3VqzFpCSRU14LbMltzUukpW9UgqlZlKCvuupweHCnhiD2s7jQPSa/etdwJlA13li1xO7Dh87vOs0EzlGDBps5Uxz5qrsFoohVZXHmVze8IolCjWtqlR2HuN09e/uDpgqpHkkL0Xh1I3sbE3zGTWfj+YQO7yzRBcQmwk+EJpTfBMjc16gCq43JAFygzp1VgV1KxS/Mr68kq6ebtPT9T3VO0QcOWXKCl0fuBu2rF3UzVxdyWnl13/xax72ez7+4c/ZPdyxLCs+WOK2x0c1PNaccbWw6wKXElnOE9YtpGpb6uOPf/zuFxADtayI91gs63TFlIqNHZvNI7LM5DQhOLq7B3xauY4XyuVKrhUxju3hgNTKusycPn3m+ftnzCYS+w5s4Msvv2Az7DHO0W13xBhYL0eu5xPrsuIDhOC5PL8wXY+sIvSbDWI3pGp0MLfV9rnb7JhPR54+fYt16o70saOWxJoWJFXmOSEVuk3g8nxUaG6GbgjsdzvtNFArvKkZbKLkiikKHRarCspslJiVxbyJtZ4+vTDnhePrlX7jubvroRpeno4cDr36O7A4qQRj6eKAhIgRS0EBNV2IGpnZjsYCqths2S7GFOWOuuZBaaIuI/xWVKKmtwmAM9iSqbWQpVDSDSGQiRvPfTywM+rZAQsWvNWuw3iLN7EFTHu8dwgOY+ByOnN/KLhO0QlSFIodOg2vrqlibbP+BxW81dvNKKnK1rQJgG1FyLHFDx1ufwAyZVX3qjgdYCu6rOEBKMq0tQ7vIzmshBgJITD0llUc1Ts1L9aMQ9WspVQ6b4kBOmu0K04JXzMpZ2RakRjIvZols/OUdaUOhX4TGe7vmJeEdYb16x3f/uV3rGnk409+wvbxEbcYQgz0m16hRVVY8qoeMiMsacHPUEJsh/4f//idLyDGGHLJxH7LenlVObLzOO/Ilwu3kG0be7wRxtdP1PXKOF4wXY9zBlkT1+uJZZo5jwv+bmB3d6Ab9uw3A6FTLYALPdFb1tMr1+MLS1nph4Clcj2dGMeLDvR6TT5fx4kkHbuPHT70bN9/hbPC5fMz3uuHIk2V3XbD6dMz3eC5XK4cX08M2x5vYbqOpJrxFjpvCdEjGEpZcBlwlmJXDdOqQqmpxVck1lRY1pV5HDk1rMDz68Tn4wt//fkERth1kc2u4/vnC18/7nHOMGwig/dqKPSeEB0hOnrjyaJ0sXURSsg4H/DGaeJ8S6g3poGarcd5DfTGGKRo1ITrlKdSVTGPtYJ4nUOY7DCmcUdLUSZGE5WY4AEFK3vrsPiWaLeSRY9A12tBjGW37fj2mzPdH32kUqAYvv3uE6fjws9//g7JsKbM3WajBTc6Yh/wVaMXVG5fKHVB1oxZHH5ZYLsidSAOO02XM7zR/H9gSt84JPoFbwM1VGLtWNJK5x3JBegS6xqIvuBExXFiLIHKsgj5ujJEg40WEwSTDTkn0jiqZ6cPZON5frnQ7SN+UITEJka++sUX7HY7fLSM88x3v3nBOkdKK+7rrxlbvIbf75UnM3koQuciy92W6/VKdBYj7g3L9GMev/sFBIPzgdrCjGn+jjzNVAeyqgx7iD3jyxOprKzjiIkdZZ51UHe9MOWKMw7XBfrDgf1moBv2OrNAOak+VMbjK9PlBFLoOovMM3MpQFGAzKw+mpyFeS48fPEeS2C4e8/d/Y7x029Y1wkQ5jnhtltKyozjQrdzPH9/Bms4PG45f37hfB7xrqqfNkQFJLfNRsmZZGcF2WQ1rJVSKLmyzBPH1xO//P7I56dXTlPiUhKXJfF5WjnOiVSlOU5BxHD49Wc20fFu1/PxMJDXyuPdgZ98cY/bb7CxJzZDnrOWlCshSku9C9ior8252CDPBuN9y1tRaE0tRdmkQaXjlIJJlWLBOMHKQi5CMdo6G29BIqHFUUjVzUYRyHlkfBn55ptX9fgYy8v1SskZWx3PU+LP//MtPnjWpfJynvjFl4+syyshDDy8v+OX35+o1bDbDDw+3kPn36TbuYpK7KVikyB2xE5a8IqNGOd03haNHr9yVdBQwx2Igegsa3D4asnO40KP8xEXDaUE+uhxrG/pdqUKNgtpXpEkjMtKGYRtH8jB4drW0CIEnHZ5KSNjZcmV4gzzvJL/s5Wv/vALht2en335SMmZ6/lMv9ty+vxE//OvWRYFLguCjw5CBzkTamV1CRqy4F+JG/e/rIdAg8hoFqu1Khxz3lOWDMbRDQN1vrTVoV44OU/M45W0TCxrYp5XpMDm7oG7uwe6LurdtOpgtOs867nNO4aBQGWaTqRV6dXXy7UN/jI5LyzZ8e4nv+Dxqy/ZbA88PD5weXpB1pWSF5ZJZzJDN5DHEesd1+PM8fXM7r0yXI+vZ1JRSHTwvvk0UFWj8ZSayIsawoqsrLkwzRPTdeI3n5755bdHvl8SszF8+3JmzoVxKT9ECVv9c03Lz1294TpeeHq68Hydic4hwZF/nXjcdbx7/8DusMXbDu8NNiprxLuA63QWYY1tMN+A853K4okU3Bsasi4VX4VsEjY4pFo6AGtIiB6BAPFeuw9RkVat6vCtNXN5feXTpyOv55lkhc+XmTVlnudFbfNiWLLw5y9HShVadjr/+PMzg7U8Dj19F9hten7x7pE//Xs/Y56vLIvBO+iGAfEqGhMpVFR9m+yMXRx4j4nKVfGubTVMbWjGgjVKt0+u4L2jZn1/Yi+EzYYhTQRxzGlRHYlEyIpGGJdKTupW7oPS9qVodh4tx9ga3WqFEIibiPNwnBeWKuwPPed5Yfj+mYeWVPBwv+Pb14WcEnhYLhfi/SO1ZkrSlD0bHcN24JxWPbIjGN/9fhcQRKhlwYcORFjGIzjDfB4xmx19H3DWkdaZsoxM5wslL0zTkfU6k1JhnTMihoevv+L+8R0WSEuikIku4DcbUpoopdAfdlCF+fV7xssrJmcSlvE6sywztoIh8vD1Vzx+9SUhdgybntOnT1SbkXVkvBxJWeh3DwRrWLMwDIHXz5+JfeSwHbh8OnJ8GYmm0keHa/GT1jqF9bqCIZCMIKt6SeZ55fnTK7/87oVfLpXnpfDt85VcMkvSu+N+t+EyznSD53CvSku/e08uHhsM52//gvX8zDULY8lszzPsK+PLwjwVfvq14B51JuIEwGMsDeTs1PjmI87rINP5hlMsymW1QbUiYi22GOWQFhCz4PGIRFJOOFspVsHGpkIhK5F+Xnh6euLTy5UVQxkCy7QyvP+os4TP37HrDcEZ5uQ5p0paEnm8UkvhXAqnXPh+TSppt5bn1yPzeuWLLz+wvTvw1VdfEUWDtbAV66GiSXWsq3YSsydHLeo6H7ENUxBosQBKiRfNh/G+3YiMMPQDZd1iWKhWC0XJCpEWA2vSKaxtmAFKoeCILQPnhoQ0KH4yGEMuwq+fR6I3DF3ADIHzNDGME5u7e7bbgf5uy7yO5GVDrRum64VtuNNwb9RsGKxhO2y5FPD84D/6sY/f+QIitSKic46aJ0paQRxus8V3viHBC3UZOT1/Zs2FfL2S0kLJlSSFzf0Dhw/v2Awb8lyUfN55NqGjVm1pTdbhWLqeSfPM6eUJKQtYyzJnSgYRTw099x8/cP/hCzbDBud70pooZcGWlfH1s56pw55hu2E+nZjmkXE6c7peeffVA5fPL1xPR+V0GKOQIGcUGGRvlnmHiGkpbpXzdeE33zzz57965vtp4SSW4/XKvGgmyjB0/PwPf86uG/iLf/pXbDeO3b7HpCsvv7pyPBdib/m4zzx+6MnFkmTA7Q5cryNfbCw1eD6/XnHB89C/pxZHqlCqEIwm9IXgCbHDhQ7XUvGUKarQH4uqW4sD0o0+BpJ1TVuMx9qoak4qIgHTYhbm04Xz+cJlyYTdBp8zl+NE+Pgz/vS/8m9wOV/5f/yjf4QzJxwr03ViedXNyq5Tpei1QFqErKJb5lr58+PILy+/5Oe/eea//m/8MfbLR9zmDmdhPp6pa27uWnXvlqJHGw1c1yOusdLmBVaPazVRC4qLcBVnNWvYV88mdtRh4FohOnUPV1dxxnCdF4wEQhCCrSp0rFAsLBVsNThTMVS8cY3SZvn2dOX5kjlsDOfXM5sy0PkN03UkbAcwjvu7Deu46NHFZFJNpLQybDo6t6VUIc+LMl3xqubuA38TKervfAHB6J4+LzNlmslJCJse61FOavQs51cuT58pCDlNrOuVeVV0fdzsuHv3jq4bWMaVWlYVQxlBTEe327FcjyyXZ9Zl4vpyJOcZ63TQNU1KIrfO0d2/491XP2O739IFDYYSaes4s5IuR+acyL5j9/hAXStrSizTyOvryO79HeU6MY1XXo565IohqFrSoMHZWXDeItYr7YtKyjDPK5+OF/7iNPJ5nEml2dBF2DnH14/3/OLjV/jNjtfjhTW9EpzQ2UpdR4ad4DeOj3c7jLdMk+Nw91N++rf/gJfnF9Kvf4M3M90+8npdceHC+y83GKdFpBNRv03scbEj+o7Qb3QGcgMRV01t8xay91hnWmqdUd6pFXIQfK2aPJdWqJk1Z9KSWGulmkoMnjyunMaCu/uKn/7x3+WnP/k55/OFX334K9bLjJdE3kpDEQrbzmJjR1zhdE5Y8dRcmJdEEbhQ+c9OVy7/0Z/xzW9e+Ft//Au+/umXDLuOqRhcTW+5MsZUshR8qtRcSElwRml2xhQNpmr8EFJRvogLWFdwAjZ4vHX4PmLXSikJYSUv6mESlD9ScyG2n7HVkYQWKw/OKLazYMgIf/U6q8tYLEuurOcroVNAc16F2AfMznIxnnib0xTI1wXpN/igc0QxDm8N3WCYl6KRI/b3uIAYoOaJ5XSmphnTdXjfbOjeUlPh+vrMsi5AZT5dWUpprTUcDvd0w0BOK85bvI8U4zBdoFbDdPrM9fN3XF6fGOdJOaE1MSeLVEfxlu5uy353z/buoTFADGI81Xr13tSVuk5QFjCRzbuPxGHg+vzM9Xwh5cQw9BhvOJ2PzNPM3M7tfef0qFAMXYx6EYrDlkwuhWUtfPsy8qtvnvnLT2eO60IRted7Z3joAz/fbbjf9LxbM3HnuL7/kr/8zYIR2PQ9W2c1jDt6+t2e6yqUbPn66y953OyIYjjPiTJNjJeJjx8HsrGsY6brHNYEpBG8DBZnPb5Jw12IGONVi9KiR6t4DVuSRCkDvkBOGdut2ORwCSStrHMilark8OjI40QRw+X1xOmcGT5+zS/+zp/wxR/8nG2/JYaOn/ziD/mL/+R7bEg87OAuFI033fRMElnPGT8IH/YDrlReLmd+dRxZilCo/GZdmP/6G455QYzwB3/rZ8TdgTVNpJpx1hFdwDlLLRpRGmrFxQ7TKPhqMdaQMjJYL9TqsNlhQ6ErkdVHBoEkqsTNs1DsSi6F4CxiQnMYNxZssWpR8BVjHTEEvA8kEY5r4mnMWAPvto5iQErVDuzuQMkadmbWTN/1WKPoB3EzXYjUUiGAWIcDSqr03lHFkVP6ganyIx6/8wVEMCyXi+aIdAOh22KrfhioGsp0vV6wwXP69D0lF5zvCN5z93jA2468JGwISrkzUJeFNF4xpvL6m19yenkF7ygpcb2M4APeBMzQ8fDTnzJsNkSpBOswNbNOQpVAt6nkZSFNEy6AwRN393T9junlieOnzyo1r5XQeV4+vSBk1rUyBM+cM4fBkteKiyruUon6ghXHuGaejwufLpmnZeVlTeQCg7MYb/nTn9zzfr/j8e6Rfbcl+p7QO/Y/eeTrhy1Jkq5QjR4BnVMfyH4p9A8d985QPz/hryM7sRx++jXnv/6GdKl8+KN7nB+wQTUV6nbX7YzzHbZr2wbXNdCx6glsyXp8QPApUm3StbtTSbivwox6aaoJGJspSyZLoet7js9XUurY3e3Z7zZspiv1u+8Zn4+YGPjZbqB++XOuy0lnBAZKsfjQUa2l+8rz0AWsgZQWTscjj58/85efXjiNK1jL5IRfPx+xf/ZP+PU3T/zsZ1+wOWyp256906jNkgvVGLpqcN4ROtWiaCzmQs1ZjwI2YJ2K/Gzw+GqooeIcuGIoVgn6ZZnxokm9IahqNU8dzKPOiazgsTgjOKPHxBAi52nmV6/LG1xpvlHwsOQqmnC3zlh30EiPNdPFjrSsVC/IfqdcFxGMcapFakNrZ4RLXinl91iJKrWwLnNbN3kCUPOKWGE+nzl//h5rYXp5Vot77DB4ui6S1wpbj3OBdblCrkyvL6RpRkLH9fWJ59cn+s0A08w4zpg+0g1buu6Ox59/xaYP5HFGpJKDIVSHYPHRM51HaplxUair0G0eqWKYLieOxxO4qgPRoWM5XxivF6Z5QqzK2UMfyMWol6fr6YJn2HdE12FFwAuLOPycedjt+eKLO8ZUsatgvOOPvnzHfn/P7u69ys9dRIzwrgg/q5pS753FBqWp+6hdQl0SwQjLqsnvaeMZx5mcVjZDpOYCq+HuwwbrOowLTeuhhB1LxVn3ls1jnUPlsS1GAQ3HFmMoFrJFV76i2gnfRWyMlMuEqcLubodxlb/6s29wtuNnf/iRw37LbrMl9hHfGULQOcTd/ZYv93+XYh2rDqZIKdF1vR4VUsIlIddKJnN5eODd/YE/+smZp8vEX3868Xq9goGzZMw8wjef+LIKD7seWw1pKcQu4l3AB6++F4tiERv93RpPNWoitNZhrYaLm1rxWL1xuYxJBW8L2TmcMQSpVKezEX+/Yz4ZZJ3xteCNFugYIn7w4GFOK0/X9UZgZFnUod9Hi4ij5MQyjmyWmaEfuExaECT02qnXQl5mfNfjbKQ4RyoaIGZdZRPD3+j6/N0vICI6BXeBPvZITmCENI1Mp2dstEzns9ryQ9dCmzwlFUy/Y5kn0uUzJU2MxxPjdCFuD5TpyufvPuOC4dP3r9Qi7N/dcXh8pN/fMewfNHahrhhr6Q4PCrQ9zdy9vyeNE0DjP2Q293fMU6XWlXW6YMiklHDBc325cD2/YiWTV41QXOfCV++2GHEE54nOM3SOIXSEOOjE3wvvu8j+/h7vA85XxkuGnMk50fcd/bBnu+mImw2uG9odUSXQKSWVeFfbjl0KWKYzlHXB1oKrlW478PCwx3lHWh65XkeGbc+mi7jQvbl2HS1DNpWm4lTEn7MGMWpmpFZsbRQv67EmYJmxOIxzimW0Cit2PnL/MLAZep6+e2LY7vn5V+/ZHjYELNY6jbAwEdD1Jj5So+i2qqihsPpVZeX9gEG/VlKi1Myuj8zR8XHd8kdk/vQXK9++TLw+X/n5fcf7hz2bFt60GwY22y1x6AmddrHWKL3NWa+8E6M5N0pBVCA1LYPGWrWlVVOU9drsBqY4nPO42BM3WoCtBDofsNstay1IFqgQrKfrOrouUqRwWjJzLiwVYoBi5c1zhHMUCmsqlHXF9Tt812nw1LanZGGpFZsLJiVs3+ExzDUTnXJWgje/52tcIISe0G+p86yEaaka4TcM2gL2O7bDvSoNrWW5zhSbOH7/DaUmjPWcv39hHF9VGjyvvH5+YakVM1uWEtjdHbj7+DVdHxBgfH1hnRbCEBn2j2z2B9YxsX9/gJJxfcCLpVbH5v0DpIyYhfl8Yr5eWFMmbntOn54YzyfmacKJMmuurwvDPrLpA5KhGyIBR+wHQtjQdXos6IaOh+goRd2sSGUdKmmeSGvCOUvsI8E7IhVH1o2SQPCGIIaSDZVKTZk8J51LLCtrXrCu4kMACr5YhqGnu9thw3ulelTRkCrXEZzFeaeaBadKVGecEtFN6zwktcRZVUFSCmSNjUCaqM0GrFfPyGG/Y3/Y4Grm3Rdf8OHnv6ADluuMrCqky2UiRiHYoKY2AWcszgreOqpXKFS1ijZChLRkCqJDSsm4wVJ8xNBx2B344p1jrUJJlSiOw92W9x8e6fqmSna6VrfNJKjmu1tcpwaeG2uxYqA5u6uxinVsMQnquVF4gilqlJTBEXPElYpUSxbFYJY1aFg32qn56LDektLCd5crSxGckbax0dek2fCKgiwpUZYFcmHYbsk5IaWooVCg1IwtC7V05JpxDnLRJQPG/n7PQBAVu+RlVKv4spBLpq7acs/nC8nokaVeRl7PI9W2ZHfR9do0npmWkVUcPmxIqVK7oXkrIo+H93z5069wOXN8OeJdYblMbB/v2B4OWDzj64n7D+906h47XNdjc8aKQxoXQtbEMs/MYhBnGb9/5uXpidfXM9tdIM1CSsKYhK/ebXBiESf4auk3A33cEGNzmQa9+1vnqKKT/JIqlkIQoXaBirIwjMmQDFJXkhhMUdByyYoE1A9KhkXzdkvOWGm807RgXKD2QpmFZZzwfYff9Jgu4PsesU3G7jzeuUY583qROcctlbbi9KIzTWjlO2xXoSREroioOMr5nn4HwVwJ1SPGstlFSqksp4WUFura9rBOSMsF4wO0MC2xhmydukidBlFVlHlbjaEWQUhUWZGqs4UYBy16sSP0gdhFQuiwLtJveobNQGjvu/VOB8M1a9hUKtSqkRa1CIbUpBNOi+dt/hM8LK4d1VzrWDRF0YiGpOclU65rW5wKFIhdTy4VnzOx83R9jzjLNAtPl5Vahf6WQwyIg5xvYT6eIpllXYk5M2z3rXhmTBd1eI7eVAxJUQRGmGohuB7Xokt/7ON3voAYa6GsyHolXa9UrKLx1pXx+EIWi4lCTVdO337HdU5s7rbM5xNVKpeXE+tayLVSXaR72GLXyvDFO+7ef+RwdyCGwOmb7zhPE/3QkVPl7v0Dftirp6IKDz/5Qjsg27G5f1BQThFqXvB9h2RhmleKcbggHL994vJy5HK+sq6JTe3xwTB+PrPbdQy9IxchBIOpht1+S98NdH0kxojrIt710FLSnI1UVwglk7tO7865tjO5CrVqUUNbSRlqpuSVvGZllOZCzoVcirZB1lCLaatZg0mRZIViPWIDzvfEfkPXb7SAoHdBLRyxUdG1cNB8IkZsAzhp2JT6ZtSta63HBkGK0HW9DlGdx9TMkhdkraS1kLBU66i2IPPMclnwtrIAhtAQAjoP0RmMRZxS0Yx4xKgr2Fh9b6z1hF4dri5ucD4QozJGYujxsSdGjQAx3ipIqGXfCF61Ki5Rk9OsWxHEek0DoDT4dOu6GkWN0gK8xWKN5uhiDN4G8lBZr0UXOc5RRGBJ2FyJxhBDJPRRdTEZLlPBG93wG4FoblGjYGoBKriqP+9VbxAhduqylUS1Xjc/whurxIh2V5VKtPD7rQMRvUum8UoGXN8j5ytpXiF2+Ibae/38iYVKGBzL+Zn5urDmxDhPelF0HYcP7+lij+23PP7kA110pPPIt7/+JcfrlTAMdP07+thpGFAqrPPKT//gZ3hgFsv+/T0uOuq0kJdC2PQIhnVeGzA4sZ5OrOOJ8XpBamV/p4FR07KSTOVd7+l8ZCVT10J/6Oj6LSH29L7TgZfv8P6Wcauahloc1XqcVIorhKDRlLXcwrCFUlZyWSlLoqwLtahwrpSqEQWWN6KY8RG32RBijx82xGFQiFIMdH3HMOgF1n4QWCn4xuZwzmGNa0cZ1UXYBlaWFnh94x5qc6/GLR86fQ3Gkn0GMjb1mmTfW+LGqvU/rYp+jDMpTdg1IVSWlFuEpiHEqtwNBCM639HQrFvYlNrEbC3YWumtIfSR2A963A0dPvYE61oh0k3VLdbhFjhVnYKHXQXRA4uqRW8XngBKPEGMWg+MejDUimG1MLkAXRi4nBc10hgPaUYW/TtZ7/DRY712UatmkjMMns5DMIbOGw3LzlljOWxQVom15JrIdcEXgw2RljDcYNRABe8dpQhBHNXpGvl3LdbhX+7DGNJ4Rmyg63rm85npfCRut1gp1HVifD2zokrJsk6Mc9ZtjDHEfU+339HtdngbMWHL+w8fWOaJ09Mrr59+wzRekb7jy6++onMW3/Ws80qVyld/9HN651imhfsvvmDYbpnPF+Y2Hwldx3S+Ml8vLOvI9Xji/PTMeLmw5IXQBfphwFvLb74/EntP7L2uNlPGmkDcDvTbgRAGzdQNHS72bT3aVJ6xviWsUWvDDIuazma9++R1ASxShGwhe6gWXGcUBBScbk1swLiAjwNx6LGxo+t77UZcxHmrR6muawwM0XNytUprcxF3E4pxy6hBbbxWeau1mretjN7ZO3o3UNqA1Vmh63Sxk9PMMgfWbKjWEKpgNhv6/R1lXVsBTJCVXSJpUoZJrVSTCbXorMEqWzR2A7Hr8cOAcR7bAEihrZ69dzjxOHEEY3RN7bx2SegKWm6ZMLUo/0Nq8/Go/b9ahxQd6OuGUNejtaqy1Bh1F1tTMNlgrSW2aIhpX5hlYb4spPMFO0+4YOi2e/rDVovBNHO6TlzHgjPCUgzOCcFZohFyy/2NoXWsIeKCQcS06FJDH3tyXXEYSs2YUrA+aL6PtVTAx/h7XkCkgvP4ECjjyOXzt4j3pMsZUzPT6yfGrM7Q5XxkWXTXX7IyRLbbO4xx5EkY3t+x2W94/vyJ+Xrl6de/oRrY3W/56c9/oXckp/mlxgW+/uojQ7RMx5Hu7p5hf8dyeiVNk5rUQtSoheuF6XLlfHzl5dNTiyhY8c7TD5FaK+d5xXWewQUOdzuWsZBypg8DfdgwxJ7OK/zZtRBt632LqrSItDUoUFoYtohGINRNoPQdOfWEdSGlHbHlweCCcjyNR5xTfoUJ2OBx3UZBvd7oscB4vIEQNYzJ0WIfrcE5zcN1zryd+0VEMXq3DoBbi2PV/t6wgXYN2FAR6whG7+KUgrUWExzSdcQwkItm2dT2Z1mnCXLKSFXvic6CFmpeKetKKTNu1WAo53S97VxH8AHvBuLQNUZHJISbW1ZX+85pCLdrOAL3W5sqEdv+PjoWRjQVr1iLiOboQtKPqJTmiTGYG2Hp5lbG4m3Aom7yYHSbZWuFZYUl44Nlt98zPO403nJZKVJ5mTWjyAh4EVKBlNsANQkLGqNaMpQcCM0N3cVBGTOgNgMDtWUEOUwj2CvU+Yfo0h/3+J0vICKCcZayrByfvldZdIjkdGZ9feH50yfER5wNpGnVXI8CyUb2uwPrCtZHDh8+shkip8/PfP7uO56/e2a4G/jw5QfevX9H8D3GedKa8N3A+w+P2JxJU2b/5Ud2dx9YrxdKnlnmK9l07GLPeLpwPZ84H5/5/lffkNNCTivGWXxwBGOZRTgeR4Zdx91GV7fjeMFbGIae3W5ofhgdUnrbNw1CeLvwfxjWVVwt6p8ouhJUm7jOSYLryVvAe51FiMW42wda4cLGaECUtV4veVOxVnDG6NzCaVQDRjNtDeYtg1aHqa5Z/n2L1VTfjjEVJ0Kx2rHcMnut67BB75jU1lg3HolxDkshhk5XoCLkatRd29gjtbFA1BOlPI9Sk0qzb/m+KLTIOVUba1ehitKbv8jbmybG6XHB6RxHg7JaKEXL16kCVipVHGIzpuiFZmzG1rZlMSp0rC1CspYGKaqK6fFGfTLZJXy1eGsokjh/PlGnqWlNNkrFfzywvd+DqHvWGMN5WrVweXDGKHzIQ6mm/dyMdknOKBYBi+RClUSRjCfiLMSuo5qAtR6kUpKS2K3VoKy/wQjkd7+AgDo01+uVZbrS7R+oFNblwjheqXFgs9uRlwVTHcPmHmsH/H7LMhW29wOmWEwtTC/PfPuXvyJ7+PAHX7O/33O329NtthjjqGml39/x+P4B0orb7gmbDdZFalqYjk98+5e/hu2Ojz+95/rpmU/ff886v/Dpu29VY2FBrNqvow/gA+Ppgg2Od4c9w6bn6ZvPWA8eSzdsGOJG4S7B4J1++P3tOGH12CHOYF3Q4V4tUK12IqJcy1yh9lXP7EAxBho/1VjdCmB12CnOgzhMRcn1VrUcVpRAXquuIBWhGBFATNVAKqt3b2O0I7kND7W26QDVGj2KiLXK1AgObKd+GalIrkizoeucosVNGj2zF0yDJ2ninRhwttfuoIpiA8gYUbyDNQacR+qKq2rBN63Fd0Yp6QZa96UqTtOeWwfApg2iNe/GiDJcTS3tSGOxtuJawUhVma9aYdXwqL6krIsRg65HXSCYAkXZq8Y4xvMMa2K7jQz7g3Zwkon9QC0L6TJjs2M1lWVdlX+LIgi8bW8zCmFSOpzOYqR1dNa17Y84clpw3RYbB8RY5jW1z4NqbMTbNuP6PT7CSBXSsnB6+oQ9HPDbHfn8Sl0rS0oMuz2uWmTY8+UffMXu8UukKJkpLyvjPLG/O7CMFz4fz7z7g59QS+Xu3T2bXs/ZwXis8wy7nuDUcenv7jAWVfVJ5bu//Ct+9U9/zeEnX/Pxp18wfX7in/zjP8f0ML8cGceRLuoPM3hH9A4TO5KppGS4f7xnuxsopXLNmc6BLTD0HT5om+tcO1p4jaz0VgHRLnisC+pJaVklRpzOANo/lnZHtA6pQja6VnXO/DDwa1sPsa5FQ7SA7tZZmMY1NZIRK+2IofEHkLGisCEN8lY8n/66HXWkKvyoRVxalbHhuogk1R3oqKRqLKdtQd+16hHCa/atl99Koyt6UTtLy9dU6JC1mkss1r7J7JGIaxccVbAib/J743QT5FqhEnReo7JuUSUtRq0ORoe+yehxxcjtSCbY2oxwxiBF+TOmVtV/3MLJRY9xxmmerhGN4Mw18/LdkZhWNodH+m2vAHAK5JXpNGGqJXrPNC+MU0KMep5arWraFMG0js5JKxhV1CgXNInPIpR1peu3OkC3UK0WnBtZnpw0R/lvcH3+zhcQDFxeX5DYs9m/I19euHz+luO335MRDkPP4cNPuPvwBfv7D3TbO6QKJU+INErWOnK+XPjw5UfEQog9rp2LvdG7gw1eg5vSSFoT1++emDO4zcD58wvf/uY79l/9jC9/9oHzt5/4i//4P2aWhLlmTsdXuk3AOQOpsulgKQKx4/zdC3f3O3bRUaSyzitd8MyXic3dHX0MmmpmbSsgt65DE+iN12OHs07FWbbFB4C2263AVaNncEFTFgxWaeHtDG0bR1WPAGBcu50Z18RnyvMw+Qb8aSIq73DNRKdBVB6cQ6xuYLRq3SioLebB/ADGwXtKBV8qeIcU4f/J3Z/E2pZm+X3Yb33d3vt0997XRURGRGVmNWSxipYt2ZANDwwB9JwTS9BAgCzT4EQQDY9IeqIRAQ4MAZoSBgwNLEi0YEAaWbIECDYsNiKLRbK67KN98drbnWY3X+fB+s6NoCqrsioCZiVrA5ERed+979zT7PWt9V//xnhRSwaLhh8Vg3GKz4jYlpOtwU01Zx3DaqGaVjDa8zy38ecx3lQLop5MWKP8i4IS4FxbKVujERRFGZ1641V13mgG3lLP5DjzgDnJGd9BFFeoC1Xqw6an5PNKvZK1+UOkoCA4eGPZ70fGu4mtDXTOE8RoPnGFOVVwHcF6SokcxpHUaPG905fY1IbIlFbInYAvSD7LDHjYfImgejFTKGnBiHZyOesa3Bk0O6lW/lTHOpScqbayXe9Ybl+yf/Oa++sb5px457u/wNU77xNsT54z96/fYt7cqqjJK2OxxJlqhEHADNKqtFWAEpVrF8ksdzNv31zz5uUbllyxqxXbx09xhxOHMfHen/0ugw3cfv45P/zt77NIonOGVx+/Ydh4NpuBuCxklEodtjv2dwvDxYqNxrYyHbQl7b3jeky8/36vBr4tC9e6ADSpuDm33C32p61MxTo9jtsHpYoCZ4ImYFfUvtAKql9R71+MmAdMAZHW9tNO+iZloVJFAUIjqm+RJkA8Fxr9oDb689l1GTSc+vxntcUmiDT8BiTo+IJUqpU2tliMqEReJe5akERaR1LR59u4JSo71zHn7Euq3il8aYqjXHacd1pkih4OYs8ApxokVTK1tOeQwdZCQbcY55ZeF7aCUMiVxvegjYIFU5ulQkqYUhR7KGrsJNk0zUwDY63leDfiqkaIuL7D245qYV4imI7gRTOMS+Xj6zv2c0ac4klWIDh9grnCUAUnRuM9jb6/lIKx+udUdaMrxio2YwzBeRYpUC0eQ0bJcd/k+rkvILUWQt8xHe4Zb95ojGSFZ9/5LqHvuX51S+i3IBPpeM84niB0DJs1Jk7Mc1JLP7EMF5dsLi9ZbQLGzuTTiRhn0rjn5u6e16/u6C6uePLuU4zoyU+pPPrWE+Jh4nr/gleff0QNlc16zdtPnuNXjrAKGLG6KaqVmDsGcVg3wlIoxlCKYZkym7VjWTLZODabHT4MbVPSsIqHDYeetog0+rdvReDs6amuVdXrzK8MZ3XTPM/0tBAtvRObXqO9rs3mB9rZqtwQ3YDIA+ux0ZxLKxyWNvJox6Sdi/5TG4GqVnU+xxiotnmHKpgLqhFRG5PcxrHG1UAf27bXQHkLlcbvbt1Ne0xTHzANffz2BKoBJ0hQfMBUq0shZxUryK1TKtKKUqOeq8Wyuq43j5VSEyUpWF3PXy8asG0RMJ5sqoZkNYp9Rllztlk1ZG0TMUAuBYNw8WzHZnvBsOvxIZBqxEZDkai4RCmM48TbwwQC6yD4YChLIQKd6E1bjdCvfLOfNJrZ2/CuXBIu9DjT6/tojR6criOLWieeA9ozlW/QgPz8FxBQ4Gw+3qo9YXVcvPcM41VMlWJm3L/EWA0hLl2g6wPTOJNiUoFZ6NnstnTDhlQLp/2BFGfyMrPsb7g/jOTQsX3nXS4fP4IsDOu1ous1c7zdc7q/53R3SxRY7dbcfPaSIRis7dSfteXAhtUamw3T8QQpa8xgm/WlMyy5MlbDxaMtXsCJwXuHSOCBclzPAZRyPl71tLRq/3fuNKRJz2s1ailYWkFoLTTFUrMgplCdkqFEGVJKY8fqAVRU4Gca8JkLmNx4J61w6A+fZ/u2qq21jRDS/m4F6DBFxWGieSwGQ2ldhxEgqxhMf0qLhNQWHSkNmBV1QiNlrGQlTJ23OjTgtDU8+vtrd1WNNH3OA7yrj9KUxLVhRpS2ns36HerSroWg1NRGG0MRjaCoNVPKgpTatlitozqv1Mv5tTCUmpSTgkFypthMjYXNdkNYrej7AWegkkhzotSCN4LNmdkmPru/59XdiBcIYuiC0d8vt9dYBHJl3fftUKlt29SpD4gIfTco01cUQK9SERLBDxQpOKvsYo0M/VMMoooI6XAgZ5izsHr6Pv12S4mJOBeyMazeeaRxizXjhg18xQYRGlCXKtP+xPZygBjJcWKaTpQQMBc9nR8Y1mtNohfh/vUblmmmVCgkUpyZc6LfDty+fEsIQDVqNuwcxhtiLDhnmA4H1TQMlhA6jqcZR8VIYH97pFYYrMeh/JbzqALnD2NuFaCdzVXXqjUJ1TVQrq1baR8sqmlmNxmRs/6lNsDQIBndEJVCVY9dVYw2BqeY1mXkxukQHRMUD0BZjU081yBFznEAosio3tBJi5G09462IDVGw69q65SMGHJNaKDLudiok5YV17Y4WlBzTthaVPNTNE5CjI4fWrQquZi2kWnYC41JKgbTtla1FY7axo5SMuRK8a0SldI2Kg251bAZ1dgUDdnW3N/Y+CJtJV3bWNWKcK7nXB/Rwt82Sd1OrSJsy1qex5EpKlDsbKCkhTklnt/d6zo7V5ZYWEdhNTjEalxlVtoLLni1APCe4oRqK0ta6EOvhSwnvB/0v4t2daYkci2k9j5q6PqfYgwEEUy3ps6Fq/ffQUxPnCbikhjnqDvucSTmwupiC9PCfn/E+p5ht6F6g6mGbuPwIow3dyQxDNsNvfPc3R7oBs1omff3HE8T/brn9RevKLmwu1zRDwPLfsF1gbtXb+m8Rif2mxVGhGVZWOaF4WLH3e0N2Mw8LdggGJzyQoyl5sLzF3e4lcf3jqHv8GKR0k5MMU034R5WdNIKC+iaUZEKdai37YtSjXYnImovSFFMI7dsllq1c2n+m6VtKnRV2YYY0Q5GqPq4teERRrcVWpNaDFGLKDiPP2Qdf85KURH9GZN1nNGJRotJKUWJcaUgRb7smhBMs1avtmLb2KSQhBY67VoKhdh0NwoAVAPGnotWgwRr21aAbkWqxjyWrB6zUNVvthT1brVex8bWAWbOz6kBubkoka0pbznT1Utt/JFzs5gxWXGemowWvGJwQ2g6nkLKQpojsSpjN7gOK5Bt4fndgS/eHrhYGQ7HgjGaKVwOmWENw3qgWiGQMZ0DKzjncLbDWfVzFTFICJhYMKlg1hq2LaIjufetANdzrNbXv37uC4gA83TSAyIKVQq5CnZYs+r19FqiZtIuU2aeZ66+9S2GvicuMy0UhXyayMbitxs6U7l+/oalRB13bq7Z3x0ww4bd08e8ef4SsULXe9a7Faf9iF/3HO/v2W4HgreaTJcX7m4O5ALrq0eMtwfSOCEWur5DvGE6TQoH5MLdfuT+NNKTeffRY/xqoJSkwi9BNxdObQL1C/r2VDEND6jt7Nf/LZEHM2PFDAq0iMdKc0lHZ/FKbeOFxTRQUNeYtJVuaadqwzRaQRLbbuLSCoRimljla+tvU/X56RsmDV9tf1dpcMz5F+HMpIVa1JqSqif8wwaBQjW+8TmUIPWA1VSFNamoMrZFVRpaN6X+kA+gMA0sLefOrhUWnVYcWJUElFSo6DZLjKHm9EAOqzlrOmLVLqW2InVO4asiYHTFW4sWiS+nq0ypia6qCC6nqHCKVZGktxDQ/N27NPG7n79myZm+CqvBqly/fRJyzBzmI+uV4+mHTwjrDVLUbc+eeS0FoIVyEduoGxAv6quTwA1rxEobD8+/6de7fu4LSI4Lrz/+hLC7QKZCGFbqqFQgpYVue8Hl43cVa5BKXiLOCKf7AzXNzPOIiGV7dQFiOb5+zZtXt7jdCieZ6+evOJ0WSr/m0crz2e/+kOQtu13P5aMrlikrQ3XaE4jYmnE+kKeJuMykAt12g8TIvBzpOkPJhm7oqTk1v0/P/f2JV29vSKiac7vudDvS7htBTYuV4CTK2VDyA1KF87beYLQoNgzgzLigJAUx3VdvZh66itIAWS0SjZ2KQNEVJu10b/thfYzm9lxLbZud9kErgGuYQ+NlPLTBD4BmG28M+hjnCISSFCM4/94N56nKhsAJjfSmQi9Tz4ySL//yWgpZjLJwS1ZLhao3dDljFLlluKCvQS4VDcXWMao+/H1QzvmwUjFi1dnsvB6vKhmg1hZCfrYHlCbx1zEHayhtXCpGAWElt0XSPGFyRIx/CHoypiME3Q7ZBDktvHh7y6u7o8IzRiAVNhvLOKt7PwVyrvRV1El+Sax3a1bbDdZ3UD3W61auLJNic6USrMPErKtcm/R9zgU5r6+/fv34ZgVERC6B/wvw59u78b8Dvgf8p8B3gI+Af6PWetO+/68Dfwkdwf9KrfW//FmPEZdIWa8ppuPR03fJVQgCKVcud5f0wwqhsIwnDm/f6sewqCLTek9YdQjC6eaWed4zjyPVFl5+co11hlwKm6srhtWam1evyTaz7juevfMOcZpZphPH27ektHB5uWEYeqZRA5Mzhu2jLXGcub25oestJRnsqsc5w/3NCTGGeYq8eHGHG3qujJ7KcVKTmTMrUIzGHeiq1bX2Xb68L41iDue8EJVl1zbT5+aQVZCkyWYP7MoqlIZFPBCmqlKvjTHtQNYypCcwnFFTaSNEPZ/6gp60jcYtjXsgjVBWS/PwOI8MxjTqupBKwxbyQkEZnlKNApGGtuEQsslKWCvNAcycyWfag+TmNo5pLFwB1wqhoLKHWgvndC2FfloRpRWxh5n/y6wW0MJbjI4kFWWYarVsz63kJqEXiqkNvLUYPPmcEpArrliyZFJS/5e0JAwG3+voY5sTuq1Bn4dJTHnhe59dE6fMNqhhkipthPXKk2LCobjKduNwrkJcKNFBKXjXazHwkKvVDVLbytS44LyjLJmw6jBFSNaS06Lv5Z8gBvIfAv/PWuv/RkQCsAL+T8B/U2v9myLy14C/BvxVEfk14N8Efh34FvBfi8ifqbXmP+wBbOh4/K1foB8e0a93LMcjqSTCuqP3PWWemQ977u9ucavAdrOl5EyOQhY0SzaoA7Yr8PqT1+wT2H7L6mKL9ZZgDdevrukuV/Sl8u53fgGJibdvXvPi+ees1j3vvf+M7WrLYX9HqYLvPIaONy9ekVLk6tEFkjOjEfy6pxzuEGc5nWZeN25J7z13dxPBiLpk67GPGIuxmtpuxarHZuNVGyPKl2jjSKVQshahQn6Yw89YgB7FagZ21qPUh++pDydvNVBSUfu9Kg83VhXaWKAn/XlMgdaqn/kYDeeQM5h47qTk7DzWgNc2blALJSlzs+Ss3AUaHyULkpTHIu050ox/a3Y64jXeh3YrX2JCUgs568+IEWRu45r+YSOx6NMvpVAlK6TSyBLaeUgbS9poZUTHkGooZ3DD2KaTaQSt0la7phVQnPqiuqIyg6TbnJyTjo3NWBpjNQLCCFJM2wZlXu73vLw7fbleNxCC7uIMYINnOix0vaPvPRI82IoJukKf40RZCuIt20dPCWEgmYopbQQUJdLZvifPC+f92DfZwMA3KCAisgP+V8D/FqDWugCLiPxF4F9r3/YfAf8t8FeBvwj8J7XWGfiJiPwQ+FeBv/OHPY5xjmG4pNs9psYFu9lgU1SCkNMPmXSey2ePMaawHE4KhG42uOacVVPkcHPD/u01drdlVQLbq0vSaebw5pa594RVz+NnT1lvtpQ48+bz59y9ec3Vs0c8e+cJvlqOxxO4nq5zTPPM3cvXVF+5fHpFZyy1GxAKeX/P6XTk+maklIJ0K1Y289nnb5hOiXcfrwihU0UqZzm8o1rfONvtKgqCmobu1ba+y6ViSdoOt9yVM0pQG9+hannRbkDrgN7QVUcD2g2lOyYaKKjFRz/E2h0Y6/QMtkoJN7RVqjkDo20ThOasCiAlq3pX7yUVeBUtEKVUSk5ITKRSQAxOtLsxRWMwqVoMLUqY0/hJjTuQcyXV2aTd9LpmJbZCU9sIZ0xz8Bcd4WpSP9fGLWmQr36vVpLG6TgPlVCNoRpLFkuDUFth5YEDonR+dJWe249XUcC2VJxfKa7lDfPtHSUvbL71ATJCKQtjHPmnP3xOXDJDr3ERwQhOVA80j4WutwzrwNXOKYgvgg3mwVUt5YWyJEJYMY+Tvq4+aDxFXOj8CrxvQkLTDIfA2sADi/VrXN+kA/lF4DXwfxWR/zHwD4H/A/BOrfULgFrrFyLyrH3/+8Df/crPf9a+9vsuEfnLwF8GeHy55fJbH1BjIopj3B8buUzNbko8akvfVIWpZLr1ipQSRgzLNDEf9yCGzbvvMMdKcIEyjVy/fMXm8WOGi0uuHj1mc7Fh/+IVN69fcDoeefbtD7i6umKZRhKV9dUjllI43e0Z54nd+4/og8dUwzxOSFlY9iemaeR4jOSqkvTD2zvu74+kJbLbBmxVT1Gd16Xt8pWkpfkqQjFn6YemlJViEEkN5GydyJkfItKiG/RGVGo7WnRSRkRXqDlLAyhbQ19ym/Fb8aiFUnJz9LJYH/TxbGPE6twBreidQURTTeNtqPjNGjXiqZIbL6s2fCVTkxoAx/lInicEwT/Q+dXDRbynGqeKYq+dozSil6nmS7r5ubuqavJMhWpad9C+ns8orrXQXLgktxWtMSCWStKa04Dqh2L90CEqHJS/suHRKUnp9VKMFjsKBX0cqZmSI45McB5r9e9f7q/ZXl3x7q/+S7z+ne8TlwMfvdDEQfVwFXZry0yhN8pmLU44TpkP3+vYbdYEr6RF53uM7cgC85jwkpu6VrvN+XDP6vJSma7OYD3UyejavlZqTmS3fIMS8M0KiAP+FeDfq7X+PRH5D9Fx5Q+6flqv9FOHr1rr3wL+FsAvfvhuZZwYD/ekIoh3rPsBMZblcM/d9WtqKQy9ZxxnVcJ2K4JxGCksi7DbbkjLkZtXbzktBWMmXn/6mu2zS55+59tcPnpCXSK3z19z8/o1pmaevfeMftUTUwIxWDEsS2a/P+AsPH58RQgeMszLgveV4/3IaZqY5kgSTVFf0szzt/fEVBmAzcqxnCLzcaRsNxQUSzgzKs/441cJWueWX0PGtfVOIiriqjxgAXJ+QcU+4Af6In8pujuDiKWou3vOal4srYsopbaTXjcXzlcszYQGo0Qvq2I6/b15IJyZtnE+bxjOxayW1MK3Iss0U2NUe8VZI0mTd/g+YNysWTMUqkmUFDDRKPBnVPBnzu04TTNTSuO2ZMWWa5PmN48O7Uhqez1accitGFmorj5gPNWexYRZUZOzv4fRClJLo7oXfa1cEVIbk7JUqA2kTAZxhRIjUiymtuxj53C7K/bXB1799u+Rlom704F/8DsfsyyZTRBqrixTYb1xyivqhGWuhE67Dh88vu/wzuC7DhFLSYU4T/gQiDnhU1QioHPUZg2Qc6HaTFkOypjOiRwTxvmvYEJ//OubFJDPgM9qrX+v/f//DC0gL0XkvdZ9vAe8+sr3f/iVn/8AeP6zHkQESloI6w5XjDqUp0pMB0739+SSdVwJHf7iMTb0dMOaWjLj/R5jMnk8cLq5ZpkmutUFyyny/p/7szx+9x0eXTzizas3HG7esswTV+/uWPsejMc4wSwRcYVxiVAyq+2AdxaRQl4iJSfqsjCOI+NJ+SDFGA6nE8bDJ5/fcYiF01wZBstyWnBiqXnWtHejWM1ZffqQJVuKFpc2fyiJKbf2XDjL4uWsXDUAesMUKU3vYdsNk6klNXd37TJyiZpXWzMpRfIyafEIAR/WWG/UUR2NTODMkUCaIK2dBwp86Kq63bxKSIvqm1H1seuykKaZNB11S1SVr1CKAuBpPmKCxbuAcT0udOrn4Zr7mRGMBN0qWYMV1zCRQknadahAuI05Z61Lc6qnCQLreeqiYSL5TKQzbfJpK17JIOUBKxHrkBx1c1EVtyhn1a0ThASlgcmSSFhijFSL+o0YByawevSUNOyYb++Y7MTvffqcl7dHTNt0VSNEgXnO7NaOWKHvHRcb17pdUZ1XcBhnyUaYjyfKMlM6i0gHRYjzRLfeqIObdeS8NN4NFJweKM0Kop5Hvq9xfe0CUmt9ISKfisifrbV+D/gLwO+0f/5t4G+2f//n7Uf+C+A/FpH/AAVRfwX4+z/rcXLKHG5vwWg6mPMdcT4RlxPLac9qt2Nz8Yh+taaK0Xl3Grm9foshUQ533O7vmKeF/vIpvt/x+KlHuhVPHj3j+sVbliUzbFY8eecxXa+S8MPNHfO4YLynX63xuRBTxgqUHJlOB8bjgXmeqPPM81d3dF2Pc563N/cs04kXLw/MS2VcCuMCY1fxU2G9chz2qnUwuKaIbHTq2mb6rDdiqRnB6npQzqdqm9DlfINW9dg4cx+MYLyuFWtMevqguo28TJQcSTlTciItC2mZiEvE+EB3cUkQpegbp6Cf3nSNIv7gSAZaVVpr2eqaGE2dr9ZiclafEVGhXUGwrkO8rkBrGalzYD4dSNOBskRCsPh+TVhvcP0K1+wJjXc4yWppUBI5z1QRJWfBA528oiHbVWwDY0Gsbdsh7cyolWp1rCPmh02Tckty6+LOHRTUGqGkLzktTe2qfqKad1NzxZpKaZ1ZLZUcE1YUNyFrJ+CMx3hhWu746Cef84MffMGjy46bw4Qvqso1DsRUljETVp71YNhtOoJ3OKf5uH7osC5QcmIeT5w9D6xXrKaKI88LduiU9xMrsYJxgcJCFYuI1QiIP8EtzL8H/N/aBubHwL+D1ve/LSJ/CfgE+NfRF/23ReRvowUmAf/uz9rA6M8V5rywvXiEFctye0OshXmeWF09YvPoGV23Qoy2pSUujPf3pOlAnQ7EmOi2F1x9+AwT1sr6NJanH37IeH9Pt+1wvuJt0LzRuz2n44H1ZsXF5WOMM+3DkZFcmE4HTvtbDoc7qEKKCzdvD1xcbvHB8fknL3h7c4s1lRf7GRHDYax0zvD6lHmV4X0q6/3YxGt6Epzp9zknBR8xWBTBF1PVnEe0jS61aLveiE6lJC0cZ+GXEXJjh+Z5UcalFErOpDgRZ7UDXOaJZTppAFbo6Ver5pO6IvRnhzD5khpueOCGfJU8UNrCQ7+JLzc3jV2LFWwIOMANK6y11JLoNzvceqAaYY6RKY2cTiNW9gzDQLfZEVYb8mqLHwaK6zCuQk66xqaSAO89JrgH4lcpmSqxdSJ8iXlI4hy3QHN1w5gWFmUensCZqF9jUlC6ZHLUUewsZCy5PmyhNN5BtSaIbqvmOJKnI8Zmqml4V9Mzlbjw+csX/N3f+gn7KWErvPM4MM0FN2d6J8p1ohJKYbcdWK/XeIO6CnlD8Bq+Pp5Gaq54pwa41UCtCcOAMYoLTuPMarNhyVVDt1NUwp1YHWX/pApIrfU3gf/ZT/mjv/AHfP/fAP7GH+tBBDYXj/C+Y7y55TRObB8/IWwuCP2K1cUltRSm4z01VXzvuU2J1e4Sc/mYsNaIv8N+0vjI9SXBWd785CMO+2v2+zseXV7id1vWV1v62bFaW0qBdDqRsmZuHK9vqcuJ4zgxpYQxMJ1GYszYEOg74ZNPnvPi+o4lZW7vIlOsiBRiBVsqsVbmDHUqyD6SCzpXU9pIknX2F7UiqNVRrVHTl6IZN+WMeWTdvuhIcgYNlYlaKrqtSZm4RGpZyCUT55k0T8R5ZplPzKeReVmQMLBebbFhRVitGVYDzjplTKJ8EeS8zDUNbFGgseG2X/kQ1gcMk6bXcS3LhaDYiTe+qW8TodP4yCpCTJmxHpjjyHx/SzeNDOuRNE+EeUM3DFjf6c2NVWBXDDFXbNb3RAHmSq1ZzaOdVf1KKYohWSWtaZfXOjpvEKfpd2fFWi5ono3Rgl0o5Jop+Wye3LgxrgG3qBCxZqHmQjxMxNNRn3OtFONxMVErfP76Ff/v3/gxX9xFtoOQUmHZJ+xgsR5WwXFKhZUTLjYOh7DqB+3uvCjL2XhOx7E9L4t4TQYsMSkbr6hXqqQeydoVDs4RMWomlAve+wfn9697/dwzUY0YVuudVkrvuXr/fUoq2C5w9ew9Qtdzurtlc/GIuhSOh3sunj5jCJ7T7Q3T21vmXJB+TVg70mnPxz/6ETEdyLny3ne+y+WjS0yJ3L95zbi/YdwfiQjTPJGniZcv3+K7qnZ+oWdZEnNaWK17OucYhoEvPn/L8zf3pFo5LoX7WdmLx9xWfhbmudJ5Q0xwjM08uETIiVISJWcVmYkyS5WZkKhZ5/oiuXUhTRRWaSzRRgev6l+aU6aSSUtkWSZKWUixEOeZeZpJ84nT8Z4pKmjZuy1SBe87Nps1fd8hVSEQ1cZoR1GKkrak0cGrtJWnaBGs9cys0C2FTlONA+GBpICxs4IzymJ1RiAn8tMnTMcD0zRTzMJiIuN4ZJpm5ulEv54Yho7QrXF9rxuiZtOQs/ItNKtG17ilaggXTZlbS8XYqE5ezVCo5EiaZ2z0GoAlAm3TxZlwJpZStc0vNRNTQUobcwzN7U15NQruClkKb9685nhzTefVUc4adZB7dX3Pf/f919xPsXFvwDphP2YurTBsO6YxEaTy5GpNPziGTmMv+s1A16/wwTEumfH+SNcFzGrQLikXvHFK2kPp+bYWnK0q288RO6wpEXVxd57QBIhf9/q5LyBiLblUDrd7fPBsLy/ww4Z+c4HBcLp9q8FLViXPdvDYkjm8faWnpwMjgbC6IM8Tb794Tox71rsNz977FqZWXvzgexxurlmIlJjBCMf7e169ekNB6Dcrigjhakcwjnw4suk7XXVax2k88cXre5wxOGN4/XZknDOxAY8bLxyS3ojOwrgUctF/Usksc8KGhNikpKpa20LQNqq7VzEeKn6rVfkHhkYGIwFCKZEaNUAqp0ReZlIpVIks08J0OjGNR07jkXGaEKshRn1zmO+6ji4EXPMXMecc2Lbm/ZJz1P6jYQ5qZfhlF1Rz05CUqviNcZpg39ax1oo6kOmOBB96Vv3A+vKKw80NKU842xPricM8M10vrKeJebVhvUl0y4TrBlzfUazFZIfYQrapbYZqc0lcHtbMWGWNShbEBi24FKrViEkzz40f0gpHLmArtTpdo9eszmTGgSjvRIl6ugo2QJZIqZX9NPH/+u+/x8vnb7CmEkTorKGYwjFlbsfK2plWpHTbVlzlMCeCF64erakpE7zBFnS8NYI1lmG1IpfM6XhHyoU6L2xXPYkmcKxVjbQax8cKuN4jcaEYR10WrLMItNTD9I3uz5/7AmKNYRn3eC+sH13RrzdYN2Bz4bS/Y55H1ceMJ47X14ynE6HX5PHleKKIZ9hesr3acvviFd3VBbv3HjEYYbx+xec/+glv9if6zgGZ6oTlMPLq9TX9ZmD3eEddKrYfuNztOB2OjFNkWAX6LlCL8Onnb+l2K0pa+OKLe24PmSnDemXJqXB90hPACcwJ9TEplfgwVkRityDGqeWfsYiLSNHQIBp3qqRMSQsPTWdWdqdYQxEocSHFhRoXVSzPkSSVnGam8cQ0j8yniWOcSNayGVYMqx2+W2PEseoHjco0enPrtqHpR3JRLKaxMOtXxhjOHUkFUuPkNLEdGIw4rM2krPCvWAXwRARxBWfUE2W16jVW0gasazewsUyHibS/I+WFmiN5WBPSgo9r9Ytt3rEa6amq3tpeN6ToSjZVSFFvdqvJdVWkOdt/ZZNlDNKguVIbrtHo8bU+0PMas1MemKxn+l2phdd3e3705p5T1EOkZLgMmZUXjtlwNrIOCCVVhrUhLYWYhXFMXD2G3bMttlakRGJJ9M7hVFKNcQETerxkxts7+lXAdGqFWVOFzrUxrbDEyKrbIfNCTpFEc3oTgzXxn8Gyvs71c19A4jxz/8Vn9JeP8NZhxOGsYT7tmU53YAzjzWuuv3hJxWIHR5wmjBX8asfqybfwoef46hXT/h63DnC6Z3+65+2ba96Oe8Ra5uM9GSGsPIdp4fLxFRdPL1gNK+bTQqVwvL7l/jARukDoV1hvuX59S+gDcxZu9gufvJ2owG7t6AXeJkjths8oAYrGy6i1siwTyzJhJ9us+AaMDThxpGIxVlenuagpTakLpjigklt2q0SjdnppIcdMGieWOJFzZp5H0jxzHO8ZZ/WfwFv61ZZ+d8lq2ND3K4b1SmM2BcQ1yW2tSNWO7uzmpWNTefhv3Sjrc6q1UFNqDE21M1TWpuIo1qlkXkRUfIZQE41voWFTJnjsYhtw6xVn2BiWw4H7w5E4R5a40KeFISw432FCUFJVM3g2VsBkTPmSHFOzrryxltyiIMS0UctUZcwW2hNqz8e2LXVW7UvNlbP0WYO8aeOMcmSqKC/k08/fMo8zzgnzUukt9FbxpJQqQzNJVsNrZRqLCMEK1qERokDf98TsoGRC8NhuIFdYlglvHMUZJgRnBMkR13UKugMxRZwYcqxMS6L3BlkiJS0s5cyZieDPyYNf7/q5LyClFnBCv9vRbdZ455nu7zne3VJrplgFodZPn+k6oCZ8r2NOt94x3R+4/ujHvH31mm7TE9/eYmVGjGGaM2mO1HnPaq2knHmuPH7yWH0XlpHnP/wU4yz9WnNVtxeXxGWk73RLsUyJeS7cTwufvzow18LGCd5UkjUsLSMkV5qdn96IsW0McoVpnrHe6lYFDRGqS8F6sMVS46JO4BVq1Vn3zO8oJesKNy+kquSgFCd1pZ8WlvmobNx5ZJwXkrFs+gt2l09Ybx8xdJ4wBMLQk3MmxYT40oKTDCKlrUTbyVsqxbTQqkxr89tSNyfKsmiGi9Dk+sqVqI12jlGDpDPNO8VFC9+yaBRnyi2wG3BKDbc244eeWCuHcWRJC+u0UFeJ0GVMijifcCZgQzNWkjYKVjDe6N9TDaSC2EUFhrZCgmJVT9JoYw+bJLVorGpWpRZiX/JhRKX6CuRaYgWqIZXKR5+/0ZyetgcerOBEiAmCVLwFb75kuJ5iZfDqe7pZWfrgyFWIMRFCoB/UGsL6QEqJ6f4e5zqWNLO6umARwYxHOt9R+4BgqcUSa8J3ysNJ1eFCT01JYQERUq70HX+ia9z/v1/GGPz2EY+evaOGQPd3VATXd1CzZnTETDwd8GHAdVYT16zl/osXjPe3vPz8U/rdwPHmDb43rLZbbl6/5PrVK+72E+9/+x1Wq45U9HQdr4/c3u3Z394wVXj3g3fo11uG1Yr9/Yn11RNCcDz/5FP2c+TN4cSr65FX+4VVL3hv6DrLq7vE3PwxQVf1uRnoLLmwFJVUqzuaIvi+VOhqO+gqxeh6Tg3/dJTgDOI1XUmZFlLSNPpcVf0Z54k069gyziPH08xUYfPoivXFFUO/ousCfhgIocNYy7LMjKc9tQq27x98VimN4d18QevZoatFFqiGBEpeKCmTUlsdG9/eRChnjoYVMhGhktPCMh5I45H5tGe8u6fmTPDuAbQFIS+JsljEeWpXOc6RfH9PionNOuL7lQad+4IXUUNjMeQpYaTihh4VwTVSWDIUWzDpLAZsDmLNb+XcJYkRCjqCmKpmzMrdkWbAZnTNfabVG+G0JF68fE0wwlwqKyMEB8eWdTsYzbgVRJPkRPusYKAPju3KYYzFGshxRqTidzuG3Y5cEvN0T8kT0jtq1eiGfrVV4mEqBGvIJarlxGLxtiOKJ5aKFV3/p5R0FPWB+tWR+GtcP/cFRIzlw1/+JbwIy2kPokrGMp04nEYwlbtXt4TNhs3VitBpCNT1i8+JuXK4uaa4yt2rt/ghsN6sON5dc3tzT3/5iF/6cIeZ99y/fMM0R7w3zLFqMDaWy6vH7J6+xzBsON3d4TrHZj3w6vPnHKeJjz99y8vDkTlWdr3Be2EVLHcHBadK+cqBlr9cdS6pMuXaTmdYloWaVYBVCvhaoQxUV5AqKn5CT1Co5JwVqEyLAqYlUVJiyYl0mshxJC4L43RifzwyFcPw+ILNbkfXrzT1zqFkMQvUwni4Jy8zcZrxw1pT3L5iaHx2aVdHANXRNFmtunelQkoLcT6RohK91PagaJp9VcUxRkG+NI+k6ciyzMTpyP3diMHqYV80y0Sk4sRTbMR512YKmONCPe4pObNOERcSpQ/kohaTWKFa/d1TTO0G11S5VGvTjOh6E+tUHNh8V6poZ6GTifqfmlQUfBShYDD1S9mB0pkU5H775obT3Z7Yup9Og2rUrR1UBCfg0OLrRegCBCcMffMnNZVh6EijNIq/2hMaHxg2F5Q5Qi30fs0S90gu+L7TQlZo9Pa25WmdzpwzRhTQlQfjqYC44cGW4etcP/cFxIdAbw3j/h5chw2OcX/LaUm4PjCdJi7ef59+taJzhXn/huV0JKeFeU7ENJNjJJbI1WaNE4vrL1htC69evODw/Au6wVE10oyK4XjaQ9dx9fhdnrz3IbvdwOF4z/76hosnl9y/fMn93S3f+/Er9vOi8nwH01IZBI7HxJQqp6U5lJ9xxq9cuVTGObUkMaHkxJKqnuL1zBwtGihlG7GpKIFJgJKVml5KpKRIipllWchRDWxinJnmif3hyH2ubC42DKsdwfcE22GD5qMKmtZWcyGmxPF+T3Bv8P0aP6waxtAr/uQEbxR/Ke13oUjjVijTNY4jy3ggLidyUkGZrlnVtMdIIadCnE/kcVKOhYWUYE6aC3zOt5FiEFRSYH3Wfh9dyaaamJdCGk/kNLNeV2rtKSkQzzkw7f0UE1F6ZzOKLoKQW/pE1bZetOsoYjBSyaZ1FhLBqrgvVU26M0U5OMWo12xxio+knPjsxXMO46RGU6ayCsISKw4IIgSjtH+1aa1sRI2TfbAQLL4PBO8xFrpVYNiscY21X0vFW8d6d8V8OlFSVI4NWvg6HxSfCUZNvnPB2oDvO8oCOSbmHPFGg8pyWVji/CdHJPvncQkQTweq0zT55XQiVcfqcsUyz/SbDh8cZjmxHA9QE27VcXrzliIWGwJ1vycEy2p9QYmJmxefc3d7yxefveDJ4zVuCIjvAEtMC+/94nfpt1dsNzvKEhnv7vjixz8hl8xV7Tme7ri7P7IfFx5dej76LOGDsOqEecpMS2VurX1jNv2+K5fK/rSoShKhxqqh0bmScyRR6ErCO4+x6khe2kyu4lMNYC4lU5ZEmTMpR9IyMsWZ6XTicNhzvySGi0v6VUfng1rfWfU71ZhHqwsTa3DOkcRw/cUXxNOJ4eqCzdWVrkydnoRODE5sA1qr5rRWyDTC2mlkHE9qWD2N5HNgthRinDhe33N781a3Za5jsx1w6x0SdnTDum14CtWKbqCsQCr4HLClrZKlkKonmUKMidNSEbkn14mSh1Z0DRq9oAUOnK43LY181VLoqGQrzaaguZWJwelelmIsJkPxaPdk3ZfeIKWASUCgUpmXhR989AVLcz3um5fsXJXRu7LKG6FqnMLgdPSx3hCC5WLXsRp6QuiQIgyrtRZUjGYFUUhLRjKEYcP1qxf0zul8KYUpTqy6DmkRIHmZECM4H+hyZYq6ZgbNQHYtTuSbbGJ+7gtILYVpSbihIy6RacqEIbDc33Daj3TbNRDBZNyqw5SOV589Z78/cvXOu6S7PRjH0w/eo6TE3e01S00sObN6fMnVu48Iq575MHPYT1w8e4ypFl8qx7fXdJuO+zev2Y8Tv/QrHzAf9hyPI58+v2M9ePb7GZwCpadD5tjYm04EZ0DST58wS63cHU/6HF3Tw2RHjgtLHolFyN2CD+fAKXVEL1Ud13JSMLWUQo2JkiaWZSHOI4fTyN39nill/HpD3+mH0rpORWqhwzQilukCxrqmLyt0qw3pyVMOXzzn+vkLtrd3bHY7VX5WxTD6boXrAkYMqbmYVzI5ReL9xDQemfJEXRLFCSkX7l6/5ouPP+N0mBjWK7pdwHaekxhW0rHuekLnG0jbUteaCU6tR6or2OgoNakq1TtKzCSB/TSRS2ZdKzlXOhcQ7zASqY1cVk3EYNpm5UzHbyrclBHjvkywD55iDFYq1XmsUW7Fg9u9aeHfDcMwRbc4t/s9n3/yilIfGOfEVvQ0VUNvXidgg3KChpVh1RmGTcew6hnWA/OU6ZzB94EUF7pBtUCSkuIXVdf/vg/kJatRUbNLUGd4oBqK81jjMaaj1hFnhUog54z32pFJOf9eX+/6uS8gpVaq7xXsMvqi33/xOSVnXFBfSWuNrsTEEqcDLz97zvDsGcZ4ljnSX2xxNZPjRCET55E4L5SYCF1g2Y8ssbJ7+gQnhvV6xelwrwlgqVJS5P0P34Nl4ng88PbuiAsqkT5MhRgrd0tuLW7Fi9AHpVj/QQh3Ba6Pc7NodDgvUEbmWolTIsUDOTlCbitKcRgcsaqoi1LV4SvqWjOmkXlcmE5Hro9HYkE/kENPGAa6bqPYR+jwnafrtJhY7/WUKypUwxq6uubyyTOs96R5Yn93xHWRLqguJi0RN3eKK5SixSzNxLKQlkheKknUaGcaT7x6ccOb168Ra7h4/zHbzRbfB8RZvB/ohhW+83pa9h3VdQ+4Ss6FzmdSVXdyEY+xWSO/OwGZiMVyiomSDtTak7uEqz3WGoxJ+u9iSOIaMa/y4CdbBWNrI4cJZ3tZYyBiMOcIhJRZmU7HmWa/+LCSNmob+fzFDbe3B3qjWEetwlIKXetELKKQkQiGwjoYtp1hs+oIg5L4wOCdOpBZ68mx4HyneItVvKqOMw6LzSPGOHIs9GsP0ZKyOtoLuu5dpgPRwjQvdFZwnWeZFnIuuM6qJ0z5E1Dj/vO6RAw1Ttxen9QfM0XlVrnAarcBIlSLc56aM28+2dZVqwAAgvFJREFUf4HfbFit1ty8ecP+/g2XdkOdKnOcieNM3M9K7nl6hTGV/vKCFQGk4J3nzfPnLDXz5L132d/cM1xdkZYTyzQyH2b29xPWC3c3M9eHTCqVVFWC0DlRunqszLH8obX95n4ipQK9wYpQS4cXHW+W0wJzARcoOWMN1BIpJit3gra6nWfiMnMaR8bjxO1xIgddO/frFav1ln61o1uvCX3Ah16dqpzDhdCIW23taRxCxlHod8qZmPb36igGLAimFkrMlDpqHm/OxGkix6g2AVQwuiE43o/s9wesdbz7C+9grMN7BSwtahjU9Ss1F24jqum6Zlykmw6ZE9kGqivUUNvJr9uEABQJVIE4LyzjxH5/pK8Lnc84o5yh6l3Dt+am3TFfblMqOuI0Za12PUnNnQw4vNLxOxAs50QsMfaBY0KpREl8/8efkFOiA7wTYqmkKoTzxlvAeUGk0AXDahUYBo8dAsEpwCyl0PmAMY4lRaw3jfGacajBUKrSmNfqneoMBBtINSNWWJaRLnR06x4pkZojhcz9cWTjAylXKg5fDc59fQAV/gUoIGlZuH39Gu+VhORaxV/vtnhnWaaZYbuhxoXD2zfsT3s2V4+JMTGfbsnzzLB6RLUGWx0Vwa4G1psV1hp2j99hnmeObw/0K8erjz+nGMvls2eUOYHVEzrNkdPhwHE/UkU43C28OkRS04I4Ktve4IDD0rJUf8Zo+fY0c5gnLrYbjPV43/JFQqXGQqpZSU9SqVkJUIVMiqrHiEtkmUdSXNgfjuynhPSOsO5Zrdes1hvW6y1h1f7pO0K3wvcdru9wPoBzgGBdC4soCecyYUXbYhTSqIrP1DwrFgqpqVNLnFjmiRSTttAIdB3znJnmCbOy9M4+xE+IWO0WTYfzPaEPONfhwqppXDzneM+com57GuZiatFYRwTJjsiIE9W2ODEsreMZ9xPbUBl6TzEem6OGgduWmyPodqKqS30pRYuERM5B42I93qpU3zktfGftUWn6ER1hKtTCaTry4x9/gm+uZbFhDU5rMx7wUukFhs6yWXvWa6/hUNZgjKelomO8JaWETYZ+u2vkMEdKM8YJyJddQ54W7Fb5LM4aMIWsZsDNJkKjYZdjZhZDrpWcZ8QUYpyhtMzjr3n93BeQUguu63FOFM0vgusDzlmW40R/eUnwnuPpyMvP36gHRq2c7u8Yb95iN1tldhrHNE2qroyJahy7R1fkeeZ0e491ldP1PRXYPr5sUvDCsN1wePuaupy4u73nZlzIOXOYM7EqQcjaqpZ2uXLKyuHw0kKO/5AeZD9G3twd+eDJO6q+9Z5SKr4GQl8oy6ztdoFYEzUXcomkeVHnqiWxzDPTaeR+mul2A956utAzhA7fqejMB0/oPKEPhK7TNDxnFWh0DmccYnS+z8mQRe0VfTXIJmG8I86RelRQNNeCJcOysEwn/SdnDEWjPkOHGENY+8b6VLJVNZUqHheCvqd+0P/2A94HxVXOqXOoy1fovbLwYsHwZTi4i+7B1iA2b1aD6Lp/sdxNkZQSq6HiqtXs4WbcbJxtCXwARSMYxChz1jRmaIlYVkAbeWpzga/lgYX68M4K3N7vubm9b9aOunbraiU08qB3QudE1bYrS9c7LZbWY63FBkupGWsDpu9Y7g54MRjfIVi6vmM8FQwLlrYWbpsjI4ZSsgKi1eF8oBZI84jzAzVVhq6jILiSECxW1N4yJ77RFuab9S//HC4RwXQBcR01q6N25wNlWagWNts18Tjx4rOXzDnRdWuW08h0f0cuwuPHl6x3O2o1xJQYr+9ZiqG/eqQbjyVireFwfU2MC77vcdZprm5w3L5+S1wW7u72XF+PSlgqhUzhsjN0zZfmlCpLVnJAWza2eMg/+Fpy5rNX9yxV087EqLTddj2hC3jnGvaDzuhF+RRF1Mymosrb05jwmzXOWQoWsT1ie6wEqlUQ1hgVteHtV4K6NetFLNRmHCTOIMFjGz4iXY8NvTpg9R4JVk/YXPT3jok4L7CMauHnBON0/Zmy0umraAQpzmO6rv2dA7bTQuKHHhM8phU744Ke/KIm5j44vPfYYLEu6GsUDKFzyloVFZp1XWC1Hlhv1riVZ5LKaZoVXE6RmDUwO+dEFmk8Ew2vylRSjs1lTt3gqq1KHjPSbtazH7xQzhGWraN5/vkLmGZa0J12Nwg567Zl5WAVhM3aEoLR/BsLoXd06+4BK7PeN9q/xaJ2BdYPWuAEnPPYrmuAb8IETzGFYlV/5J2jDx2JxHw8IsbSby5BoDNWn1fbwFnrdOT8Bh3Iz30BMaa5aqWEdx3d0CNpIU4j2+2GdDqwv7vj+vqabrOmlojJCzmNXL77mPXFFm8d82nPMk4sCFfvPKFMkWkaESnMd3fEZaGKMOw2GMAFyzQdmY57KAvTEpmWjNRC5wxDMNquZh6Mg1W90STatv6h+AfowfqjL94yL+qdKWIR16n7Vh/ow0CwQjAW39y0Xdvhi1PGYSwJ03k2fU9e9IZQYL1wFrI9SNpNE7AZdRozgG2B1WJ0tac3o8FYi/XawYgNFKs3sOk9bvAUqx7lOaixTc6qAp6XmcPNNcfDnpgr2UFugVmmV3cxFwZsGAh9T9cNGs3Ydzjnmt9qQXLGWMDrGCHWqruZ0Zu65co/bEWsK9iQMVbn+qHzDLst1XeMzVPWWtWrmAy2MfySaZ2Hkwdg9fxaWGfaCphmoqxjSWuCNPRQDEst/OB7PyEmBdJrrdjGJPaigKzzgnNC7xzB6usdEDqnI5Ithn7wOCwmVbzxhKHDG4s9R5Km/NA5SqmqKrbNLlGM8mdi8z0xZ0U1WCk41zdinHngFpkCzvffZAnzL8AIUyrLGNlcbhGpBGcpOeKrgTxxd33L67d7vGSkahsX5wVvPZvdjn7Ysb+75nB/YC6V9ZPH+Cp8/vI1v/Ar75NHlbzbvqPbXdG5nhxHTvcTKR6IJSIpcZpnlgIuF8QKadH8VGsU2HMNUTOimbXeKi7yszyvP3t7z/3+xMWwUVVptV86nmeQ1Pgf0mGMKmI1t9ZRbTO2GTSsaDmMGJMxRTcIFWmApHnIdGnVRb1DxT6cProZ0E2XFS2IWap6w3YFT4eYRJnU9c1YIUkmSqJ0whwNJUY4ZjVg9h5rAtYoQGo79Tf1vsN3HSFYgg+IU9Mf20BJdYgXjKuUYnULd/Y7QY2Ra0mN2dmMmKLaTdas9ggVg7MBYy34zOmukjPauTglgmGs4g6+UeyLNCezjHiLt4K3QbctWOXMGM3n+fLAVgej42ni+YvXjFltA33rENuyB0ql7wybdVDinjUMq55uCLjOUZeIC55+vWaaErZWXPAY79UHh1G7ssYFQQzGZWx12Ko+sKEbVIsUs3qlLKglpOuYpglnLathQ3ITsQn9nBG883+6MRAxwnq3bl6lhnk84a3h6sP3OLx6w/5+4e72BhuPRGfpVh3jeGLJFd91lGXidDqQBcKwplSj3Urv8c6wzInqhPWwY3t1xauPn3Px9JL5uGdeTogzjIeRPCeshRRrWw9qhIs1QiqqoKSRk7yglOg/Qmm/OS18/OIF7z15gqui25Zc1e/SR9Vj5Koy+SrYFCgWChYjldJHPU1wBLEsuVByUf8Pc1SAjoAzQnI9zoUvVafWPCS/UVQ6r8VDI6GMNfgkaqrsHaVadSpzDjtJY4wKGcA6Wl4eNFDQOqOjj1cv2xBW+NATgsVZ3xzDGssWDds20rJjULqmVO36qJAx5KYnSjETU2SOkZgyOWZqjPq7O037MwJd11Fipi5JjZmN+nuYoDcezrQilSlGw6at8e3dc7qZanwUU9UNPiPYquQ4BF68es3N27uHzVBnhUBFrB4km04YjKULliCWbnA4a7HWtgRL9XbNEaSobyze6L+tWi4a63HeQklNLGj1lS8tMMp6Yq1Uq05rtoIzlUrGimAs9GHNklYY7qFkbOi+1Dt9zevnvoAATYRlSKcRYw3ryx1GDNdvb7g7npgPe6RGthsVXsWY2Dy6gmI43NySUyGsNpRquH1zzTweWa0CVrSL6LuO1WrLcneg6z3z6YTxmf3NzGbl1UM0a6yhVbtzghNiVam+i2BazIh6dwi20NSdf/ibE3Pldz55xb/yq0cGPFacgvHWKhhWI8ZqRIMpCeMFjBrixFKou0w0ljwnuj4wx4V5PLDs7zkaz2mzZbO+Y7m8ZHMxUrcXsGww2wuqXWMFbAtsUlWtjmA63ljEBcV0qofSYVyhiCM5hwte7QQCCB4fF2VMWsE7q6HPfkXoVpiuI7hA16l/qRXfslqab2lpVPLafE2lQotf0Ju7UudGgy+FuSSmHFnmmRQjpJmslRwnFmrBiuJZq5UnIQTbqbdsKIotGN/GO0i26mneyK+aIidaqIEiRS0GrNWC1zQrpRZ+/KOPGcdZ7UeatMiK4I3iHkOnMv2AoV97LTS91QDyBL7zOC+kRYO3bS2E1U5p/mnRELJSCH5NTmoWXU2AtJAtGB9UpFnAeodIxnpHCAHb9dSayNkS04QxPdY4bFCTKvPgP/n1rp//AlIrw2atRjI1450yFu9evOD+fk+aT+R5ZLjckqYJtxno+p7VWjNz98eJi8cXpJR4+0KjGyrgup7gPNlpsrnrPNN4xPeOcZrIVZmVSyzEJSptPIMxlZJ06xJMoTowuTJZJbkJim2I6JR+pgr8gU+Pyo9e3nJzPDKsL1Xu0URg3nsVzFE027Q6TFGDG0pF1mtwnq4kssucTkdO+0QumTcvXnN/KnTO42rlycWOd957xNNn77K7vGS1e8xwtaNbr+iGDa4bMF7bdPXKUBAzi9GYTYRQCtKyS5Tu4cihJ6aIj5Ea20glFecMRjy26/EuKBDrA77rOFOpCwa1E61N9Kth1bWZIOeaH/JsUtSNzzieWKYDh9OJcX/Pze0dx/sTpMj2YsV6t1bWrff03uOdp5aM9Iqz2FrJAUxR4LUaleXbYqimYq1TgFlsk9tXxV0ad6Sew3uKqnjHuPCjH37MnDSbp1QNoDJOFbarXnBBU+QSmoXsXFspA2Iq1jsqhRQnXBfIcdFOrhR1jfOdrrFdQcyAjUecoCt456k5YmxHigUjAWpBjILSUgVjQyPKVUrSOBFvFXuK8/RgPv11rp/7AmKsSpvTouaxu4st+XTP21cvKbUy3t7hVlucCy3dzeHCDucHpsOebrNR67bjohEGOdJ5R9dMaK0PBGvJUWMN4ukEWVgWjT2IU2RZNIsmZegcpFqxAcyiLmPZCKEohTg9iOc0zOiPcr3dz/zks7e8d/UexQmuGdqIcRiXkNpaal2TKE/BmGZ47KlpIUlitRoYxkQykEzArTUr+PD2jh9+/orvf/qSZ4+e82d++ds8eXzD9mbLMKzw3UC3GrB+hQkdftUTViuluBttkZ0PurERFf8F74isdSsUE2mZyXMmlUSNmkfsjdUPcghI6BT8E90u1JIRUyhFkFyIJanJsVRyXKCqhibHmWU6ctof2O8P3N7dcPv6hlfX93xyt+fNfkFKZe0su/U9f/6Xn7G+2hCso+8HjDEEMRSTcMEqVb3q/CmCUttrbfaLpsV1SnveDSMS3/ghbbxrTkMCvHj9iuefvVQMSZS67o0wOLgMuloeukBoIKqanrmmNk50/bpZN3iKLerVYZUomHMmWA+x0G+3xDyST3eKF1mDLIUuBLXByRFnHd4oXuOdUJ2DMuOomDCo7qcoWbKq4S3G+z/dWhgRIc8zc5zYXl5ipHJ7e8eSDfPhhOs6wmrFPB9ZbzfUIgybgTRP2BAo80LwPc9ffqoepHMGq0Sgaiy+k5Zq5sjTQQHAkhExLGPChkpCuR1WtLsopeCtYZKCM7CY+qDIJVdci1Uw8rP6D73mlPnNH37O/+RXvkvoz1ml+uH1oVcrw1qxtfEgmvkNVW3/krGIifT9muAV4Hzng2eU3LFdbVh2F9x+7nh5d8Orw4n8+pZfGXoSlWle6MMRt1/h3V5VrFYwLtANHWFYKa06dPrBJSty33tszurVYRaicdRQtZvITdlcKzWLOqO3FWrJmVQ0/KrmQk6VPE/UNJFTIZdKLlroyxyJy8w0jhyOI7eHA3dx4UefvOauFG7mSFeF3bpju9oq69L2OOMIfa9S+FrxzoIP2AB1idr5oDaGWIPJSgZUPKYg1UAzbBbMwwZLMZJmbWAUj/n+Dz/lNI7Ko6k6DvW2svUWE3TLUrKKY1wIirG0LtN13Zf0hKquY7UafPDUWnChJ+dICcPDinve32OKxzrPskRCLfp+iG6wjLEUNPzL2qBFEdoBK5QMsZwYxwNiVmS+TED8OtfPfQGByv5mz+bxjs16w7y/5+b1DQW4fvua7dNLSoksS6LLmVqNipecGg5X65jHPfeHPevdjtN0zbMPv4URwdlAteCZiMcJZwzSe1IeISciGXsOgytVzYajqkWNM/TWMDd/0GrP1Gq9/12jSf9RepAKfP+La56/fctms8b7vlmhOrCWWidcW+WJgHMauaAAn21GN4Yu9KxCx2ItrlshbsBEw8WwY2Ud5RPh07fXXO9PyKNHmK4jLzOnacaWhO86nDOIOIydWQ4nnN3jfGOQBo94ENfhVx0Yp5wS6zC2OYGXRY2eU6KmRBoXUjoxjbO6pKsWkJIWYirUpB1Hrhq9kJKm/eWUyLEQrTBPiWXJmNXAarWD6yPL8Yirhvc2a5493envZA1XV4/o/EDXebzVzg1RGX41BbGuqZiLiuCo2GqxVrk4tra1tm0cJES3X5Ix1bZxTp/EKS587/d+qBhRe2+uOmEThH7V+DK1EKqGWFtrSbZga2ZlekIYVItjhFqU2SpSlLqOYmrWtVW6Wt7jV1vmO1UzOxuo4qmpEFY9BdStLs0E3yO+w3UdxjhKjgQ3ILUwLZOyga2Fc5rg17x+/gtIUanysNlASexvrhmXSMYixjFPTZC2WmGwjPPCarfleHeLcR1u8IzHEy4EKonNxQWrzZoyL3SrFWmciKk+bD+kCqSMBNdiAKEa9XQwwgNrT3JisI5iwEqm2kofoEYAlY07+VIu8bOuuzHy2z/6lF949yld6DSztPExjJIQKGXRYmYd1krLufYQFEvph57QdWD0lBvWO7wbyFOkF4eNicPhxKe3t5zmheGDb9EJOrK9voFdz/HtLcR7Xe9Zj7Nq0GPF4IK00G4FG43z+GGF6XqV9udEipE4TuT5RFpmjZNYJnJOWOOoxhJrJk2RlCKkpZnfFMrgsOseiyffHDFWWH1rR7w5wu2J8PgRCe24Sqp8a7vlg6ePGLrA+mJDvwrsth1d6OmC5gGpt+pXbhGjW52UFZglqzeqiNdioYYhGGmrbavkK1PVRAhpznBW+Pizl3zxyav2uYDgKtvOMvRCpFCXStcZMII3RnU5YrDWYYPFibDkhO+CjnR4xT4Qak6I8w9xpHGZm4B0ABNYFnUdGy4usS1w3HWDyh6WiOAIq751tJpuiLEs4wlrRMlpBrqw/ka35899AUk5EVY9nfMcb254+fK1rvlKpNbMaZ+4fPSIzum2xPmO8faepVY2g2c6nXBO7fejVC4fX1KXSL9Z431HPJ5aqdf2Oy9qC1iLMM+Z0MvDhmAuCpSZ5qhlpeKsxViNlXTBYbOmmZFb9fgjXrlW/vFPXvE///W92g36oCvWqiCbeoV25Jjb92ecVUdyqUoeCn1g6HVNiesYuo71xQVlhuhHeq+blle/9Ttcf/qc8iu/SPfoEV3fcXKe3S+8y+nmlpvf+QHj/T143a4467BB6GJo6lPbgsBnzP0e6ztMZ4jLQjxF4jRpbGZJ5GrImsbaDH2rmjyVQo6R5Thjaqa/XLH77ndYPX1M3O/Zx88wqzXunQtO+S1TtsQuEA974jjxrbDiu0+fsRrWbB5v2D1aY6QydJpcr5R4qy5mpSI16cjS8nqVs9MCt0XpAmp6rliTkq0sWQrg1Me14UEF9Xj9ne9/zGmOOKvZMOtg2PRqdDqdEoNXJqmzBmMrxqjmyDhRFmjNatdQKsb3zUc2a/HIkeB3nJaZOM90F4/I6YAsidN0ZDnN+MESD3vCxSMKYFPUhEvX63vUuD4ab2OpadEcIqNOdFYM4gx/qte4IoZhs8XkmbdffEFcRgpCnhYohSVFpXwDYgxx0ajG7uJCEWYq3g3UnFmvH2FTYV5m+qGnLBkbDHVW1qbtOqbTrCu6HJWPUWCq6oMhWUip4vpKyYbY3LKNNRiTEVNxTpi0U+ePO1p+en3gdz/+nMeXO6z3BLuCWpGSG/PxTB7LGN+rNb9rHxAK3nf0XU8aI6FbYZ3BO4fvehaxrPqe7eVjig18//nHHF6/ZnNxwboPrN57xvbJUzZPnuBi4fDRp+R1h73csLy9ZX77hvl4gmqwxhKs1Q0UApyaB3EmzolSE2rdupBaILopiZwixQjdO5esHl0STyPm+Q1O4OKXP+Tql/8s4g2TC0wXt3B5gXRr6I/EMFOmmXpz4s9dPeNyWLO52NFdrNk8Ug0QZSIEfc4q6G1BU2So6vrGOePm7JlhGr/DFmpdkOYR8tBpiLJzMaUJb3XMuDuO/PiHP6FxV+kdbIOwVCWtiQXXWZwzVKuM4JQrITi8t7STCOc9y3TEV0NFyW+VrBnPVXkr5EIlcBpHjAjLYQ+p4kIgF1GWtrdYG6h5YZlG3GrVuDzKPs5xJplIyRkxzWNmmbDy9aX88C9AATHG0PeBcX/L3f5ArYXT4YRxBtMF1r1nf9zz9Nl7lNOJZWmhywg3t3dcPnmCs8J2t4Fl4jTNlOatucSo9Hi7kClMZaKkhHOBvCSME+ZamabKZmU5TeokbrKQgGUumK6oYKpCFzQF3bZNjPkjDzB6zbnw33/vM37tFz/UAuDVa1OqxiUaUzHGkWLGVRCn+IepgPE4vxA6j50jwXX4oBiABKG/2MIpsRxO/Pqv/iqPL7fc/eRzttsLLh5d4IdeqdvA9v13qHPCP37M+oN3mA4Hbn73++w//pScCosRsljyvEBZtEtKhoWJvGSKqLu8sVC9o0plOSzUVFi994TLP/Or+O2OPB0J9SOsdVz9wrcZVhtqTUTnYL2FfgUIhzd3vPjxx1z2ay7Dinc+uCI0ubrfrQi9oZaIVKHzDu+U9q6rZNRPPpszH11fU4xyTaiIVIwU7TAQ5eLgHliomnZ3ficrFcMPfvQR969v6Aw4K+w6zeY5HgrrXhi2HmeVqeyCaFBYLljvoChZLjg1SDIiLHNm2ASsE8hzC+PyeFGukRGHc5bpdMfh7Q19F3DB0+225JowOSPzhF+t8UEaKJMQK8yHPf36gligpkg3aLcj1lNy+lOOgTRtxvWb1yxpZDwdSUlt2vqNcPf2ls2jLaHvefvyC1IB1wcNAKqQYiTHjEjleHOH7Tt6v6JmWJaR0F9S2avBzTRjBtWbiHMaNkRUH1JxZOQBUMXA3Qh2ldkExz47fHDUmPG1UIthkZ+ZHf77rh+/uuUHHz3narPDe4+sBqwx2tJUmlbEUWrE4JWmfjassYau6/BmxpiKDx1QMRSM6zEbFdHVuePDd8A8T3z+T3/M1ftP8cOWskwqVlt19O9c4TZbNrsrutVOqdy5Qqz4D57h1gOH62uOr79gefmaeDoS0wTGYq+uWD/eMTy+wvQDdZmZPv6MOieGX/qQ3bvvq/l1uiLfj/jB4zfbBiAV3TxYi8TKlE68+OgF8Xrkne+8x/biAjME3DAov6J3UDMYhzMBbwvWaSKeNMxKanmIbdA40XpWPLaP2FnZCoIeLkZUOWxRPgzWKsFPhEOc+Ye/8Xuklja48eBd5c1J1/qdETY2YDvlrboWchV8Y58adPQVhwruVUGexxP2YkNJgBFySx2UovyjvCwcbu+I48jm6VOcBIIPLEtpbFSY9nu6LhDWG9VF5YL4HpFCnUqLtLSkeSRsLtQL5k/zFkaMIY5H7q5fk+aZmhMurNltt/z4n/w27mJN1wXSuCeOJ7K1rOyKNM7ktHDY3+N9wDghlYK3FkPheDziO9+CmwylJtJp1qR3Z0gA1baWLzPHgnXC6VQIDmKEYyysp8zFZUdYwEuHrRFrIVfBUv/oKGq7xlj4h9//lF/97nv0fcAnR/EBa4CWfYs1D4lqJekJqra6as7bBSUXdd5RlVCpruNiMOse6QIG+PA7v8Tl6cj4/A1xuKVjpr+6pJaCGTx+PWhejbGsLrfED56S58TuF38JFwKbJ884fusZ44uX3P34J7j9Pf2777L99nfw6xW+6zHOQ8ncm0Dc37H74BdYbS4xVohxIVxd4J2uGkueyHHi5tNPefv5S9a7K9JSeH97waP3PmSzvaT6gPWCGQLWVSpRD1vrCEZUcIcWAEOlSG5jinJzkpgWc4n6jDQPEx1EnN5oaNtfrRK9Co0PU4Tq4Pd+9BM+/ewFlULnhaEX5gQ5FjZr9TctttD3vdZEUXuE0Pn2WdCA71JT+3xVjFgSCTdPOt1YEAc1W2p7XWJOpNNRA6Scw2+3pCXShw2lTsoaTkcgkpeTbuKMwQbPskzkZcbIoEpejKq0rf/T7cpujGEZZ8YxK4V5qWy2a463d/j1SiXnBsbDPeIgLhOxLJBhPs14Kqu+U51HrYjziiE0PYPUgnFOGYQ5qV+EURC0X3mur0cuOliWpCnyNVMQIjBmYZkL1gidgVKSZoUY1Gnsj1s92nf/6OUNP/7sJRfrLcGpBohcNQxJXX/1/2cdFxr3SYlPzuOHwDwlail06w3iVs2wBupYwEJ3sSOkgdX2kmm85fbFc64Pe578+i+B9dqxONcS3cC7QP/oijhGhs1WP5jOYr2l8z2u75hu79l++CHD9hLnWtxkC5XKH3zIeN3Tb69wLqi3a82a9SKJtJwQmRnv7/nkd37C25+85ru/BBfbx7z7nV9SToQxVKtxmCYYbKpkKVjntUCWiDvbM7bti6ltbSxQqp7+lQRVRXWN1UFp6XhF9xUUpOEdqtQhZ4o1HOcTv/kPfou4JBDhYm3xQXhzSAydGgi5IAQnagY9BGzWz5gNRv1tjNf84Nq8PFDpgKIsVR3TRbTjNEJxluP9K+I0YroON0/YpvlJy8JqtWGJypL1a90wFusoIuR4wtmO6j3LeIK4YDZbMGrxIN+Axg7/AhQQEWEZI7karHNsH28hZ+7u7hAjpCkyHfYEIKaMiJrj5nkhTROpRvr1gDNC2K6Iy8wCONeRKCxzIgw94+Ges9GuVUYYl1drXr3eU6VicsUFtY9LTdGaqZySMI0JP7hmaWjJYsh1UlZj/eMXkcOS+cff/5Rvf+sZzjt6r8QmI0b5ARSyoJ6o3lGLxRpdJRsj+M6zTJm4TKz8I1wXaKYiur5cUK3KekVdIr7vCGHNPN4S7w+U4KmSsd2a3C+qMBbwfYe40MKZBZxRmvUK6uOCX12wvXqG7bRjkpbalkpm2F5o1IBArlEB1phYDgdsPiJDTyWx//w1l3nF+7/+L7G6uKQLPX4YwKm+CF81DY+K9NBJh3UFUzMla8dBLk1Xo6CpqaKEqdTeNVFrQCV+qfeHiNH3GaBZB4po16GafEsm8b2ffMznn75CqhaL1WDZH1RouQkG5wXrLL4LmJLpbI/vPZ01VAzWQEwJW1TOT8txMd5hq+BCACq+KbJN1q3Q6fYVty/fMKw3bHaXeGdwLbYi1QTGU1LCh45jinjRTU8taGLhciR0A1SjDvvGtGJbvgEC8i9AAaFWToc77Q5IdCvPj77/fYZHF8xvbtm99w7z6aA3mKqrMVTG4xEXDDHOxJipxtF1A4c3bzXVTqxGDuTMavDsszpvTVOk2xm2mzXL3Z7gLeOS2Dqh1EI3GKaxKCYHTKkyL5F+7bHB0VVLzpHeGI1E/ANiHf6gS9os/pOX13z/o+ds12uMC9jBgdVuoLaZpDRClLXttGqSfWs93Q7SktSbxLW3WZr4rRxJMdOFQNhuqezoVltObyzTq5mym4n7L5jf3ON+/VcVjDUeG1aaOJdVSl9LaitkHnwqrFMfUigNU9BT3FrlWdScSGmm5IU4L7z54cfI4TVPf/kX9Ga4hvc+/CWNMfUenGk+qxVbkwLHrtH4RUV7IoW8jBrTUJSjkQXNb2k4SKVq0QWaGypIIXMOrVZmb5X2nhmDVIdYyM1P5TCe+Cf/4HeIi46Su17ovXCdKmtvcFLxxrIdeoZVr4FZORGCo1+tiEsGU0kpq9DQGdKcEe+Q0GGzHg9qcC1IzRQR7m5vuX37guV0YrVas9rtMN4TY2Sz2SLWYyhKcCyFfrNTrZJRy8ZlOqnZk+nxK2UUi3XNlEq7nq97/dwXkFoyx+MdqSbW261GWxrwpjI6px+qdjoYlSNScuTu/l4n2xwZb++5eucdwhC4v1XSTdd5Sm3h1NIRnFe+xX4kxcx6u+H65p5hO/D29R1dr/TnlYPZQCnKFpyKunMJTUHrMkiHc5HK8jWGGL2mXPiHv/MR337/GcEFnPeICxjJVNNUrG3vT6lnUSvGeSQXetsxL0JJzRnEar6MWE+MM2kZicsJ68+ApN6sfn/PtN8Tb/bM4ytOl5f0Ty6x3QrEkEslLgvUtq5NWVOS6peCM01Nyuo3aqyOdRVSztTjgVqUPHZ4/ZZ8PeKWnvHjiX5zwdP3fxkvyhatJVGlkaqsIXglyRWjnYIzjcWZUjtFNQ7TNTFiEUctsb3+bRRpUW1VlEBmiq5qa9XuTZm9TfgmBcEj6Cn+T7/3fV68eEMsqom6WluWlDXI3cLQe9YXG4yBPMcWhaG5PzllXPDMJSKl4r3DeaX4W+cwYimiIeYuBM2B8Jbx7sDtm1dMJ00LxGlesZjmd9MPxLxgyCxxIVHxfYcP+r1NUwG2ww8bQt+TSyI0ycY3UeLCNywgIvJ/BP736K/xT4F/B1gB/ynwHeAj4N+otd607//rwF9Cdwp/pdb6X/6sx6hFU9p8rzP54Xhgs+2pMbLaDOxvbhi2ASnaduZUEBeJJbNMM9vVwOH6lsfvPCElFYWd5rl5TTrG05Guc/jO0oeOt+mOjRNcha5zXF2t+fGnd2wGoauK2DsvzEc9WTUmUYVzjtxWq1YZm9CyXH76u3SGNP7ZJ6xiW++Ez2/2/Pb3P+Vqu1FDHm+//B6xFPQDV03Lai1Wpdxi1PouaLHECGJdc0qzlPWKEiNxPGCcA2sI3jNsN/SrgdX8mO3TD4jHI6dPrrn75BWsDDV4jseFp7/2Z/Cda+l4iQrkVKhGH6MkNf3RqpqoCPPxyM1v/wAbInlaqBM4er77i39e2ZJFl6vVGjUTipWShWIyzltcb8FZCkUZvsZgpGgv0bZiOWsXUVCMKKO5J0a0+0BE6fRFC04Vo+tORDc1zbdVzmZARnQkwvDF6zf849/8XU5Lwhvh6cbQB+EQC+vO6Nee7XCdJ00Tq9WKMU14Zyi2sqQJyQtmNTQSntFuSQyhG5jnkdCvqSlhnNPw7NPE3fUb9sc9Xhzb3QXDdkeShImJMAxUCpSZWirOdWC0AEkR5YUYXR1bCfTrNVUEsWcbAy3G36SGfO0CIiLvA38F+LVa6ygifxv4N4FfA/6bWuvfFJG/Bvw14K+KyK+1P/914FvAfy0if6YqLfAPvGqtpFQZ1pfcvX6J6zrim1tq3+E6w/31iWHrWUpSzn/SnBKpwBLJ644smdubW9abNav1ijdv9jx5X70np/lEmlbY0OPsyLAaSCUjIqxXA7FkrrY9+8PMcKFuYUUKY6l0BhbFAlU41qpBTOpDllLlpwU7/KFdiegoUmslV/jHP/yMX/7wKd9xgWoCtQnE1LDDttT7Qs1NK2PUxKeiJ3aMGrzdh5VuG0TwoUMuduS4EA93EBMybDTOsgv4fqDDUHY7Vtst8/7AMh9Zrg9Mr6852J/g39nphiMXihGkCmnJdF5NgrL6K+oNnhL3H33B/PE1zlu2Tx+zfvYY4zxOjN68NVFqJRVdu9ccNXjaOuzgNaXJeUytTZ+i6+mSk/I5TAWjbnG1arpfrdp1VGOapExvFkG+VNeep8yqVmNSVaavYIhmv5ymkb/79/8Rp8MRV8Fb2K6tan9iYRgCwzowbFaM44w4w5JmbNWDxInVXGSTcKeJ1WaHiBBjpO86FUr6QKbiTcVYy3g8ctgf2b95Qzkltu895uLJO4TtmttXL9ltHG7oKCmyHBdsrdQCvQ9KbXdW7RWkYCqsnlyRS9Kc4BwRP9D7HmP/ZIlkDhhEJKKdx3PgrwP/Wvvz/wj4b4G/CvxF4D+ptc7AT0Tkh8C/CvydP+wBaq24LjCdDuSaqXEhpRFfPPkUySlpschJPw1LUq/IkjU3g0qshds3L1ivPmC1uaTfrCg5Mh3VrCfmTB82WB8YOs84jXT9QN/3cLfn2x9s+e3fm5hzZRXql3oFdO9fAMngrWdOiVIjMaUWg/BTntQfUEEeVNWtM0kVvrg78Vs/+pRHFzuc6zSxLDjteMSS0PAl27w9yVWLHBUxGSsKrlFVIVtQApqjp7u6ZH57Q5wO6s9RK7UOeNdhQsCHgfBkYHX1SL0uUuTJaeRwc8Pdj14yH251vWgVEErHhfqdPWbjKXmhlky+m0n7hX57yYf/039Zndi9RySTTifS/QFSxHhLJpKzeq/g1PXNdV5t/5x/eN3UiTxTY9ucoa9XQa0a8wOW0QoCGuUpVQ2ARDSHR2ozT2qM1GKEigKwInrzZxK/+Vvf56OffK7ZtA52nRACjFHHnvWuZ7tZac5uBScORHkoQTxExT5EHBRI00kJX11PAjahY0qRgpByxdTC/d0dN6/fUmNis11x+fQRPoTm3F5Z7y6YDge8D2w2TzmNN5R5pGRhGU/UkKhjZPvkcQv+iuSoBDWxAeOdvnZFmblf9/raBaTW+rmI/J+BT4AR+K9qrf+ViLxTa/2ifc8XIvKs/cj7wN/9yl/xWfva77tE5C8Dfxng8cUa363Y3+/1QxonsilQI5IzF9sVks6S2URhYZ6y3t616Pqyziz7iVefveI7v/aY7/ziB3z20XO224Fh7RmPB4bNhm7l6fYwzuf2Wxg63aG/+zgwnyLe6wf7zEMyzUgoNo6G4Rwo9Ac7sp/rx++rI1WLiBfNv5lqYSrw48/f8MvffkMIAfFg7KqdqOcztZDRUGhj1TTZitre+b5rfhcRY5ShWWsBA241qBzg7obxdIedR8o0kFyPX2+UBxIC4pwi+t5inafb7bj41rfI40hMIymBlEohEmNlOd5TlkotFkKH/XBD2F3inRoklSUS9wdymilNTJdroqZZJUQu4K3DBYPrnNoytKoqqPVbrRbqoi9arjqWNHf7XCqmaXCy8GA/qPxT0wyHtctEhCxFuw7axqZWsLqt+fT5C/7BP/otckwt21vYrbySWgtsV55h6Ok2a0IIpOmG3jtSw22QNkoZhzWK7cSasHGhFo8LG7CKtMxzIvSBOM/cXF9TYsY4x/bqCjEdKc/YHFhvLgnDGhsC3bBm2d9hq8UNa0qKlJrxzpF8JpdInSMlTdBMi7zbgQi1JDVb/pPwAxGRK7Sr+C5wC/zfReTf+sN+5Kd87aeWvlrr3wL+FsAvffispmWm7zzT4Z48nzDeEBzsTwu9q6ScHzoR6zwpZc01pVBTRIqQCxwOJ+7HiUcXV3RBGE97fNhisCzzTBc6Vus1SywsWZPfVv3A7c0tl9vA5/uFeYGlaLtogc6o76XU5mxlBW/VlNegxWD5yrPUzcQ/+/9r/fJrTlTXp26WQq6FKS589OIFu90W5zylCv1glXpumm6jJETUpk6s9kgU9W/FWf3zWnT8KVVnYWMJa/0AT29uWY57iAu1j+Q0k+cVtmW12E6p7qDApbcBv/V0ZqeRFCidvFQoOar3R6nkoul1ZcmUeaaMR+bjnrhEao2ktJDypFk91WKCoQtWTYV7NSJSHVBROrrTDUKNkSxq/KPFRbdPJbcgLmnFQnRsE0WbQawKvM/LsZavQhVI+hDFKnX89uaOv/Pf/SbT/Qnv9TO0CYLrDSkVeh9YX3RcXO3ohgtElmb4rGOSqcKcIiUlBqfiPCngHVSTyakyBKsG195RmakUPvv0OWk5sXv0hDIveNdRKXg3ENZbpjevefLetzGd5/7NK6Z5Zn35mPF4A5LIy0wYVhhrSVGtKfKyIF2HqVmnPWtIy5GU458Ykex/Dfyk1vpabwT5fwD/S+CliLzXuo/3gFft+z8DPvzKz3+Ajjw/8yrGYKxQU8TYQIiZeDxRcsZ0HikVi6OmQvXq5ZlKwXaG03ikYunWgVQdN59/QZkj737rXZ5/9gVxyoynPf16jciGsN4wjDM1LkonprDdbZjjLdtdYH/UlLPNCsax4BXb026EjOBYGgCY6k/Xw5w9jc9fPReVSgPu6nlEKthmSnR7feCzz75g0zgW0TqMdDrPWxQorYBVqz5dVKoRsw9d85jIjeIt1Bw5R+eFfkAeV051YjwcyCVhnCeORz05rccPg2IrtnmQ2IYjmGa208QiNWUl21V0fbpo1koajyyHIzlOpBKZ40wtMznPIErP7waP7TV4yvQB4xymyQGEqoHbXiX3RTSbpZaswKdRsDoZVVJrc2Ealb39Lijg8c8Uj3rmfyj4WkX7yMPpxP/n7/0GX7x8jbWiJC0RdivTQrgK3TDQ9SuMeHxwvH31tr2X2nnUtso2RRPxSkwYqXgbyDiMdxBQ/K69YwnB+MBupf4mtXNkEr7v1JRpnug3OwwdXb8Bd0e/3uC9YZkd47hvQWFOhXIlUSg6uiUNpdIwraqO70l9WL7u9U0KyCfA/0JEVugI8xeAfwAcgX8b+Jvt3/95+/7/AviPReQ/QEHUXwH+/s96kFIKZTqxTDM5L1SjdOAcZ6V6d56UKkkyJWZkyZRiSK2VLaWw6nuctaSYuHv9hpube9b/8q/x7J2nHO72kAvj8QBVWK86+s2a6Toh3lHmhd22Zxx7ShZOU+LmkNhsLM4K86TAZW1bhOI83iRSLaSC6i7apUWmYSbnGQbtQM5yhCBCKhXrDXaR1knpvP7m5RvePLrA24C4ESMVG3pMLc0wR6jVUsVpPIOtD1oQ61a6DapZzYHENttFXQvbvidcXpHrG47XN1AMznqsWLz1xDE0tzajPOuWJ2PWyqmpMUKq1JzIRQlcKUfyaaaUpBm+MZLqTCzqBSIGbGc08Dv0mF5NgK13SKfr09raBRUggESh1EgpEaHo8xBHsZrcZ4BsrAr8VBGlOEjj0CjrU4FSQYltpUK1agxVirCkid/4R/+Ujz/6TLtMCzPCMBg6K+Q5UX2gWqFbbUg1cbq/p+aENw5jz8CYAAXfd2RR2nrfd8SSVNHcD2oWngunaSJ4y2k6MjhDNyjoncQQ54k4HukuHrHe7chVozUqls6v6C4tJY74bmC6v0NwpGXG956yZB3cxNOttuS0AA5KUZwKyzfZw3wTDOTvich/BvwGkIB/hI4dG+Bvi8hfQovMv96+/7fbpuZ32vf/uz9rA9MeiVoScZ40MW5W2zsz9AxBdRbWW/KU6ESICCTVFlCEfnVBTYlxnLHBcTgtZBP56Acf82v/o18nl4ScRvZ395rDcZzYrNb4YFgmBUyXU2R7teZ4GFkPjjeHyGnK9Naw3bRRopFyai6IFMZFA6m/SkStwPkTq5QhrSHnFyEY3Rpk2lKhKk291kI1hUjkxYsXrPoe7yyTGHw1hODAonGTFBXXWcHYrq0Z1BXc4NQ0qXHfXdXXUhWZhjBs22/lOF6/ZTzuMQ0UtE5zXgSL9WBMUKn7UYltpUCNuW0/CqSkQHKcKTkS40KcI4VIFvC9oxs2mC5gQ8B2HWZoOTHGQQM79UYsFLHg0C6iVuWWuLZVyc1n1FQ1R6Yowa3oi17PbNMq+sI2aoTKhRULyaWSjWEuM//kt36X3/ytH1LJeKvvWQequG0dznYdePqdb7MZBuIyExe1bOydo9ja9JZVNUtORxdB/ViMUWwn2EBaJv3eZu6cxpEuaNdXc4SUMGgsxXp7yWb3mGosSzphxhO+01D5mDSlL/gAqXGjUtH8nJTJy0Qta9I8EwaN03RujQ3+p3AJ/ujXN9rC1Fr/feDf/x98eUa7kZ/2/X8D+Bt/zAdhGQ8spwO+65njhO0swTkkT9RqSDUrC7Ed5dUqzbdf9WqrN8+M88IgHRjFLm6ub/n4Bz/mw+9+wHScWMaZ4/2eYR2wGLz3rFIhhkiZKpIym1XHYU6sV5nplMm1EIJhvQq4nBS4Oq9Ys5Kd0v/g6cjZ1bu2daI+SUQU/8jly3CqM8bStdWkoP6wt3d3DN2KtXM4YyCp5qM2YKxWjzGD5rm0ExqxWOeoZ/8Yj/4ei4MSqWXR7YR3dJdX4ITp/o55v+d4uqeOGVPU4csap12CDe13r8RmjqxanciyzJRcSWkhxrGBlIYaDKFf4YcOaV6fZtCtgLFqW6ACuUr1TU/zkM/Cg6GRdhtKoDNOFLAVQ8kJk9ID0O0p5KJdiBakTKViperWowVZFWuYc+S3fvBj/v5vfI8YE9uVwWZdp6+CjopLrqx6z7Onz1ivVtSYGHY7ltcv6UJQu0lTmJcRcQ5PoFA0MMwYQtdpXsywwnpLKRZI6vafwZ6HjBwhL2rAXwRnDd4q9Xz76D3u337B6e41q+2O6gLMo467ppJyoqeQo+bplDyS4wS1Yr0nLycWp+v1Yff0TwZE/ed11Vo1L8MGcJ71rmOJE8s042wgS6WmqC1Zithhi+8GjsfX1GWmYBjHGeetOmalhFRLyhM/+exzXl3f8mf/3HdxS6dtdiitSPR6UxvNgy9Tonee3RCIMfM2F3LWGz8vSTM4jCGlyniKyk796rzdLi0aZwLxl82jFT0VUz0n2ykAG6woSJtVDYypLIc9t8MG69WB2zqrlntFR76UE75l2Firkn+qktqwNIyl6gxeBVkqS0m62UIjJcN6rRGPoSOuBuK8EI8nYpqYlxNljtTqqGRMFoopLVdG1P0riZK7asRYD97ifK/rYRewqwHbr/Cd002ZtbDo4xfUgMeKVUtHoy5fzUuBYrUY1IT+rENT5VJCSsUZ2zY255GlNGuGL69UVUhXs2YYLxG+//Gn/H///u8yTYlewImhOuUUGW9IWVmuu91O7R+MEGtmvH6jObVNvevEMdMW/aJBX6aA7QVTCsPugu3FY2pNiAjO9NQ0E41+3n3X44KjJMFi2HQrvNPPb4jKLO5X/7/2/jXW1jXL74N+YzyX951zrrX23mefc6qrqx13G5lITj6Qi5ANCEUJlxAhwhdQkKKAZBQJISWQD+BWPiC+kQhFCBARFoRwi4MVIhJZWE4UgiIkO05HMXZ33B13u7qqq+tUnbNv6zLne3kugw/jWfucdMrdVaecqn2a/Uhbe6+51+VZc873ecf4j//lxOXNS+zq5KPjGKh0t0YMRjfnIj22aLVcqMs9EjOtdaR1N1oO4ce6Pt/9A6R3NASO+UDrjZQTteyk2a3gghp13wkhUefA8clTLvd3mO1Ap+6PClvYth3EWFdH8FvKXF7fc/z2d/hbfuFv4Xz3wP5QSMG4DJfsGDopKmsvmMH1IdB6Yt8bl9XNhFSd0BRiIvSdsncMdYbZF5aIR0I8rm6fA6iPju/C4Ex14SCQBc/gHYK2OXoI9mW5I55dTakCHIS5eRB3743aCgGPltT4GG0pb/UpjJzXkBTrEW0Z+k5v/v8hCHKYUFUXeu2VdLzG9oW9rPS6Y82o+zbyWKvnjnTHbDSGEd6UPU4yJWLyQ0NjJOUEORERB/GqM1pRlwRojG9ZvRJkPJeuc5ExTvUyo0N1qFq1oxppUqF0ZGAgHSXYcNeHkXTXqOZgYjXh13/zE/7Cv/PLnO9XZnUsCvE7/8ETQDAR5hw5Pr0hTQdK3bGgnNIVD683lsvG6XSglgXVQBWhrjvumG5EcRvMKTnXZl9Xatm9TZyP1H0jz5nrpx9w+uADPvvtbyG1cHz6jMvDHa9ffo/p5illX0inJ/RXn1K3hZQzqBDCRJyObPXeh0tmXsl1t2HcLveE6YAQoHX0MMOPMYGBr8IBApyePUcIPNy9ZlnOniOaj4h5mXb1NNNrcSWpwXJ3576cfgskBr8XuaGMsXejBaWcdyQIn70+Mx9e8uGH1yx3D2x1p7ZI64UQ3ASX5rySvVUOUXh6iiSpHGZFgvpbMzjrcS2V2ozI5yPcx87hizMZwQ+IwmO2rgN2OThl3o19ff/BhvmvKpoFaxvr+cwqgShKCkLN4W32a+vubk5yL1WG29bjtEbGHbi3juZADhmrwTe8G7UUrHr5FEOANA6VrGhL3i5Wo9RC7zs09xotAwPxMaZCdFtBTWl4uGYkRAc49zIqA0F69wjMOSHTRNTg2h31UayqYy022phm9taQB/OYxyINCwWpIN2l+SKPHaW/fmbN3di7iyNLb/z1Tz7l3/oLv8LL2wuTwhwcVMU6c3anMboL964+/JDD9TVlW5nmG3e1f7hnWTwLp9ZKGzYAtEaWSBma+Zwn8tUT0vHA+XyHZ1kqPfhNIYYEWTheXbmR97pzfTp6dfvsOQ+vXmD7Qi0703xkOh4pywMiR2IInjGchneJdaw2urh/r5hR2nhudAIaRqfWlf9wjfyjrXf+AFEVkkbu39yzPizE04EoAq1TB3287hf2h3taC9y+fsV6KbQxQO1iqAbaVig7lDLs9gTWrdIjHLeN7/72Z+xl52e//gH7ZeVyXti2ztXVRJ6UmALLuQydhHGcQEJiCgHPanYbxbJvrKWyd/OIh0eehzyW08NVj88fy4x2ReCgQopA9z2mNKYPST0QWYQpuCO99k7Zd7ZwcbZmSExVITRai47Wm4G5rN5EvSx3mHbwI4b5jgRM3D5RwEVYpdEMFCVKpOP09CSZrh2Ca2xaT1j3SEp9hITNR58qOi76QFQlCiPpTYbJcIQQeTQqkOAO5voWCPavNWmDIOd5vESjdXUgOBa3WOjVPU9stIbeJzIYQQOfccez2oWlVn75r3+Tv/xXvsnL2wsHhTkrGt0D95CcjFe2QhQhHyeubk70vXoLVaAUZ3PGKLRtp8sA2TBSSA6StkKe4HQ6cbp5ynp58OlHcz1LiIkYAls9k3IiHa+5vXtFng/e/qmSpom5PGN5uCVff0AILq7EjGaFpAlP9fOWy2rzyk68Im29k/uwEtBOrRM53CA/pqDunT9Aejfu7u/Zy850faLslXA8Yq2x3z5Q9wckDgFoKQ5aBkG7g0QMeXYzB8/MICdlq36YzEdPeitl41vf+j6tN37m449Ic6FcLrx+tXA4Hjk+ObJdVrT6nZBq5ODAmgBzjqgY67lyf3ET5PqF8XrjcWrrNcgjbJXFM1STwhz9ThuC/2+M7uIdu3JMkRwnQlCiOtgpGK0Wtl3R853L5tWDnHpznUbPDM8HJ1GZ6jCREZDg3JUxdu0YTBHTk4/+NBPqSq07rRSaeFq8SgVzQC+IOFktKFUrNiwBZWTK6qDQiwQIrmPx4KqRWqeKBq9CCEqUhCZvYTzKWrDgQLATngxru/+uMVCbDZf+6jGgY6oEnmXsRut9AMU4Xd4a277zl371W/z5f+/XUescE+O5c4/TOfr7pnf3UU1T5OmTa7ooh6sbnjxzbUlaA9v9HZfbN04umxRVPw4lRaRnUhWunlwzH04syy3bZSVNM9M4PB73FbIHQdV9I0oip0SeTyMUHubTNe18jzNKNzQGvx5I1La56zqKBjdVqnV1zo5Vl3aIOm29m6uEw+Tv5R9jvfMHiBnQdqYpwXxCo5dczaC2fZj9CGVdWC6FFv22b81HWFPOlM1HelEVDZ2tGWs3D+pO0UlI4qnK3/vkJdEaz55es6E8nCv79sCTp0dOT068eXFHqd1l5M1o5j/DpfLKi9uN+90zYnaFaG7MzBjVPQruGFOXq+jtSR6gaRA3qulmficcn5tESUHJOZNCcrcwdYZmt529CnJ+GFR1J1FVDfR5dus8iwPfd62MSPTnSUa534e1XvdWJwIxJlqN1HWjpepRDG2nUbG9eXDXWxqtMGGD2OmgpzcRDhy7h0lAdfh9jawZUxlB2459xJCGKNC8FFePRnh8jXrbsTHRMIo7rI9+H4VWnG9hrQ6RnpM/3A+kUlvh7mHj3/0rv84v/cq3Ees8OblxUEri7e6oDPdq9L1yPM587Q9+ncMhM89H8mFmvTywryvnyx13L1/SSnF/0t5IwWjVUwslKqf5mqfPv+YBaNuKdOUwn4jzEcmJ9fYFcZpJ6YRZQVslzTPn20qaDj7irZ2QJgoPHKZrmhgpRM7rhSAnJBh1r0gwJCfatg3QGa9MrGF1J87TOBQVkfRj+aHCV+AAQSDm2e9qZlRr7LWxXC60fef09Ip6d0tpxtYah/nAvm3stRPmiW7CvjnbsWJvgb4pRyKB+TAxpexJ98vOnBMvPrtjvRSePT+6h8PDwoM1pnlmupqodwtdhBTFMYPYsSAsS+Hl/cpucArKsXfO9VEBOiroMQ3JCkf1MW3Av1cYOa1iQjKvQDBICWLooM0PmDi8PeLIgBGX0O+2szycgWHea0aZEjHPpC/8fNEwWJruo8rgn6gJXToxBCwEauv0PpHS5Elxo1y2avRpHyPngAUHjQWD3jF87GzNhqix+SEQHinv5kDpoHBrCKg8MmNwtig+aVEJb5m2PkIKWHLWpjSPJ23WvOVqHpfZzXv+3pszVbuzenutvH59z//nl36NX//Nz4gKcxavGsw9Pda9epWGR45eHSIffHjDzdMbphDZ9wv3d24jsN7eclnObNtCCIkiQpRIa41WOyoubchJuVzuaL2hKFc3T5hvnhI0cT7fYl0JwfVH9XJHVXX5P0arG0Gf0KUjyVMA9+WOeP3UiZWoYy50Wt+gdkII7HUdpkT+mjTrSNuggIZEV6P1MpL2fh9jIIKDcwGh7Rt06HWlXs7M85G2r6z7QmuugxFww5d5Jigsl5W1NbI4ASqLkm4yaT66YCsKLz99Q7XG0w+OqHVe3m1897MHvrFd8TMf3aBT4P6yspWd0/HIvlfssmEKOY3xSavcLxtLcz+PoMp9628nK8jnL9MclQnjKjofIapwSF551M2Ik5Dw77GVzqSBKUZy8J5cYyBHRVIYtYLQd4NWWFa8ZQieo7vvK6nslDzGqYTBYG+0bSPmyTNVB4xrpphVLCUXlHXFYhz2Au4/0rqPC+3xDtfdtECGMQ8qWG3Usr4N4nLwVsG8qpDBZEU/57hod8zKbKTYM6jyAZ8WdMNCQq3irUzzEX7rmHXX4LSd3jpYdQJVbw6C7gufvHjNn/+lX+Xb37t1Q6BnM7UX5imRgnJ/u1JV3RLRhNMh8+HzE8fj5DeL4UI35cz5/g0PywN1370NMxAVmmcmMmcf806zH8T75cLheMPp5gmnp89AAut6Ty8rx2fPOMwnQp5gDbSy08vCNB1BfTSPPpIVPcA8xICrGBvWC2UdTNwoyMjEld7p5qbTasOHrVU/sINALwP0/n18gHjIcCb2jvTOHqA/FOaTm988vLxnXSqXWjx1XCHPmeVhQ4LQWidPStsqvUFrSt0qwRY2a6whUnvj5pDQ0nhzXlm3RhXhsxcbonc8vZoIIbPVHbnszFmwov6ihUCMhtbCdmkcgnEdhMtePxfRycjdxvvsJJDMtRV5BMAfAtQRSKRihOjXQFC/M0p0EJWRjqbBe6AoycGWyR2/Wt9ZNv8+ogHdEml9IORMjJOjCo+oLry1G0Q/v2vTR1BXCKCO5go++ejd3oJzZq6CNkZ107qb+2B0qU6qYsjmdQSDGyOaQsa0xpeaYMGQ7lwPUccSfGQkw+R4YFrmJlOlF1q5UOpOa4XSGrV2WqtI32jV91p64zu/9T1+6Vd+nRd3C4fryHUOHOdMNW8967o6WF29Jb6+nrl6PvP02TVPnz9HgpJC5sOf/znubm+py6eO4+zOlm2izB3EqatvU99cj9TJ+cCUs8epdkOrB6Qdjtfk44kQItvlnlpBMwRNWK6OD1n3uMo4keaTs5P31XlAyfVQHcHwiYtKpeGiwlY9A9is0btPq2JMnmHcC3U//1ij3Hf+ABERYki0stCssq4XLCSun9ywvn7Ffr7wcFnRlLk6HjhfHtjWnSpuI1dbp5ZODM7oE4EpPepE3G/zow+usNb4rc/u/c6XlaukbFvnk0/PSIcnh0zbI9taidqZc6APph+90poCjessvFm7C7owggwrvaEIPQgcxRUIWYUMSBDfUx+myDg+smGkR2A1CilNqDjF0j0tIlEFy8HtPjRCbfTeWdcVDXeEIKxxIuYDKc0+ksY9TMPhiKo4wUyGQcAgpvTaxkGj4w0mRHUBnUVnWJg1L6+6U8W7GTT/N7n7JMYaVoY3qejbw0fCwES6g3p+E+wewWh+2GjQ4d5uw+/lMUXFI0+tVFqpWC3UbaeXTu2Vve5IKVjtbKXwH3zzt/jlv/YtCp2U3PioJmUrjWX3iNS6d7p41XF9nDhdH3n+tRuO0YFdmTIRd+W/vf0utezU7qxP9zcZXJQ+TJsfVdEaiJqIGogpk5NPwzRE2r5wevaz1GBoiNT9lml2A+m6K613YvQpjIRE21dn6/bHyZIr0KsVbFuxUrDuFaKKumOh1DGJMaC4Q7uoh8dvD+zL8lNT4/5klhn18oCmSN3BJHG4ypxfvWA533Fedw7HKyQMpmmp1OoAZK9GLw5eRvGJRo/TGCv6hfH8yYmyFv7yt15RDI6pc32I9OZd/X0R3jwUnpwyIi7QWkonVON4NbMuhW3f3aK0u1T6o1n5ZDUOwVvzJ0k5FyOpMCcd41rlmJWIoZNr1CTAZG5VIGJUgxiMkAM5ZlKcSEFGaHQgYKSBV+ylEjXTzMd0re2US2CRM6qZKU/UNJNCpmvy3lfH9GNUA2YMkNMcve39bethguMQguMu3Z8/Z9NW/y/xA0cGcInhTmnRQ7WheY7NqKL8dXDzIJ+UiGMq5iCqREF6wGpjBPh45GhvrvAtTsQqe6FUF+jVUjw/qO7U0vkrv/5t/uJf/uu01kkK2t0z5c3rHWVDo3KaI9MpczyduLq+Ik8e2LRsTl2/ksbN6Ui4OvHd73+Hu7uVuhWfDE4zIU3UsmDBHfHjPBPGeyGExOF0xXSYma+viSFTe6NiTPmKfDqi5jaPYt6eVjNSTvR1R+eZ1gpBIiKR1h7oYoj6GBhrwyipjBG8A12tmb/5+g4Ddwpx3Hy00XtjX+8w8hf40D/6eucPEBeSBZpEqjXy4YRt9y7SEh8H0h1d35tRu7K3RhSh1oowiGRdmKfoQFd2pH++PrCfN37jt2+p4FWJCMtWORwjS2scpsBhCpyXwlVOLtHvxr43Ji1oAlb3h9BBvHo2KUtvLLv43QXjekxUksIhGTdRvaqInssK4mnxGGH01EkgoExpJqsHXMfsgVWq6nmwOiIXpkhvhUBATNmkU/qKreBxAhFNMyEdyCmj1hAVogaPDzB3MzNc0q5BnUyFDZKYjSseV7eOWEgbU5dHnoX1gWEMUZtKpA1SHH0cJI9SdwdO/Hv2MRFSALcUdNDXK6r26OBjbipV9wu1bNS6Y/tKLwut7D7W3jZEOt+/fc2//83vUEsnMTxCkoddxxTIUyQeJ24OR7oGOpUCIwyqkaaJGkF1pj3s1NdvOD/cU3ajLSvTdCAfTpRWmQ5XXM1Hnj69gaw8vHqJYMynA/MhIQGsN7at0KQSQiRME50OpfNw+9pdKqNg1Su8NB2J0wHbL0yHGTRT6+os59pAPKGxbQutub/qo3WB0L1NKRs9zeTRtoqYpzLaivbAdPX09zcG0nunizMfD6cT1IXLvnFedy53CzFFNAPbTi3GujXylIj7RjOY8pg2pOhgoXjPe/XkxMOy863v37G0ztUcOG8F0UDKUItxOEwcknKaM3VbaTkyX2XkvtKrsm8NjUaIRrl0KG6eZwIfH5XXYpx3G+p3xzLm4C2KZ0AFsqceOu0tKWs3YjDvhYdAZg7CPEemOHlgkziAiri5MiGSQqKxuVO7GDEJUiq276w8+Bv2cCBO7mSlGtAmOKFsgJ+DIzB44W9HrqbOG3A2ef9cydPaMPNxJarpKIXN6N1HuR7o5Y836YygEkyciOahTf4GlhhGZeJj5d4atVY/lKjQGq1Xyr5Qtgv7tlG3Qr0srGV1+4DiHhytdn7ze6/57MFzgA7qgKyIEbNymAKaM6qJFjJNIhLcnavHjGb3QDkcJsq28Ob+HvbK/b6ibSXNM4SJpQiHeR75xBGZJqyeCSGQg3A6nVAaGhN1L8TDAbqS88w0H9iXlX1ZWLYLN9fPMEmk68jl9pYpTpRlI482BikEMVSNsi8cTjeULRDzFWXZENtpfcctVDpGdSC14SN7GhIzeyv0rTDdPKeJK7i/7HrnDxAM9nLmdLrGysarzz7hsqyU2jgeM6V22t7YamdbNw6zk2i2Un3MqZ3QBIvBvT6jENOBu9cXvvvqHjOl7JU8w/XRnbzmKbKsjV4rT56exp0hYSETA25mWwq3DwuxwpwzQQtJ4JiEN6WTo3KMndacTRkHhTyqkEWYsoxkdCGph2T31piSE9tSd22HiREDELwEDeKcChVXoRLFDxoeU/dc3xFN8aahsNeNZbkjvk7k6eBpfo89uwnYQOVFgOYX9ONd6RGbQIcwzFsFp7L7/jC/u9OdLermzW18bzftQcwl7eMO6WSrz42oCQ62ynAMYwgDH4lcZo1eN0rdKcvCvq7s5wu1LGzbylZ8/Eo0Yjfulgd+47de8ulDw4BFhSkaaxWWXindiBU0FqRUJCQOUYkhE3Ol75H1fOG1DvMlFmfmPloGnq7YcAzrsm7M+cDWGm9uHzhNkZwn1IoDmL1RpdJMmKdEW1xt3JYNnSNlv3A4XHlY9vHAebml986+rf5+ufkave+U/cFfN3V3/VYLMXlWjwBl3xCMUiu9q4vxxGMldEzSBIVakDhDCi5D+P3MRFUN2PLAw+p5Levu6XOHFHi4v0Vl4rKt9AY5OwLem9FD9DJczJPSQiIEnwq8fvPAZd1pe+fVfeF0VDJuWpOjYl0I4u1Fiv5GnuaJ4+z+I2k+kC5O2d6rEaygEfZNyBG0ClszrqJHDlSDw2CXphSYBebk+Ad0YlaqudNWVqU1o6t//zRFUoqklAjJJwFBgo8NhzOqjNGpaiBkGdqUDuZs1do6dVu58IaQJmKKzhMBSur0ntHuhC3vojq9jWpkWDvaCLJqbaeVRnukTKv33aI69CljTNuh6jAvZoCnNrxKGL6sj9Zswojq7BDF4ZNesd7obYdu7j5eV0pZWLfFlcHrwradKc3vrBoCtS40Ot97ecd2ufDxQdnNK34dMaBBhdcPFY1wOs1ILax2QbtxTNmDoHL0UXkvZDUX8/VGmo9A5rI1NCpIRcVvOCFkogXuS+A4P2GWxm5Gjs7f0Bho1Qle+145PLumi7vq5+kAAsvywH5eiHlCJZIPJ/b1QkiR/bxyON54qN5gJjo75nFOm3w0W3YXRvb2Vj9h3SUcrVbP/E2uBdKRb/Rl1zt/gBjGw90dcT7QutKKIrax7m5v6LPvRIrKw7qSgILw7MkVpVVareQYidPMsjZenVeadF7fryx75zC7KbKK0EujqDEnt0D84GqC1plyIh+yl/W4B0WeA8ckLJuw7Z10VGrzaYILtQwJwvUsrHt3gRb4yDcohzkw9+4zhSlTl52YnOvg6t9GCIFDnoiaUAIBn06EoETDDw0ZaH9wVatpIEuitG34okxM2thtYV8fOL/28G0ZBwhy8pGPucbkcez6No6iVepWsFYx9VGxU8ZHsFT3CkiCjIQ0x0sCQ6I/2iCXhLqZkbUBtobuQGzzEtqiv5l76+4i3ve3hkS97pSysW4XLpcH9u3Cvi1YM8LhCtHqnqt947wsfPb9z7iKxgE/5DYAE0oX3qyN3UB7xWThOHsLGLSRaM7YbQVh5Ck3AzUszhQLqCZKF8ra2dedae4c5gPnZUdTZD5OvNmEOSSezTPGwmQOfC7LCq0xH2fWdUHT5+JGgHJZmbIb/fSRVLcud+jqbe50dUPvRj6cUPPAq2m6Yskz5bIgY4Rcjc8zgkOiYwQNgCJp8iFCc7PpH2e98weI8xHcOT0frsiHxPqweEuhwr4uzIeZ+/OKpsRpylxFpW8L61qJMRDyzN3DzrlUliq8evHApXaSCDFGd24KHo0wH2Y+/OCKKcF6ORPIzCn7izdPzArbshJSIqfIUgsPa+fGg8RYK0QxDsntCFXgagrEyQ8AVWOeEnGoSTWro+4qrrzVR7GdOPN1TsTsLUoYbw4dMQVqg8eBOkNTOl0V6UpME602jEaQRm6BvRtlO/Pm9qUb7A6hVU5u+SimPtI1Z5O2UsYYtWO1utfI0Jw0mmMgJpj4cyfRJyiKEOKM9kgPibepLNaROtqjmPzfYQj+BFf/Uqm1UTZ3fLfeac09asu2sK4XtssD67JDjOTj7CzT1mk4iezV6zPn+wvHwWDdu/snTdGjGq5nWA3oyhyVnDoSjCl6DIhJI6lXHxWhSKAzIUzUPrlxkznnpTdY6Sx95WoOlNvOUwlcPX1OLyu3533gHTMxQWVjr5t7tqiwb5XLwwPH6yfsZYfWuP7465RafJytxnp+4Hg6cnr+dYiBaF5FlX0hxomUMylnVsSzX/ZCsQZW0HwDIRLw1p3piCfbBZdj/Fj1x1fgAPG7dqQVpewL9MC+FeJh8jf9fKT0zs3VE0JoRGuU3tnpnK4P9KZ89urM/VpJMfPyxR2vLo0chauDcsjK3jpTCByOkZ/56AoNwr7t9K6cjkPAlg9MeWbfzz6BN/U376XQOyybT3vq6odHinh5mJSggSlHMCMn9wlJxCFxx0vjKVL2SkxD5HeYOB4ihxjIweX2qoqk5LZ/wcVwwiPXyg+krm4skzQgEl1QpQFCIpqra9f719xKcgCzNtp0cn2NdIJkHrsLa9VjKHsfuh/XmTRzFqr1MXUJ3qZJcIp80Ih1QdX5OO6ODogSug3G6g4IVMFU3TC4NnrotG2jlp1uO1ahl5W1rGzrwv35TCmVOB9IU3YSVd+ovY3XofHJq3saSpgCmHAAdjPqALmzuqo5IZgOLk/ZXQGskWAe5dIlQox0y3SNdNSNiEU4GEhSCIGtdEor7LURpLO1O9a18tGHTwgxsZnyZoWreKQTCLExHQ5oVM6v3jAfrpwioEo6XbOtbkcUIpwfbhE1rj/4GUKaqXVHUuSy3GK1Mk1HSt1cO6XGsiyUuvo+O2jyKh2JSDyhOWJl85GxRoZn5pe+Pt/5AwRcCxNSpJRK2Qo3T57Sonqvh3KILiBz2Xqn75WgidaEFy8vLOZg5d3tmd5c5PTkJvJsnih74fn1kZurzPGQoXT2Zry53ThdH5gOM6rKnCNt3wZlGFJM7P1hWOd5Hx+j4wHH6JWGjw0DOSgxCDFHrHW20gmHSBYwCQTtJHHORM6RNAyAojroGmJ6e9cQEwigKeBwpQzNVHcQUSoaovMt6IgFj5kMitDQ3TNrLncv3am9dvK8kUYVorIOE5qhkeiN/pgctzeadHqpdKBaAxNnXI43oQbQEAnbNjxfxbloeFgT1giasRERYb0PEVyBILQxIejSaa3Ri7cvl33hvG2U7m5cKfv4udU+IiQqrXVeX3a++7ByIXAw2GvjGCFHIeRI7+bPdYc4xsW7dawaDwuYuhahDyJY6GPM3KBZZw7RoZvgWp+oiZAH8W93M6qXb87cPay8ub/wcz/zdY5PjpxLo14aV6en5PkamUFSY73c8exn/hC1Qj4cCSEPEl1mPb8khEx++iGEwPLwijjPbNsGtQ3hoVdfMXroVNk3p++XnaSJ3o0QwgC6zUf9GhBJmHlO0I/haPjuHyBmXtbX6iL46TSjBDerDRNl3by0jx7nuO8e4mN159XdhV2BYtw+bLy6d0XpzSlylQIa4OOPnnB1OtLrypu7Czc3V2xr4emzJzy5npkOJ4J1sMK6bISUMTqtLGzLjopwdQgEdSvAaXLCmkvAA1NKpOA6iuDIJylP4y6ohBgoq+sVDjmRZrdMBCPFxBQnphBJElGUIErSSOARCBUPMMLxIhN9ezfrVtGstBKRvXg4lFZCb1RbeXh4hZhxdbyiTYUQM6q+V2nt7UXj5uIOnPY2LCZ1GNWIY0L9UYk7eB3BAimEQVzyx51nFhC7IEG8VWuANLeDFqBWN3q2Qqte/eylcKkbpoHpMPkUaRirSN+gbUg39tr57psL95uxW0IFlm5sS8Plfj4dQ41gSpBOpXO7eslVFbKqc9ayVyqlK/ROTK7YLcHbUul+V28mJPUWjuOB2jvdGjvKpcC3Pn3JN7Tz4QcfYyLcrwsnfUpqyilXwpTZ2obUTrq6Ik4zEhL7vrAtK88++oB8uqJLpfROpPnBr5GUjoNhOrAkBo0foFVS9PbRdERXKI51xTCEignrP4Sv+e+y3vkDxJ2djNYhzjOHw5F6HhevKvOcXKDVjVYqbW/c3S98dvvApRildF7dV14tbrw8R+VrH8w8vTkwTRMHDZwvF/ay8fyDD7DeOc7C9dXkgT6lIEHYilsrhqhYKyyXBRiepVOnNqEZxByIQSnF6epBPHhbUEQCGn1MXHcj5EQGbLQjKSQEYe+FIMrVPBEjhOSOXjrc36V2JHv5LOrWgfQ+5P0CuLWh2/nLqEzcHyVl9wmx5qLEh/Nrmu1M+06Mk2eKBKfPU4ZIDr/Lm9sDU/bde2eRMYoVWhwToe6IP7pThKG9KUOwB2Ye0CCPk4TunJDG4KLguEJtK7vttK4ecJ2ErMkxreAO7K3stOKS/W7C3Xnjt1/cUbrRxbjvHY3K/VbA4JSEWjzsqrTK1h6nV16RrMW1ODkKuUHnQDIfs9M6KbvvbFDxqE3zMPHWOw0HmLe9IAiH65lO4G7Z2X/zE+5evubm+Qdcn24I8UTI14R+hR4/Zt8WjqcjIU+cbj6mWaXuO4fjE/J0IMbMtu9MhxNmm8eX6oSpj6gxZd8WynbGWerFf69pRqOi6eBZQdNE75Uo0SvfEOj2aHP15dY7f4AAhNOJU1DaXnh49YZpmri5vmLfF3o3NAnrw4X788qLV2dePGzcLYXbrdMKbHvjahKePZ35Az/7hOdPb5x40wqXzUewH3/wMdtlIcTIFAKUShNhnibKtmFdOBxmet2c3GSNw+nA9rDSEffhqoaaTxE8yMkvkhACKY0gIZSclPBWQt9Jk6tk676T48QeEin6GHpO01BPOv6hGtwXVMV7WHHA06MTXdDmzDQhSmBvzceqeSKJUPeKDXFiL53ads53lTXvxJRJeAJdVt+7DPFcbTgTtFfq4JCImMvCm8LmNn4+UVaMSlF14FgMdsOsQhMkeMvggySla/NYyj58S5v5XTwIhExQI0se0yY3KJVhp1itIbWz743v3124lJ0sSguRtTe3JoiNvRS0wVUIpOAVRd0r92undBsOcO7Gdr91OHee3nQ+uD4xTZkQjCTmjmMINvxZeg8+bUKoVOZp3ECq0Gql950lBr57v3LfP+Vn98Lx6oZWJ86XBtNzyt233W1NPavGeqfXndOTp4QUfdyKkKcTJkcUYSsropFaN9reKduOMNHrg+tjakOC41ExzR5CXjqaHnEqx+bE3DLyy653/gAREWqpbJeNdV05XV0zx8Tl7jVb2dGQaKVyf9l58eqez243bjdnRZ4muCuN508mfu4bz/nww6NXHPcr+76xtcblUvn6x888hsAq63njME8uahI3aaldePbsGb2eWUvjvCxO8upGjJ4pVveGSXe3MLxqiNlP+TRncnKnrinPNB0pYckluFm9AiF5hZFUOEyZlDJ5ysQ4XnDrLtwy0OY/wx59uwYpTVTdHCiAmOtuOt1F5iGiOfnFaxULEaXSWmFb76k1UuyCGEwhesC1BOcQ7BV6dS6IuveH4aCsPeIw4v30o6OaGW/9QRTBeoEuiPqRK6pgkW5t2O6Nx0SwnOgG0SoaJgdmg7cXGJQ2QNZeaK3zsG587+WZsg+KvCoaJ3o3b2mls3S4tMZRPKbh6Ry4OQSawLa6QZImGZWVMEdnCs9pqKNDHC1jpIn4JE1h7wpxjNjNsSGjudBRE7s11JTL1nhxt6Cf/BY/owG9vkEsUeWKffGpy77vlLJSloWrq2fklCllxyTQt5Xj9XPidCLuC+v6xiMrm0/wNE9YaYToZIYQPLun1wXTyH45M12dqDRSq5gVguYf6/p85w8Q68ZyvjBNmXg8IX1j3ypIIsRA64U3L+757MUtn7w+szXlcJUJQVn3xt/6h57zja89R3rh7v7M62UdzmRCVOXDj59yd3uL1UKMiXzwGMi97hxTxsS4/uCanASJE23duT6euDxULBildZZLZa9GjkrX6HfwoB5PEHxUnPNEzBnrBeuVMAWsd3JO9NJJeRpArB8GeRLyIRLzI4ksod3Rv5iPY4xYkTA5OCouve843wAEiR6xqc2TlDquYwkqdAv0sjk2EQWpnVY3qjSkG+vaCGMkawTEGgRorbviduTbtOaajGY+AtU4JkPOBqMP02TFfBzcBay4c9ZID4SKEbCQHmUwaIOoeeiFIpozopEoRq2NVgrSG4FAkcKLh41P7y5Uc6lAM/9d17YPCrsf7F07SzXuzoVDEA4R5km4mpXaoZm4PL/DXhqlLkiH+frauULmuE7E3dx3hNI60QqGkwDFHM9paoN85+Bz7geaRF7crZj+Nl+3ncPVc1p+xu35exzf3PEkX2Nu8ErZVsgJ7Y2+nqF0akguNiQQSHSZsX4BBI0e0lXL/jYTSBHKXjhenSgmrrOK2V+TUZ38vq5ADON4mogGpXdqFUprrMvOZTnz4sUtr9eNly8qkmc++uhAmoXr4w2nqwO2b6y399w9XLxiSU4t7zuEFLncvaFtlZwikpTWd4wj+TiT5nmApDORzuW8o7GSJuXQMi9fPXBeO7U4w3QKik5eaWgIdAJpCszHA0HdH9Q640AI1NXbhh4bIkYWJUR3LJ9SYtI4/EGz085jIoSEPrIO8VgLkRFRJWGESDsGYIMGDgEzn/TsMmjlyTOFKRUxN1YyunNH1LAk1NJp60ZpFW3d26UhlanW/U5tHSUM4hzIMkBTG0n3OMYhpjjUGmjWiQIel2duZziMhbQWNEdizISc3rqMO7ZrtFZprQ63Mc+duawrv/3qnr11D9gypTlF160bKagotVfq7hOkjnC7G/dLRR+G43wU0sjT7SLUweR8WAofmXF8cgOAFqGLsqiHqIcQfFqE+7FG9T13B5DcBJyAWGdrjaV2OG+sn7zg+QeFZx98CNMTvvfdT6jVmA5OBFvPtzQK0hrbcuc+v1aZQ0Yk0teNPF/RgNYb83RgPR5ZX5w5Ta7rQRO0OvAOpxakmNg2f6FsmDN92fXOHyBBlaTO8mylcr44pf3+9T2vLxfeXAr5dOLrfzCQFE5jjNiXMy/v31BrZd+MKnAMQlDXCqSQ2Ledbd1BAzn5xXe6OnKcD1ydTqhGDlPikCfKduYwz4hsbPvO7auVh6USCExTHNGE6q2LKDkmLGV/vBTylH2MuBvWd46HzKVGUhBad7l8ytEjGnv39DcRUkjk4P1qCOHzwwL3kPCUyoBodv0JzoY1Kc5CxBm2Yj6OFfHkPunO21BzUJXGqCocQxFz2bscJtTCkMo/UtiHz0d3xbNKcXi1efkv7mWDjdmHdnMZMoZo9XlIilivaIUuglklRUPS5L9XUGJKpDChIWEiDlbWRi0FtHlrZcLrS+G7rx/oPi6i4h4iUaC4RwEhCnsbpLDuB2EHUhCKuPSAam4yjfHF2USk01898JzAdLx2UFzcsa11G1wK/Pltwtqd/Zyim0lv1aX24GbXEhJ77ei68dmre2I8cnXI3O+N8u1v8uTpTJyvqPLAqRby4UhrjTA/QY/Xrhequ7ux1UprbhJkGNN84r5/j3g4+FRNQDTSupuAmxWsbU6ilDAcyb789fnOHyBmxrI11n3j/tUb3rw+83De0CmyrMbTm2uePb1GQiVpdqGROLW6WUdbpTfjsi+Uc2XZd07HGVDMCn3KiAnHQ2ZKk1vvXz8hT8o0zxyH9Dtw4O71C8rWePPyjh1PTetNiM0t52IKZAIpZR+xhgDWyWnyCwJ8pEZECUyTQfPwItSnJWqGpEhImZgSOQTX8cSIRnF8Ifpj2CBlBb8AJWYsKPTq36cNjYSYj4Yf6euD26E6rvScB8O0QoUgSg/jbq4+ku3aSGlEWZoRzAlnuZtnrlCQvmNNwVyOrkNC3qogUh3nkQ7aqc1cwo9/vkZFpuARlxKd6s6j+k6hu66otUK1dehkOtu+8/27hVbEpzNmNIQ0QqNElNjF9x8S3QoVG21IoJTqvjHj7OyPgmK80jLzMLD1UlnqGz76SLg6HBwDq25/kOdIwRm2YYyxa/cJSWyuc2plR6sf1jE7iS9yoNQzr+IdfPiUmm/4zqefsDS4vukco1eNGiam6w/8eaiN5e4lvTViSmz7xfk+IVF7Q/LBW5eYx3vKeURYA4mk5FPEmA7EnKj7j3F68BU4QFozXry+5+7NLeu+s6yFfJo5zIEPv/aUp9dXnA4T02EipolSKvu+cH6443J3Yb1sbNvOXhtodKxh8zT0vRfm45EPTgennD97yvOPPmCeDxzmRJoE2StvXrzkcn6gtMrt643SAnVfsDK8Kkf4VJZA1JFrEoK3FxpAqxslhwmz6PoVzRyfHNjfLK6yTclzWmsdeSmBmCMxeNh0iAM9VCFoHMbIg7puEcTl9Wj3cbENRx9x5avG7DEXNsyH8V5d1cenYYx7K35nV4KPhY0BCGaaQcAQ7aTiQdMN/93EAk2z37uHs7v24FMSjYQGpo+X5SM7NfiBNxzbTbLvXXUEUg9TYAZtvOxY232MiUcuPFx2vvm9l+ytMEt2T9Pu051dXPDWah2HYCcPO8VmDavmzvDirZ7zUn7nBTWUzsC6NV68uEU+FA5HD+SmCWGKBJRmdVQkwxlhqyAuUqx0lt5oFeiVvWzUbUez+udKIUZlDROfno2iCbtS7LxS2mccyjVYpZGQHEkp01QgKnW7kKfJR7LiVgHhcIVpoCwLKSRKMzT7QWL46P94fIbm7fe3I9ledl5971Oaeln/s994zvOPnnBzOpLm2cE6hNIrVivb5Z7lvLCVldLcwd00cn19hEGuKgjTfGI6HcinA0+ur5jniePxmkOO5DlBr9y/esmbF69oQ1r+5s2Z+zdnbt+cXdOSA0H9VNegTNK9+khOE9YkBDohObDok5iOaqI2mOZAn6Ln2op5nGIKSExEiYQYfXIysmAlpsEnGYlrOmED8dPsxbeYGx71IfuX3S8095EQavdwBxlEUwsu33cgTd1jsxu9b1hzJutjUrWKkIetoMWKdvEU+OahkSoJhndtp2HN7QIiuCtZazRRQujOog0jWiK43FxVCeaTpDAmSm7E7DnEpe2eE0PAaqfUxqf3K8vuJb1kj3uI3WjNQdSouCWCCJt2rAdi9zYMgVXt86AvYDhOj7LeeMQH/Ogzlq3w6uUbnptBzJgaYV3IaXJOCA7sNjrR/BDrbYDKOqI2e6M0o1gj9UypldYrc0606o56D8vG0q75+vPnJHH7RayTQyV2Hc5zxclsqjQCqjZ0WhPT1RM0TizhlrYu5JDQlF25HPwA72Ulx4T8GNEO7/wBIhq4evqEp197xmnOHE9HF4+WSll2tn2jt+YJYbVSupu3HKNyyDP1WBBTat3Ze6MWY3p2Yj7MTDETDxOn05WXddFzYNvWeLh7Q1k2Qr5iuX/gO9/6hOVho+yNlJXjMZNGr55TQgcvIEZ9SziTYOQxLapWUQ1IctasGsQ4MV0F7OKh0h6u5NYDMQg5TkMyriP6YIjdusdcQsEkjulLR0bYUwUHELs4NsLm41OGqQ7iHqPeILtva3BzAb+DGlimW/WkM7y12oEw+BJIxEKndUM0EcwBx6aRLtWrst4wcxlybc0PxMe9EfzjEfwViEgfmbrR0OCREe6j6lR3EXEqvLiqtu3G918+eAuUAlvt5EMkSKeIOALTjRgj2D6qw0AVvM1qdUSGKk26t2KPhRuPdYcftmbGYwLCeS3E23uuro70ENm7EYOrijvuGBcaWIBl352IBm8rRYa2qFj1Mbn6+FZRdlVUO0utvHh9T5QZ+dqHPD2dmLMRQ2OeZ3SaXIjYPBmvlQ3JkfPDG57dPCVlH+Gm7MzWNB1Ih4Pn5YwgsH27J8q1ExG/5HrnD5A8Jf4T/8mfh+7281oKBaEuZ9bLyrbvbKWTZi/TNcywu/S7bAu9+QRgLTutGjkrCaOvG/2Yx8gTDscTwRrnV993vwtVzpeFT771GS9e3bKXwiElntzMA9x2k9wgwjQntIkzS3NGw7hjqwOaIfqsXaQiPbnrelCsCPNxYq8GdUQYSII4THlVQZKX86ZEGZ4AoyLRx5FImrC+v+VlqLp7mIkrYKMpjUHnFqU/skJbGWK2YdCLIlZp3ZmbMWQ6ldqLBxupe3uoc7lHBqyNyYeDpogQJGID1+jNh7hxEJZCeLRHBAhvqfME93l13OhR4CVU8zs4uLu4qlCrGw29uWz8pb/2Wxyur5nnTF0L2iKYEsUNmisNMyVaIERoYj4ibsPJfHjnhq7UZLTi6mA33/GztNswkzZ7qxs5bzsWIKQEfSKFgFqgmFdC2gO1NxKJ1puPpmguDbCh5m0VKR7FYN1xm0Oc2LaNZo3LWvn+q1eQBAkz9vypm2GfTsTYRutVUY3UZXGj6dbIxytimti2FSuVw/U1qEdhSgikmJE0UcrihMcfg87+zh8gQVwWH/LkpLJtZdsubOtCNZiOB46q7ol6WVnWnb1UlocFGDEE5n3qfLzi6ubAPM/kw5F8mgi9udpzW4nSab3ycL/xve9+xsuXtx7Uo3A6TkwqhJFeluaJOeW3e1MVwpTdRXvfXXafFMypzzEdkd6GJkEdwNoacXKiU5gz1iohJnoI5Bi9YlFDkpPFVPzuGZr7angO43Apk+Cxk0Fo3R3JLSSCRjfqEUWkY+Y+qKX7NCTEMZKFEYOng2/irQoBH9MGpbUKspN6wHpzsZkpre3uI6LBWyjnqbvQjpGXK0ofRCtnsFaU8DZm002dnQQXNA3lik82eu8De4G9Vmrv7H3n+7e3fHZ74eOQOJ0OtNyoQErRKyzagFccHT2ot7pFox/malATJXqSnZqi2eUPbyNjv1Dd6xg1o0JpxnnZmax7i7FDnjKtNfZB1AsWCFGovaPaSRIdUAViyt7SETCHSlhtd8wL90Pey07vxnw+kqIL6VrN1P7As6dX5Cm45EAT8ZS4XB584qWRXjvbw9mrHVGmw9HV3BKHL4i5x+rja/8l1zt/gIgI8zR74PW60sWYp5OrYbdC2Sr7ulJK5+FuYaubG+ukSNk7e2l87Weec3pyzWlKpOgl5HL/ivXV6ij9YSbGA3cPZ773m9/n5Zszkh6Zn67E9WwfZZ4zeY5uqBujv7mPk3uTto5aI6aRtRI9vDpEcU/WFt0lyobpTgoEAjE9ujJEJAlJEhrT8FINb1mnXd1kmdY9QyXgk5bgLYF4I4NqAtmpVqlOSnEsQTuKUerqjmBRaF2Q5geddaBXrLYRuzAumBjIMVD35lZ5j1VO74g0p0tLoCkjh5eRwevjU2+DjPg42hVBTfGYtOEKPiYmbp0YvGXg0dKwYoIrdbuT02rvSHdD6WVd6O2GnLIbkeNK6Mfjyyy4higYiUDvxSnoRGLwzORmgTDAWo14ezcCjeXRs3W0PsPFkd6MVjq7bgRRiM6o7fhh3QyC+XOirVMjHumggSSdFgI5ZTq7p1YgbNtOC465mQp3lzNXDwvt2ri/3IPe0Lphcub6KjLngvVCjDNIIITsU5fxHB0P1xxPTzwWs62kNA3cyYmMNhjMX3a98wdIb5V1W5hOJ/L1tRvrlpViwJSw/cL99sD9w5l993LXuqG588GzAzlH7wjW16yXRk3CumyUtSEpklPi8uaBl68fOC+NVo0pCzEqWZz6HaKSNBCmSM6ZGCMhCHFKRCI9KaEqXevId+1ufhyjg4qI4xExuJjMqqs3ETTNnObM8uYeoxJDgD76aHXtS0izZ8EK46IOnqowqN/21qQ4IK0PL4idkCK1VbR5lrCJS7oFn3LQCoSIWKf1RjKhaEBypgtIq56bO8BEHSI27YaYp797JxIGAOmKXKVi6m8taSPyMvSRM+MVyKMBs6kNZzT/PAV6LwhKUyeoTepHY2t9eL4qtXU+/OCap6eJN+eVbd24ur52yz71kXnV7gpmBarRKa6KlkcjaSgGEQ/5rq36xxHo/RGVckzJZEynvMMKwwDKurHtlag7U03svYPsZHV3ttiNvXea+Ag6hoR2ZXOEGaUSQ/Tvr8510RyJ4cC2b2gOvHjzhic3T5lP19R9J54yD5fd7REkMOlGayvbdoemBNNEOF4hr95wfPohejgOnClBcuBa8JuGiP4YNLIf4gARkX8O+K8Cn5rZ3z4e+wD4vwE/D/wm8N80s9fj/34R+OP4+f2PmdmfG4//XcA/DxyA/yfwj9sP4Sffe6dcHqjLwnLZWZeNlLLHNlBAXIz2/HiD9sB5q0TraPTkeGhslzPdvLdd7neWgYvYWnmzPFB2sOheHMRGzpEpRqZ4IAYIUwbtA/NQYs6E5NWCZ3EoKZm//UUIcXyeegB20EAt3j+nPDlnA2eWlq3z7A9+zPqwAtXHvCn63U4DxORtj/jdCzNUmpf/Cob6RTiYl4gfLK7UVWJXTCtWih8iCvqY9xKi06SdmukRA+qqYqvjgGheHZXuZjlxgJ5mMghngVINtTL8PoYmx6qzQHVgCgj6aN6jClYdJ3nkh2A026F722ppJhBJYq46rdWJejFQq7e1N1eJbzy/5ruvF9Zl43B9ct+U3klJgYTV4gZBygi81sENgWbGhFKGY9ojN8hoVPNp0SOXhNE2mrn6yD/bnyt6Z9s2F+OlgIlRTJmHZYHhCmNTQUIlh0BTQboibdg4BkgqdIGEB4/v+ijMW/nOp9/jdHjCMc/oQbCUuWwVBeKVIOy0so52OrjvR4D5+grN2V8T8rA5dEKipgA/JhP1h4Ff/3ng7/8dj/0J4N8wsz8M/BvjY0TkjwD/EPC3ja/534hIGF/zzwL/KPCHx5/f+T1/8AZDoHbl9n7hsvkd4u7+gZevX/P6xWtu35yHRNkFT6fZLeqoK215oJwvTuxp7l/ZJDPla8SU1pQQM4dTIiFka1wfZp6cTlyfjhyvDlw9f8L1zYmr0xWnw5HjkxPH05VXIhKJqm5SHCMpzaSYSOmAxAwxu2IW8XZFPUg6Tm7wLGqEkGjdODz/wDNN1bGEEDI62lPBDXDf8shVaL3RTLEQXELfjN6aYz6iSJwG4BnQlIlp8gu/7N6+VI+EMgFS9sMxBrcfDAO4zQFNHvqk3WXzMs586Z65gzTC0OD03sGaczmbK0p722m1Dkf2wdjsPk4VCRjyNi7TumM5fmimIfPfaXWl1OIeJ01YLneoVCaJ/OzH1ySFy7ogtXm8aTdPjeuNYJHQBTUh6OQjYnNKQA6Z9Jbdq2+l/arBXeiC410emuWXWRQ3SNJxsftzAqUbtRak2ZiGVTptGCA8XmiGdtcPOZMFEAimiHpV2fBEOtXANM0cpkw+TtydL7x8/YLLtvBwudCbUYCHtbK0I727zsWsEdSfozy8RVQUTLGQUT2ABVeQ24/nBQI/RAViZv+WiPz873j4HwT+nvHv/yPw/wb+x+Pxf9HMNuCbIvLrwH9aRH4TuDGzPw8gIv8n4L8O/Nnf6+e3Zry6dXPd7eHM+bwxz5knVwem0+Sqy+ShRP5E7W5ELROS4TDNbK3Qtp0YIn3r1L0yhYRKpe5Oz55mJccj8/FIDgdSTsQUiMfJ8YzmY1gbJTCDH+G08e6BTsMeLsU0HMrFEfTmOIFZQ6yimpA0RGnauX/5ipuPPmR5cwc8KlWDu4iZgxMujlJ63bzcT2k4m5cRGBd8DDuMYx7B48e0MlHvtwvO2xDzUW4X//4mTl13T486KrY+ylxc3YaABczKqEJGbqs1PwzMfT10tG19RCKIRarUIbBjkJnGXVzMD7ms7p8a3F0+qtLGeNHMqyUzxqjV0NCxEPja0xvmrJwvhbIb11eZvewkAlk6TUBjIJVOUx9Jiybfu3aKBoJFWnNuint8eIXaxLNkgzojtlVn3fKWYPf5wWJmLMVfW9Xu1QoMb5SIhR3tTnLrEee5iNP7mziFHgsEBand+Tki9A5TnCmx8e3PfpvpOCEhEmMkzZlmndJmDqcZCfcEGWZM28rh6tlQOnc8qjyNQDCPhnD7gvG6fsn1ZTGQr5nZJ/7i2ici8vF4/BvAX/jC531nPFbGv3/n4z9wicg/ilcrnLLy3b/+LVIWnh4yN09PHJ/MaEiEZMN41stEayPPtXaPAkToS4VeCAX3PgjuwSExoR3ScGYiR+Y8c5ivmKaJMEZeOUbM/Qb9zWBO2EE8jU3GHVUw4jAVDjG543hlyOcLmBCTE638yxPWd3c76y72SlOmrvsgUZlPZAaAaG3kxuJtgnQf/zmrVF0bMvraTnNdSO/ODwC6POpfHNjtvTvUD8PUePTGPRB7oPaKzzgbEaXI4xEl9K7OeqW6T6gGgghdQc1Hogy8RZmctNQrzQrBj5i3IdwMIpc085AuUW9pgh9EtTr/ozVvR1vxVjHFA7UpN4eZJ4fEd283HtaVw+lICJFWGylmKo3azIFkXMyIZq+UrPrrFTwtr1dvK82K70/V3yuPoK42aI8TKm+1qnW6yhAOwtJWDm0mSKY1d+D3EjyxiyEIwZzQmGMYYK9XmdaMrp0mwtLcENzP20aaMmWvvHzzhtPVDfEwc9y9JV7PK9P8jHT8CImv6F2ZpiN5PgGGVdcHqTilIEYnSqpEBsLzpdffbBD1Bx1l9rs8/gOXmf1J4E8CPJ2DrXslnw7MxwPHqyMExyy6+B1MMPbzSr2sdBViTC5ZL06yiSMP1XqghojOwdPgxbkRKXmbMc8nDqfrQdyKhBT9oqfBcCAXceGcaaCWNohNHZqNx0Gso92ReMHRdGeVCxKyjxi7m/xQKzSlLAvHpyfuPikAdJQgn7cLpglrxWXxin/cDay5pWAdz7ImB8xE6bF7xdAqHoBtdAtIaAyalffh+OTAenM1coMg/tbowaVlivr3MENxPwzT5twU8RR6Nb+TmuITgY7HY7YG8lilfK5S7c37bxXBUnL9T4hMybk2e11QE+pIvfPsquK4Ce5sP00THzyZ+c7rlcv5gfrsCSlFllKcyaoey9DV27NGpVkFgo/Pu2FhYEO4mVEjErNT/oUwnOEhdsGi0nrzOAnx3qY9vslHS7M3R1Uk+xRIrYMOD9sg42Byrk6XTtRE7SDWiDR6iv5+6QM87h4cNYXIy9tbnl7fczxdsYjfrC7rRnpYOF4/owSlbGdSPtDlkWXbsOJaI6N5aPd4B4SB233Z9WUPkO+LyNdH9fF14NPx+HeAP/CFz/s54Lvj8Z/7AY//nivFwMdf/4DjaUJU2K26s3ct1GpuqDuS5HP0g8Aa0AqJUWlIHN4Tru4NyRW+DopVUCPFI/N8IkwJyB6ZqS7uqq2i0cE0f0F8tu7laXDHLWz4ZDCANmeF9u6u8tIMCer5HzHQu6AW6UFoZjy8fMOTrz9HJvfPcNwDMKVZ8zdhEK+4QkTCeMMzwE/UW49xwDxS/IOqR4O2ERZl5iYy4gY2HUX6mJAMrkUzcX4C3ZW1ktxZDOhNHFBMCvh4tHdX3NqYBXd1bCOqH00i6iq14s9N7wXrXsKnMCMRB4dxJq8EdTd5ga7i/T2Bfd3YykqIOkhqjSlGPr5+gvCGy7rTWyMcE6EK2l1hLDGMsPSAaqd2bzutO3mvtIp1IT9K8O1zfoq/2sUvsjZaPHFfEeeKDB+UQQe3bvRibOY6l4oOY6RB/sMDxDS4e34g0MRIQ35QTJgGXrT1iphXa8EAjBgir1+/4smTZ4SUqaWhQdn3wtyOzNd/gLZ+SogTtTXYFtznTT16VTywSmIiiOuR5KfQwvyrwH8b+J+Nv/+VLzz+L4jIPwP8LA6W/kUzayJyLyJ/FPi3gX8E+F/9MD8oxMDp+kAKgpWNVjpb9fFiULcHjEEI3ceR1psL2/Lk30BcpUmPnlatSorurSkxUPZ7VJQ4PyGFo3tCpCF4G5OQEPPw1RgeG+JTBRnJ9VgfBj/O1mSAdLXuOMFC3Oavj5l7cMs/TQkhjVZCWR8Wpqy0dQCAzSMnHynqj45fDPpyf3QIh8G9Hm0W/rO6eeqZ62Nww9+6eyC2CjyCpWRq230b3aXy0htqyR3XqwHNsQhc4asidKIfROxYV3pwHITHSU03Z8saBBIxmo8vu7NoI/rWuzVMs8dBxmkAq4+ga/eRcXMvkCDBJ14NTBKRnY9uJnJQanWFbpDIFPyQjzj3JAi4q6sSaFRrqCQ/YHogaadbIMQOXWgtEUOnW8VDwWW0Z0YKPhZv2tm7V3d+MflUpjPGu1vnePDoCBuO9MVcCzP34LgW4zBTv9G9lRiYuPwgGlRXBE/Rcbe75czD/S3HqwlawqLfhMpeOT75WZb1JdLK2/eAHw8rvYJRkXzwwyMMJvB/nBWIiPwpHDD9UES+A/xP8IPjT4vIHwe+Dfw3AMzsV0TkTwP/Pt5c/ffN3kK9/z0+H+P+WX4IANV/PoS+0FpgXy7stSKinPLk9oENYszDCjAgYWKeJxid5aPIK6YMSQnm7lZxREGYVaIm8uFI1OltPyyiaPbKpbcO2ftgilOIhQDd2wMNkwOItjqwWhl8A3GHqzZYmsGzYXodo0szYshI98T25e6W+fgYAh7cUxMhRVdatn1zX8y2Q8TflNUtB5E6qhJc+j7Gc6J+V2zmQCvi/htjVusnS4ijBnewVZqgvdKlOY+jtqG18ecUwbNwFW+JVN1lneHPKkIYSlrf2+d4kbuENwe8B3Es5ETKiRQitEapO2KFZs3HqCpvpxNRBWndNUA49+X66opDUs57Z903DqUxp5m1bogGTAL6aJRkbgYk4HwZhCRCSxGrFakVTJ21aR76xTiIemIQAY3Y/SgSEXY29yE1nKfTIZrSS6XmSk5ufRA00qz7ZWcdGQHkDQjWScPNf2+VqTnoXUdx67qrgJixW+XV7UuePH/GnCuhK9teiGnHYkZPH1PP3yWd3EvVD34H4a02iDaYy8PO4cdY8kNQMX6qS0TugV/7ae/jh1gfAi9+2pv4IddXZa9flX3CV2evP2iff9DMPvoy3+ydZ6ICv2Zmf/dPexO/1xKRX/oq7BO+Onv9quwTvjp7/Zu9zy+v432/3q/36//v1/sD5P16v96vL72+CgfIn/xpb+CHXF+VfcJXZ69flX3CV2evf1P3+c6DqO/X+/V+vbvrq1CBvF/v1/v1jq73B8j79X69X196vbMHiIj8/SLyayLy6yLyJ37Ke/kDIvJvishfFZFfEZF/fDz+gYj86yLy18bfz77wNb849v5rIvJf/insOYjIvycif+Zd3auIPBWRf0lEfnU8t3/sXdzn+Nn/w/Ha/7KI/CkRmd+VvYrIPycin4rIL3/hsR95byLyd4nIXxn/97+UHybz0oaB7Lv0B3fn/A3gDwEZ+P8Cf+SnuJ+vA3/n+Pc18B8AfwT4p4E/MR7/E8A/Nf79R8aeJ+AXxu8SfsJ7/ieAfwH4M+Pjd26vuBXEf3f8OwNP39F9fgP4JnAYH/9p4L/zruwV+M8Dfyfwy1947EfeG/AXgT+G07j/LPBf+T1/9k/yTf0jPCF/DPhzX/j4F4Ff/Gnv6wv7+VeA/yLOkP36eOzrOOntP7Jf4M8Bf+wnuL+fw42e/t4vHCDv1F6Bm3FRyu94/J3a5/hZ3wB+C/gAJ1/+GeC/9C7tFXcH/OIB8iPtbXzOr37h8f8W8L/9vX7uu9rCPL5gj+t39Q/5Sa5hrvR34KLA/5AvCvBFX5Sf5v7/F8D/CD7X2vHu7fUPAZ8B/4fRav3vROT0Du4TM/tt4H+O674+AW7N7F97F/f6hfWj7u0b/AiePY/rXT1AfiT/kJ/UEpEr4P8O/A/M7O53+9Qf8NhPZP8i8uhf++/+sF/yAx77Sew14mX3P2tmfwdwZlhj/g3WT/M5fYa77f0CrjI/icg//Lt9yQ947Kf+/h3rb4pnz+N6Vw+Qv5GvyE9tiUjCD4//q5n9y+Ph7w8/FH5IX5SfxPrPAv+1YSP5LwJ/r4j8X97BvX4H+I6Z/dvj438JP1DetX0C/BeAb5rZZ2ZWgH8Z+M+8o3t9XD/q3r6UZ8+7eoD8O8AfFpFfEJGMGzX/qz+tzQw0+n8P/FUz+2e+8F+PvijwH/VF+YdEZBKRX2D4ovwk9mpmv2hmP2dmP48/b/8vM/uH37W9mtn3gN8Skb91PPT34TYQ79Q+x/o28EdF5DjeC38f8Fff0b0+rh9pb6PNuReRPzp+x3/kC1/zN14/CRDqS4JC/wA+7fgN4J/8Ke/lP4eXc38Z+Evjzz8APMfByr82/v7gC1/zT469/xo/BJr9H9O+/x4+B1Hfub0C/yngl8bz+v8Anr2L+xw/+38K/Crwy8D/GZ9ivBN7Bf4Ujs08eg//8S+zN+DvHr/fbwD/a34HwP2D/rynsr9f79f79aXXu9rCvF/v1/v1FVjvD5D36/16v770en+AvF/v1/v1pdf7A+T9er/ery+93h8g79f79X596fX+AHm/3q/360uv9wfI+/V+vV9fev3/AONYm9WJhIyWAAAAAElFTkSuQmCC", - "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -297,51 +294,120 @@ } ], "source": [ - "plt.imshow(np.array(Image.open(identity_image)))\n", - "plt.title(\"Identity Image\")" + "identity_image = np.array(Image.open(identity_image))\n", + "structure_image = np.array(Image.open(structure_image))\n", + "appearance_image = np.array(Image.open(appearance_image))\n", + "\n", + "plot_results(\n", + " images=[\n", + " identity_image,\n", + " structure_image,\n", + " appearance_image,\n", + " aligned_image,\n", + " blended_image\n", + " ], titles=[\n", + " \"Identity Image\",\n", + " \"Structure Image\",\n", + " \"Appearance Image\",\n", + " \"Aligned Image\",\n", + " \"Blended Image\"\n", + " ]\n", + ")" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "table_data = [[\n", + " wandb.Image(identity_image),\n", + " wandb.Image(structure_image),\n", + " wandb.Image(appearance_image),\n", + " wandb.Image(aligned_image),\n", + " wandb.Image(blended_image)\n", + "]]\n", + "\n", + "table = wandb.Table(\n", + " data=table_data,\n", + " columns=[\n", + " \"Identity-Image\",\n", + " \"Structure-Image\",\n", + " \"Appearance-Image\",\n", + " \"Aligned-Image\",\n", + " \"Blended-Image\",\n", + " ],\n", + ")\n", + "\n", + "wandb.log({\"Predictions\": table})" + ] + }, + { + "cell_type": "code", + "execution_count": 12, "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, { "data": { + "text/html": [ + "Waiting for W&B process to finish... (success)." + ], "text/plain": [ - "Text(0.5, 1.0, 'Structure Image')" + "" ] }, - "execution_count": 10, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" }, { "data": { - "image/png": "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", + "application/vnd.jupyter.widget-view+json": { + "model_id": "ae1799c6f74a44fc8d36bd345d2a5c17", + "version_major": 2, + "version_minor": 0 + }, "text/plain": [ - "
" + "VBox(children=(Label(value='6.369 MB of 6.369 MB uploaded (0.000 MB deduped)\\r'), FloatProgress(value=0.999975…" ] }, - "metadata": { - "needs_background": "light" + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Synced skilled-sun-16: https://wandb.ai/geekyrakshit/barbershop/runs/133snw7f
Synced 6 W&B file(s), 1 media file(s), 6 artifact file(s) and 0 other file(s)" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Find logs at: ./wandb/run-20220330_173858-133snw7f/logs" + ], + "text/plain": [ + "" + ] }, + "metadata": {}, "output_type": "display_data" } ], "source": [ - "plt.imshow(np.array(Image.open(structure_image)))\n", - "plt.title(\"Structure Image\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "plt.imshow(np.array(Image.open(appearance_image)))\n", - "plt.title(\"Appearance Image\")" + "wandb.finish()" ] }, { @@ -349,9 +415,7 @@ "execution_count": null, "metadata": {}, "outputs": [], - "source": [ - "aligned_image" - ] + "source": [] } ], "metadata": { @@ -359,7 +423,7 @@ "hash": "fff2847cd74d0abab8e7b713e45368b315320c9df162762b3e6d925ce5c86810" }, "kernelspec": { - "display_name": "Python 3.7.11 ('Barbershop')", + "display_name": "Python 3.7.12 ('Barbershop')", "language": "python", "name": "python3" }, diff --git a/main.py b/main.py index 58a815b..cf39a40 100644 --- a/main.py +++ b/main.py @@ -80,13 +80,13 @@ def main(args): identity_image, structure_image, appearance_image, sign=args.sign ) - table_data = [ + table_data = [[ wandb.Image(np.array(Image.open(identity_image))), wandb.Image(np.array(Image.open(structure_image))), wandb.Image(np.array(Image.open(appearance_image))), wandb.Image(np.array(aligned_image)), wandb.Image(np.array(blended_image)), - ] + ]] table = wandb.Table( data=table_data, From d7fce9ff5c72ab7eca9f786a8aa1c7aacad07e4e Mon Sep 17 00:00:00 2001 From: soumik12345 <19soumik.rakshit96@gmail.com> Date: Wed, 30 Mar 2022 18:19:47 +0000 Subject: [PATCH 09/15] combined face alignment prediction in main.py --- main.py | 70 ++++++++++++++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 67 insertions(+), 3 deletions(-) diff --git a/main.py b/main.py index cf39a40..c65627e 100644 --- a/main.py +++ b/main.py @@ -1,17 +1,58 @@ import os -import torch +import dlib import wandb import argparse import numpy as np from PIL import Image +from pathlib import Path + +import torch +import torchvision from models.Embedding import Embedding from models.Alignment import Alignment from models.Blending import Blending +from utils.drive import open_url +from utils.shape_predictor import align_face + + +def apply_align_faces(args): + cache_dir = Path(args.cache_dir) + cache_dir.mkdir(parents=True, exist_ok=True) + + output_dir = Path(args.align_output_dir) + output_dir.mkdir(parents=True, exist_ok=True) + + print("Downloading Shape Predictor") + f = open_url( + "https://drive.google.com/uc?id=1huhv8PYpNNKbGCLOaYUjOgR1pY5pmbJx", + cache_dir=cache_dir, + return_path=True, + ) + predictor = dlib.shape_predictor(f) + + for im in Path(args.unprocessed_dir).glob("*.*"): + faces = align_face(str(im), predictor) + + for i, face in enumerate(faces): + if args.output_size: + factor = 1024 // args.output_size + assert args.output_size * factor == 1024 + face_tensor = torchvision.transforms.ToTensor()(face).unsqueeze(0).cuda() + face_tensor_lr = face_tensor[0].cpu().detach().clamp(0, 1) + face = torchvision.transforms.ToPILImage()(face_tensor_lr) + if factor != 1: + face = face.resize( + (args.output_size, args.output_size), Image.LANCZOS + ) + if len(faces) > 1: + face.save(Path(args.align_output_dir) / (im.stem + f"_{i}.png")) + else: + face.save(Path(args.align_output_dir) / (im.stem + f".png")) + def main(args): - print(vars(args)) wandb.login() with wandb.init( project=args.wandb_project, @@ -37,6 +78,8 @@ def main(args): segmentation_model_artifact_dir, "seg.pth" ) + apply_align_faces(args) + device = "cuda:0" if torch.cuda.is_available() else "cpu" ii2s = Embedding(args, checkpoint_file=ffhq_model_file).to(device=device) @@ -81,6 +124,7 @@ def main(args): ) table_data = [[ + args.sign, wandb.Image(np.array(Image.open(identity_image))), wandb.Image(np.array(Image.open(structure_image))), wandb.Image(np.array(Image.open(appearance_image))), @@ -91,6 +135,7 @@ def main(args): table = wandb.Table( data=table_data, columns=[ + "Realistic/Fidelity" "Identity-Image", "Structure-Image", "Appearance-Image", @@ -150,9 +195,28 @@ def main(args): "--smooth", type=int, default=5, help="dilation and erosion parameter" ) + # Align Face Setting + parser.add_argument( + "--unprocessed_dir", + type=str, + default="unprocessed", + help="directory with unprocessed images", + ) + parser.add_argument( + "--align_output_dir", type=str, default="input/face", help="output directory" + ) + parser.add_argument( + "--output_size", + type=int, + default=1024, + help="size to downscale the input images to, must be power of 2", + ) + parser.add_argument( + "--cache_dir", type=str, default="cache", help="cache directory for model weights" + ) + # StyleGAN2 setting parser.add_argument("--size", type=int, default=1024) - # parser.add_argument('--ckpt', type=str, default="pretrained_models/ffhq.pt") parser.add_argument("--channel_multiplier", type=int, default=2) parser.add_argument("--latent", type=int, default=512) parser.add_argument("--n_mlp", type=int, default=8) From d71a875304ef46684448b52e927ab07a0d5bfd82 Mon Sep 17 00:00:00 2001 From: soumik12345 <19soumik.rakshit96@gmail.com> Date: Wed, 30 Mar 2022 19:15:55 +0000 Subject: [PATCH 10/15] updated codebase --- align_face.py | 1 + inference.ipynb | 120 ++++++++++++++++++++++++++++++++++++++---------- main.py | 55 +++++++++++----------- 3 files changed, 124 insertions(+), 52 deletions(-) diff --git a/align_face.py b/align_face.py index 7d64e65..5712483 100644 --- a/align_face.py +++ b/align_face.py @@ -34,6 +34,7 @@ args = parser.parse_args() +print(vars(args)) cache_dir = Path(args.cache_dir) cache_dir.mkdir(parents=True, exist_ok=True) diff --git a/inference.ipynb b/inference.ipynb index fee061e..45e2743 100644 --- a/inference.ipynb +++ b/inference.ipynb @@ -7,15 +7,22 @@ "outputs": [], "source": [ "import os\n", - "import torch\n", + "import dlib\n", "import wandb\n", "import numpy as np\n", "from PIL import Image\n", + "from pathlib import Path\n", "import matplotlib.pyplot as plt\n", "\n", + "import torch\n", + "import torchvision\n", + "\n", "from models.Embedding import Embedding\n", "from models.Alignment import Alignment\n", - "from models.Blending import Blending" + "from models.Blending import Blending\n", + "\n", + "from utils.drive import open_url\n", + "from utils.shape_predictor import align_face" ] }, { @@ -46,7 +53,7 @@ { "data": { "text/html": [ - "Run data is saved locally in /home/paperspace/Workspace/Barbershop/wandb/run-20220330_173858-133snw7f" + "Run data is saved locally in /home/paperspace/Workspace/Barbershop/wandb/run-20220330_184722-1btth4r6" ], "text/plain": [ "" @@ -58,7 +65,7 @@ { "data": { "text/html": [ - "Syncing run skilled-sun-16 to Weights & Biases (docs)
" + "Syncing run firm-galaxy-18 to Weights & Biases (docs)
" ], "text/plain": [ "" @@ -70,11 +77,7 @@ ], "source": [ "wandb.login()\n", - "wandb.init(\n", - " project=\"barbershop\",\n", - " entity=\"geekyrakshit\",\n", - " job_type=\"test\"\n", - ")\n", + "wandb.init(project=\"barbershop\", entity=\"geekyrakshit\", job_type=\"test\")\n", "\n", "config = wandb.config\n", "config.wandb_project = 'barbershop'\n", @@ -113,13 +116,60 @@ "config.align_steps2 = 100\n", "config.face_lambda = 1.0\n", "config.hair_lambda = 1.0\n", - "config.blend_steps = 400" + "config.blend_steps = 400\n", + "config.unprocessed_dir = 'unprocessed'\n", + "config.align_output_dir = 'input/face'\n", + "config.output_size = 1024\n", + "config.cache_dir = 'cache'\n", + "config.inter_method = 'bicubic'" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, + "outputs": [], + "source": [ + "def apply_align_faces(configs, identity_image):\n", + " cache_dir = Path(configs.cache_dir)\n", + " cache_dir.mkdir(parents=True, exist_ok=True)\n", + "\n", + " output_dir = Path(configs.align_output_dir)\n", + " output_dir.mkdir(parents=True, exist_ok=True)\n", + "\n", + " print(\"Downloading Shape Predictor\")\n", + " f = open_url(\n", + " \"https://drive.google.com/uc?id=1huhv8PYpNNKbGCLOaYUjOgR1pY5pmbJx\",\n", + " cache_dir=cache_dir,\n", + " return_path=True,\n", + " )\n", + " predictor = dlib.shape_predictor(f)\n", + "\n", + " identity_image = Path(identity_image)\n", + "\n", + " faces = align_face(str(identity_image), predictor)\n", + "\n", + " for i, face in enumerate(faces):\n", + " if configs.output_size:\n", + " factor = 1024 // configs.output_size\n", + " assert configs.output_size * factor == 1024\n", + " face_tensor = torchvision.transforms.ToTensor()(face).unsqueeze(0).cuda()\n", + " face_tensor_lr = face_tensor[0].cpu().detach().clamp(0, 1)\n", + " face = torchvision.transforms.ToPILImage()(face_tensor_lr)\n", + " if factor != 1:\n", + " face = face.resize(\n", + " (configs.output_size, configs.output_size), Image.LANCZOS\n", + " )\n", + " if len(faces) > 1:\n", + " face.save(Path(configs.align_output_dir) / (identity_image.stem + f\"_{i}.png\"))\n", + " else:\n", + " face.save(Path(configs.align_output_dir) / (identity_image.stem + f\".png\"))" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, "outputs": [ { "name": "stderr", @@ -152,7 +202,29 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading Shape Predictor\n", + "90.png: Number of faces detected: 1\n" + ] + } + ], + "source": [ + "identity_image = os.path.join(images_artifact_dir, config.identity_image)\n", + "structure_image = os.path.join(images_artifact_dir, config.structure_image)\n", + "appearance_image = os.path.join(images_artifact_dir, config.appearance_image)\n", + "\n", + "apply_align_faces(config, identity_image)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -170,16 +242,12 @@ "source": [ "device = \"cuda:0\" if torch.cuda.is_available() else \"cpu\"\n", "\n", - "ii2s = Embedding(config, checkpoint_file=ffhq_model_file).to(device=device)\n", - "\n", - "identity_image = os.path.join(images_artifact_dir, config.identity_image)\n", - "structure_image = os.path.join(images_artifact_dir, config.structure_image)\n", - "appearance_image = os.path.join(images_artifact_dir, config.appearance_image)" + "ii2s = Embedding(config, checkpoint_file=ffhq_model_file).to(device=device)" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -223,7 +291,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -262,7 +330,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -277,12 +345,12 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 10, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -322,6 +390,7 @@ "outputs": [], "source": [ "table_data = [[\n", + " config.sign,\n", " wandb.Image(identity_image),\n", " wandb.Image(structure_image),\n", " wandb.Image(appearance_image),\n", @@ -332,6 +401,7 @@ "table = wandb.Table(\n", " data=table_data,\n", " columns=[\n", + " \"Realistic/Fidelity\",\n", " \"Identity-Image\",\n", " \"Structure-Image\",\n", " \"Appearance-Image\",\n", @@ -370,12 +440,12 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "ae1799c6f74a44fc8d36bd345d2a5c17", + "model_id": "34fcf209011c4b338c6d41669182a08b", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "VBox(children=(Label(value='6.369 MB of 6.369 MB uploaded (0.000 MB deduped)\\r'), FloatProgress(value=0.999975…" + "VBox(children=(Label(value='6.339 MB of 6.339 MB uploaded (0.000 MB deduped)\\r'), FloatProgress(value=0.999970…" ] }, "metadata": {}, @@ -384,7 +454,7 @@ { "data": { "text/html": [ - "Synced skilled-sun-16: https://wandb.ai/geekyrakshit/barbershop/runs/133snw7f
Synced 6 W&B file(s), 1 media file(s), 6 artifact file(s) and 0 other file(s)" + "Synced firm-galaxy-18: https://wandb.ai/geekyrakshit/barbershop/runs/1btth4r6
Synced 6 W&B file(s), 1 media file(s), 6 artifact file(s) and 0 other file(s)" ], "text/plain": [ "" @@ -396,7 +466,7 @@ { "data": { "text/html": [ - "Find logs at: ./wandb/run-20220330_173858-133snw7f/logs" + "Find logs at: ./wandb/run-20220330_184722-1btth4r6/logs" ], "text/plain": [ "" diff --git a/main.py b/main.py index c65627e..b97b9cd 100644 --- a/main.py +++ b/main.py @@ -17,11 +17,11 @@ from utils.shape_predictor import align_face -def apply_align_faces(args): - cache_dir = Path(args.cache_dir) +def apply_align_faces(configs, identity_image): + cache_dir = Path(configs.cache_dir) cache_dir.mkdir(parents=True, exist_ok=True) - output_dir = Path(args.align_output_dir) + output_dir = Path(configs.align_output_dir) output_dir.mkdir(parents=True, exist_ok=True) print("Downloading Shape Predictor") @@ -32,24 +32,25 @@ def apply_align_faces(args): ) predictor = dlib.shape_predictor(f) - for im in Path(args.unprocessed_dir).glob("*.*"): - faces = align_face(str(im), predictor) - - for i, face in enumerate(faces): - if args.output_size: - factor = 1024 // args.output_size - assert args.output_size * factor == 1024 - face_tensor = torchvision.transforms.ToTensor()(face).unsqueeze(0).cuda() - face_tensor_lr = face_tensor[0].cpu().detach().clamp(0, 1) - face = torchvision.transforms.ToPILImage()(face_tensor_lr) - if factor != 1: - face = face.resize( - (args.output_size, args.output_size), Image.LANCZOS - ) - if len(faces) > 1: - face.save(Path(args.align_output_dir) / (im.stem + f"_{i}.png")) - else: - face.save(Path(args.align_output_dir) / (im.stem + f".png")) + identity_image = Path(identity_image) + + faces = align_face(str(identity_image), predictor) + + for i, face in enumerate(faces): + if configs.output_size: + factor = 1024 // configs.output_size + assert configs.output_size * factor == 1024 + face_tensor = torchvision.transforms.ToTensor()(face).unsqueeze(0).cuda() + face_tensor_lr = face_tensor[0].cpu().detach().clamp(0, 1) + face = torchvision.transforms.ToPILImage()(face_tensor_lr) + if factor != 1: + face = face.resize( + (configs.output_size, configs.output_size), Image.LANCZOS + ) + if len(faces) > 1: + face.save(Path(configs.align_output_dir) / (identity_image.stem + f"_{i}.png")) + else: + face.save(Path(configs.align_output_dir) / (identity_image.stem + f".png")) def main(args): @@ -78,16 +79,16 @@ def main(args): segmentation_model_artifact_dir, "seg.pth" ) - apply_align_faces(args) + identity_image = os.path.join(images_artifact_dir, args.identity_image) + structure_image = os.path.join(images_artifact_dir, args.structure_image) + appearance_image = os.path.join(images_artifact_dir, args.appearance_image) + + apply_align_faces(args, identity_image=identity_image) device = "cuda:0" if torch.cuda.is_available() else "cpu" ii2s = Embedding(args, checkpoint_file=ffhq_model_file).to(device=device) - identity_image = os.path.join(images_artifact_dir, args.identity_image) - structure_image = os.path.join(images_artifact_dir, args.structure_image) - appearance_image = os.path.join(images_artifact_dir, args.appearance_image) - im_set = {identity_image, structure_image, appearance_image} ii2s.invert_images_in_W([*im_set]) ii2s.invert_images_in_FS([*im_set]) @@ -135,7 +136,7 @@ def main(args): table = wandb.Table( data=table_data, columns=[ - "Realistic/Fidelity" + "Realistic/Fidelity", "Identity-Image", "Structure-Image", "Appearance-Image", From 6f9f6e4433b356b25a635e7b87730526a93ca3e8 Mon Sep 17 00:00:00 2001 From: soumik12345 <19soumik.rakshit96@gmail.com> Date: Wed, 30 Mar 2022 19:22:11 +0000 Subject: [PATCH 11/15] updated wandb job type --- inference.ipynb | 2 +- main.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/inference.ipynb b/inference.ipynb index 45e2743..1d604d9 100644 --- a/inference.ipynb +++ b/inference.ipynb @@ -77,7 +77,7 @@ ], "source": [ "wandb.login()\n", - "wandb.init(project=\"barbershop\", entity=\"geekyrakshit\", job_type=\"test\")\n", + "wandb.init(project=\"barbershop\", entity=\"geekyrakshit\", job_type=\"predict\")\n", "\n", "config = wandb.config\n", "config.wandb_project = 'barbershop'\n", diff --git a/main.py b/main.py index b97b9cd..4d67ab4 100644 --- a/main.py +++ b/main.py @@ -58,7 +58,7 @@ def main(args): with wandb.init( project=args.wandb_project, entity=args.wandb_entity, - job_type="test", + job_type="predict", config=vars(args), ): From 06e7dff4b3b156929e2b4067cbf37ae92492a3f9 Mon Sep 17 00:00:00 2001 From: soumik12345 <19soumik.rakshit96@gmail.com> Date: Wed, 30 Mar 2022 19:38:06 +0000 Subject: [PATCH 12/15] updated readme --- README.md | 21 +++++++-------------- 1 file changed, 7 insertions(+), 14 deletions(-) diff --git a/README.md b/README.md index 6820ea1..8619eec 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,8 @@ Official Implementation of Barbershop. **KEEP UPDATING! Please Git Pull the late `2021/06/02` Add project page. +`2022/03/31` [Weights and Biases](wandb.ai) Integration. + ## Installation - Clone the repository: @@ -37,28 +39,19 @@ cd Barbershop We recommend running this repository using [Anaconda](https://docs.anaconda.com/anaconda/install/). All dependencies for defining the environment are provided in `environment/environment.yaml`. - -## Download II2S images -Please download the [II2S](https://drive.google.com/drive/folders/15jsR9yy_pfDHiS9aE3HcYDgwtBbAneId?usp=sharing) -and put them in the `input/face` folder. - - -## Getting Started -Preprocess your own images. Please put the raw images in the `unprocessed` folder. -``` -python align_face.py -``` - +## Getting Started Produce realistic results: ``` -python main.py --im_path1 90.png --im_path2 15.png --im_path3 117.png --sign realistic --smooth 5 +python main.py --identity_image 90.png --structure_image 15.png --appearance_image 117.png --sign realistic --smooth 5 ``` Produce results faithful to the masks: ``` -python main.py --im_path1 90.png --im_path2 15.png --im_path3 117.png --sign fidelity --smooth 5 +python main.py --identity_image 90.png --structure_image 15.png --appearance_image 117.png --sign fidelity --smooth 5 ``` +You can also use the [Jupyter Notebook](./inference.ipynb) to producde the results. + ## Todo List From 24a59774231cea8b532eebb05b58721cadd42ec0 Mon Sep 17 00:00:00 2001 From: soumik12345 <19soumik.rakshit96@gmail.com> Date: Wed, 30 Mar 2022 19:53:51 +0000 Subject: [PATCH 13/15] updated readme --- README.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 8619eec..e51f010 100644 --- a/README.md +++ b/README.md @@ -50,7 +50,9 @@ Produce results faithful to the masks: python main.py --identity_image 90.png --structure_image 15.png --appearance_image 117.png --sign fidelity --smooth 5 ``` -You can also use the [Jupyter Notebook](./inference.ipynb) to producde the results. +You can also use the [Jupyter Notebook](./inference.ipynb) to producde the results. The results are now logged automatically as a Weights and Biases Table. + +![](https://imgur.com/gallery/CPrMZpp) From bf8bb18ea85c2946862b3bf4ab2f4c4217858e6d Mon Sep 17 00:00:00 2001 From: Soumik Rakshit <19soumik.rakshit96@gmail.com> Date: Thu, 14 Apr 2022 16:01:34 +0000 Subject: [PATCH 14/15] updated README --- README.md | 26 +++++--------------------- 1 file changed, 5 insertions(+), 21 deletions(-) diff --git a/README.md b/README.md index e51f010..b18806b 100644 --- a/README.md +++ b/README.md @@ -15,19 +15,12 @@ ## Description -Official Implementation of Barbershop. **KEEP UPDATING! Please Git Pull the latest version.** -## Updates -`2021/12/27` Add dilation and erosion parameters to smooth the boundary. - -#### `2021/12/24` Important Update: Add semantic mask inpainting module to solve the occlusion problem. Please git pull the latest version. - -`2021/12/18` Add a rough version of the project. - -`2021/06/02` Add project page. - -`2022/03/31` [Weights and Biases](wandb.ai) Integration. +This repository is a fork of the [official implmentation of Barbershop](https://github.com/ZPdesu/Barbershop). This repository build on the official reporsitory to add the following features: +- Combine [`main.py`](https://github.com/ZPdesu/Barbershop/blob/main/main.py) and `align_face.py` into a single command line interface as part of the updated `main.py`. +- Provide a notebook `inference.ipynb` for performing step-by-step inference and visualization of the result. +- Add an integration with Weights & Biases, which enables the predictions to be visualized as a W&B Table. The integration works with both the script and the notebook. ## Installation - Clone the repository: @@ -52,16 +45,7 @@ python main.py --identity_image 90.png --structure_image 15.png --appearance_ima You can also use the [Jupyter Notebook](./inference.ipynb) to producde the results. The results are now logged automatically as a Weights and Biases Table. -![](https://imgur.com/gallery/CPrMZpp) - - - -## Todo List -* add a detailed readme -* update mask inpainting code -* integrate image encoder -* add preprocessing step -* ... +![](https://i.imgur.com/subthu8.png) ## Acknowledgments This code borrows heavily from [II2S](https://github.com/ZPdesu/II2S). From 971be31afca55499287e97a7034a59a66b871ba8 Mon Sep 17 00:00:00 2001 From: Soumik Rakshit <19soumik.rakshit96@gmail.com> Date: Thu, 14 Apr 2022 16:03:23 +0000 Subject: [PATCH 15/15] updated README --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index b18806b..20b1872 100644 --- a/README.md +++ b/README.md @@ -18,8 +18,8 @@ This repository is a fork of the [official implmentation of Barbershop](https://github.com/ZPdesu/Barbershop). This repository build on the official reporsitory to add the following features: -- Combine [`main.py`](https://github.com/ZPdesu/Barbershop/blob/main/main.py) and `align_face.py` into a single command line interface as part of the updated `main.py`. -- Provide a notebook `inference.ipynb` for performing step-by-step inference and visualization of the result. +- Combine [`main.py`](https://github.com/ZPdesu/Barbershop/blob/main/main.py) and [`align_face.py`](https://github.com/ZPdesu/Barbershop/blob/main/align_face.py) into a single command line interface as part of the updated [`main.py`](https://github.com/soumik12345/Barbershop/blob/main/main.py). +- Provide a notebook [`inference.ipynb`](https://github.com/soumik12345/Barbershop/blob/main/inference.ipynb) for performing step-by-step inference and visualization of the result. - Add an integration with Weights & Biases, which enables the predictions to be visualized as a W&B Table. The integration works with both the script and the notebook. ## Installation