diff --git a/dataset/Load_FAS_MultiModal.py b/dataset/Load_FAS_MultiModal.py
new file mode 100644
index 0000000..a9b504b
--- /dev/null
+++ b/dataset/Load_FAS_MultiModal.py
@@ -0,0 +1,226 @@
+from __future__ import print_function, division
+import os
+import torch
+import pandas as pd
+#from skimage import io, transform
+import cv2
+import numpy as np
+import random
+import torch
+from torch.utils.data import Dataset, DataLoader
+from torchvision import transforms
+import pdb
+import math
+import os 
+import imgaug.augmenters as iaa
+
+
+ 
+
+
+#face_scale = 0.9  #default for test, for training , can be set from [0.8 to 1.0]
+
+# data augment from 'imgaug' --> Add (value=(-40,40), per_channel=True), GammaContrast (gamma=(0.5,1.5))
+seq = iaa.Sequential([
+    iaa.Add(value=(-40,40), per_channel=True), # Add color 
+    iaa.GammaContrast(gamma=(0.5,1.5)) # GammaContrast with a gamma of 0.5 to 1.5
+])
+
+
+
+# Tensor
+class Cutout(object):
+    def __init__(self, length=30):
+        self.length = length
+
+    def __call__(self, sample):
+        img, image_x_depth, image_x_ir, spoofing_label, map_x1 = sample['image_x'],sample['image_x_depth'],sample['image_x_ir'],sample['spoofing_label'],sample['map_x1']
+        h, w = img.shape[1], img.shape[2]    # Tensor [1][2],  nparray [0][1]
+        mask = np.ones((h, w), np.float32)
+        y = np.random.randint(h)
+        x = np.random.randint(w)
+        length_new = np.random.randint(1, self.length)
+        
+        y1 = np.clip(y - length_new // 2, 0, h)
+        y2 = np.clip(y + length_new // 2, 0, h)
+        x1 = np.clip(x - length_new // 2, 0, w)
+        x2 = np.clip(x + length_new // 2, 0, w)
+
+        mask[y1: y2, x1: x2] = 0.
+        mask = torch.from_numpy(mask)
+        mask = mask.expand_as(img)
+        img *= mask
+        image_x_depth *= mask
+        image_x_ir *= mask
+        
+        return {'image_x': img, 'image_x_depth': image_x_depth, 'image_x_ir': image_x_ir, 'spoofing_label': spoofing_label, 'map_x1': map_x1}
+
+
+class Normaliztion(object):
+    """
+        same as mxnet, normalize into [-1, 1]
+        image = (image - 127.5)/128
+    """
+    def __call__(self, sample):
+        image_x, image_x_depth, image_x_ir, spoofing_label, map_x1 = sample['image_x'],sample['image_x_depth'],sample['image_x_ir'],sample['spoofing_label'],sample['map_x1']
+        new_image_x = (image_x - 127.5)/128     # [-1,1]
+        new_image_x_depth = (image_x_depth - 127.5)/128     # [-1,1]
+        new_image_x_ir = (image_x_ir - 127.5)/128     # [-1,1]
+        return {'image_x': new_image_x, 'image_x_depth': new_image_x_depth, 'image_x_ir': new_image_x_ir, 'spoofing_label': spoofing_label, 'map_x1': map_x1}
+
+
+
+class RandomHorizontalFlip(object):
+    """Horizontally flip the given Image randomly with a probability of 0.5."""
+    def __call__(self, sample):
+        image_x, image_x_depth, image_x_ir, spoofing_label, map_x1 = sample['image_x'],sample['image_x_depth'],sample['image_x_ir'],sample['spoofing_label'],sample['map_x1']
+        
+        new_image_x = np.zeros((224, 224, 3))
+        new_image_x_depth = np.zeros((224, 224, 3))
+        new_image_x_ir = np.zeros((224, 224, 3))
+
+        p = random.random()
+        if p < 0.5:
+            #print('Flip')
+
+            new_image_x = cv2.flip(image_x, 1)
+            new_image_x_depth = cv2.flip(image_x_depth, 1)
+            new_image_x_ir = cv2.flip(image_x_ir, 1)
+
+                
+            return {'image_x': new_image_x, 'image_x_depth': new_image_x_depth, 'image_x_ir': new_image_x_ir, 'spoofing_label': spoofing_label, 'map_x1': map_x1}
+        else:
+            #print('no Flip')
+            return {'image_x': image_x, 'image_x_depth': image_x_depth, 'image_x_ir': image_x_ir, 'spoofing_label': spoofing_label, 'map_x1': map_x1}
+
+
+
+class ToTensor(object):
+    """
+        Convert ndarrays in sample to Tensors.
+        process only one batch every time
+    """
+
+    def __call__(self, sample):
+        image_x, image_x_depth, image_x_ir, spoofing_label, map_x1 = sample['image_x'],sample['image_x_depth'],sample['image_x_ir'],sample['spoofing_label'],sample['map_x1']
+        
+        # swap color axis because
+        # numpy image: (batch_size) x H x W x C
+        # torch image: (batch_size) x C X H X W
+        image_x = image_x[:,:,::-1].transpose((2, 0, 1))
+        image_x = np.array(image_x)
+        
+        image_x_depth = image_x_depth[:,:,::-1].transpose((2, 0, 1))
+        image_x_depth = np.array(image_x_depth)
+        
+        image_x_ir = image_x_ir[:,:,::-1].transpose((2, 0, 1))
+        image_x_ir = np.array(image_x_ir)
+        
+        map_x1 = np.array(map_x1)
+                        
+        spoofing_label_np = np.array([0],dtype=np.long)
+        spoofing_label_np[0] = spoofing_label
+        
+        
+        return {'image_x': torch.from_numpy(image_x.astype(np.float)).float(), 'image_x_depth': torch.from_numpy(image_x_depth.astype(np.float)).float(), 'image_x_ir': torch.from_numpy(image_x_ir.astype(np.float)).float(), 'spoofing_label': torch.from_numpy(spoofing_label_np.astype(np.long)).long(), 'map_x1': torch.from_numpy(map_x1.astype(np.float)).float()}
+
+
+# /home/ztyu/FAS_dataset/OULU/Train_images/          6_3_20_5_121_scene.jpg        6_3_20_5_121_scene.dat
+# /home/ztyu/FAS_dataset/OULU/IJCB_re/OULUtrain_images/        6_3_20_5_121_depth1D.jpg
+class Spoofing_train(Dataset):
+
+    def __init__(self, info_list, root_dir,  transform=None):
+
+        self.landmarks_frame = pd.read_csv(info_list, delimiter=' ', header=None)
+        self.root_dir = root_dir
+        self.transform = transform
+
+    def __len__(self):
+        return len(self.landmarks_frame)
+
+    
+    def __getitem__(self, idx):
+        #print(self.landmarks_frame.iloc[idx, 0])
+        videoname = str(self.landmarks_frame.iloc[idx, 0])
+        image_path = os.path.join(self.root_dir, videoname)
+             
+        videoname_depth = str(self.landmarks_frame.iloc[idx, 1])
+        image_path_depth = os.path.join(self.root_dir, videoname_depth)     
+        
+        videoname_ir = str(self.landmarks_frame.iloc[idx, 2])
+        image_path_ir = os.path.join(self.root_dir, videoname_ir)     
+        
+        
+        #log_file2 = open('temp.txt', 'w')
+        #log_file2.write('%s \n' % (image_path))
+        #log_file2.write('%s \n' % (image_path_depth))
+        #log_file2.write('%s \n' % (image_path_ir))
+        #log_file2.flush()
+             
+        image_x, map_x1 = self.get_single_image_x_RGB(image_path)
+        image_x_depth = self.get_single_image_x(image_path_depth)
+        image_x_ir = self.get_single_image_x(image_path_ir)
+		    
+        spoofing_label = self.landmarks_frame.iloc[idx, 3]
+        
+        if spoofing_label == 1:            # real
+            spoofing_label = 1            # real
+            #map_x1 = np.zeros((28, 28))   # real
+            #map_x1 = np.ones((28, 28))
+        else:                              # fake
+            spoofing_label = 0
+            #map_x1 = np.ones((28, 28))    # fake
+            map_x1 = np.zeros((28, 28))
+        
+
+        sample = {'image_x': image_x, 'image_x_depth': image_x_depth, 'image_x_ir': image_x_ir, 'spoofing_label': spoofing_label, 'map_x1': map_x1}
+
+        if self.transform:
+            sample = self.transform(sample)
+        return sample
+
+    def get_single_image_x_RGB(self, image_path):
+        
+        image_x = np.zeros((224, 224, 3))
+        binary_mask = np.zeros((28, 28))
+
+        # RGB
+        image_x_temp = cv2.imread(image_path)
+        
+        #cv2.imwrite('temp.jpg', image_x_temp)
+  
+        image_x = cv2.resize(image_x_temp, (224, 224))
+        
+        # data augment from 'imgaug' --> Add (value=(-40,40), per_channel=True), GammaContrast (gamma=(0.5,1.5))
+        image_x_aug = seq.augment_image(image_x) 
+        
+        image_x_temp_gray = cv2.imread(image_path, 0)
+        image_x_temp_gray = cv2.resize(image_x_temp_gray, (28, 28))
+        for i in range(28):
+            for j in range(28):
+                if image_x_temp_gray[i,j]>0:
+                    binary_mask[i,j]=1
+                else:
+                    binary_mask[i,j]=0
+        
+        return image_x_aug, binary_mask
+        
+    def get_single_image_x(self, image_path):
+        
+        image_x = np.zeros((224, 224, 3))
+
+        # RGB
+        image_x_temp = cv2.imread(image_path)
+        
+        #cv2.imwrite('temp.jpg', image_x_temp)
+  
+        image_x = cv2.resize(image_x_temp, (224, 224))
+        
+        # data augment from 'imgaug' --> Add (value=(-40,40), per_channel=True), GammaContrast (gamma=(0.5,1.5))
+        image_x_aug = seq.augment_image(image_x) 
+ 
+        
+        return image_x_aug
+
+
+
diff --git a/dataset/Load_FAS_MultiModal_DropModal.py b/dataset/Load_FAS_MultiModal_DropModal.py
new file mode 100644
index 0000000..9193543
--- /dev/null
+++ b/dataset/Load_FAS_MultiModal_DropModal.py
@@ -0,0 +1,244 @@
+from __future__ import print_function, division
+import os
+import torch
+import pandas as pd
+#from skimage import io, transform
+import cv2
+import numpy as np
+import random
+import torch
+from torch.utils.data import Dataset, DataLoader
+from torchvision import transforms
+import pdb
+import math
+import os 
+import imgaug.augmenters as iaa
+
+
+ 
+
+
+#face_scale = 0.9  #default for test, for training , can be set from [0.8 to 1.0]
+
+# data augment from 'imgaug' --> Add (value=(-40,40), per_channel=True), GammaContrast (gamma=(0.5,1.5))
+seq = iaa.Sequential([
+    iaa.Add(value=(-40,40), per_channel=True), # Add color 
+    iaa.GammaContrast(gamma=(0.5,1.5)) # GammaContrast with a gamma of 0.5 to 1.5
+])
+
+
+
+# Tensor
+class Cutout(object):
+    def __init__(self, length=30):
+        self.length = length
+
+    def __call__(self, sample):
+        img, image_x_depth, image_x_ir, spoofing_label, map_x1 = sample['image_x'],sample['image_x_depth'],sample['image_x_ir'],sample['spoofing_label'],sample['map_x1']
+        h, w = img.shape[1], img.shape[2]    # Tensor [1][2],  nparray [0][1]
+        mask = np.ones((h, w), np.float32)
+        y = np.random.randint(h)
+        x = np.random.randint(w)
+        length_new = np.random.randint(1, self.length)
+        
+        y1 = np.clip(y - length_new // 2, 0, h)
+        y2 = np.clip(y + length_new // 2, 0, h)
+        x1 = np.clip(x - length_new // 2, 0, w)
+        x2 = np.clip(x + length_new // 2, 0, w)
+
+        mask[y1: y2, x1: x2] = 0.
+        mask = torch.from_numpy(mask)
+        mask = mask.expand_as(img)
+        img *= mask
+        image_x_depth *= mask
+        image_x_ir *= mask
+        
+        return {'image_x': img, 'image_x_depth': image_x_depth, 'image_x_ir': image_x_ir, 'spoofing_label': spoofing_label, 'map_x1': map_x1}
+
+
+class Normaliztion(object):
+    """
+        same as mxnet, normalize into [-1, 1]
+        image = (image - 127.5)/128
+    """
+    def __call__(self, sample):
+        image_x, image_x_depth, image_x_ir, spoofing_label, map_x1 = sample['image_x'],sample['image_x_depth'],sample['image_x_ir'],sample['spoofing_label'],sample['map_x1']
+        new_image_x = (image_x - 127.5)/128     # [-1,1]
+        new_image_x_depth = (image_x_depth - 127.5)/128     # [-1,1]
+        new_image_x_ir = (image_x_ir - 127.5)/128     # [-1,1]
+        return {'image_x': new_image_x, 'image_x_depth': new_image_x_depth, 'image_x_ir': new_image_x_ir, 'spoofing_label': spoofing_label, 'map_x1': map_x1}
+
+
+
+class RandomHorizontalFlip(object):
+    """Horizontally flip the given Image randomly with a probability of 0.5."""
+    def __call__(self, sample):
+        image_x, image_x_depth, image_x_ir, spoofing_label, map_x1 = sample['image_x'],sample['image_x_depth'],sample['image_x_ir'],sample['spoofing_label'],sample['map_x1']
+        
+        new_image_x = np.zeros((224, 224, 3))
+        new_image_x_depth = np.zeros((224, 224, 3))
+        new_image_x_ir = np.zeros((224, 224, 3))
+
+        p = random.random()
+        if p < 0.5:
+            #print('Flip')
+
+            new_image_x = cv2.flip(image_x, 1)
+            new_image_x_depth = cv2.flip(image_x_depth, 1)
+            new_image_x_ir = cv2.flip(image_x_ir, 1)
+
+                
+            return {'image_x': new_image_x, 'image_x_depth': new_image_x_depth, 'image_x_ir': new_image_x_ir, 'spoofing_label': spoofing_label, 'map_x1': map_x1}
+        else:
+            #print('no Flip')
+            return {'image_x': image_x, 'image_x_depth': image_x_depth, 'image_x_ir': image_x_ir, 'spoofing_label': spoofing_label, 'map_x1': map_x1}
+
+
+
+class ToTensor(object):
+    """
+        Convert ndarrays in sample to Tensors.
+        process only one batch every time
+    """
+
+    def __call__(self, sample):
+        image_x, image_x_depth, image_x_ir, spoofing_label, map_x1 = sample['image_x'],sample['image_x_depth'],sample['image_x_ir'],sample['spoofing_label'],sample['map_x1']
+        
+        # swap color axis because
+        # numpy image: (batch_size) x H x W x C
+        # torch image: (batch_size) x C X H X W
+        image_x = image_x[:,:,::-1].transpose((2, 0, 1))
+        image_x = np.array(image_x)
+        
+        p = random.random()
+        if p < 0.5:
+            image_x_depth = image_x_depth[:,:,::-1].transpose((2, 0, 1))
+            image_x_depth = np.array(image_x_depth)
+        else:
+            # Blocked modality
+            image_x_depth = np.zeros((3, 224, 224))
+            image_x_depth = np.array(image_x_depth)
+        
+        p1 = random.random()
+        if p1 < 0.5:
+            image_x_ir = image_x_ir[:,:,::-1].transpose((2, 0, 1))
+            image_x_ir = np.array(image_x_ir)
+        else:
+            # Blocked modality
+            image_x_ir = np.zeros((3, 224, 224))
+            image_x_ir = np.array(image_x_ir)
+            
+        
+        map_x1 = np.array(map_x1)
+                        
+        spoofing_label_np = np.array([0],dtype=np.long)
+        spoofing_label_np[0] = spoofing_label
+        
+        
+        return {'image_x': torch.from_numpy(image_x.astype(np.float)).float(), 'image_x_depth': torch.from_numpy(image_x_depth.astype(np.float)).float(), 'image_x_ir': torch.from_numpy(image_x_ir.astype(np.float)).float(), 'spoofing_label': torch.from_numpy(spoofing_label_np.astype(np.long)).long(), 'map_x1': torch.from_numpy(map_x1.astype(np.float)).float()}
+
+
+# /home/ztyu/FAS_dataset/OULU/Train_images/          6_3_20_5_121_scene.jpg        6_3_20_5_121_scene.dat
+# /home/ztyu/FAS_dataset/OULU/IJCB_re/OULUtrain_images/        6_3_20_5_121_depth1D.jpg
+class Spoofing_train(Dataset):
+
+    def __init__(self, root_dir, csv_file ,transform=None, is_train=True, smoothing=True):
+        super().__init__()
+        self.root_dir = root_dir
+        self.landmarks_frame = pd.read_csv(info_list, delimiter=' ', header=None)
+        self.transform = transform
+        self.data = pd.read_csv(os.path.join(self.root_dir, csv_file))
+        if smoothing:
+            self.label_weight = 1.0
+        else:
+            self.label_weight = 0.99
+
+    def __len__(self):
+        return len(self.landmarks_frame)
+
+    
+    def __getitem__(self, idx):
+        #print(self.landmarks_frame.iloc[idx, 0])
+        videoname = str(self.landmarks_frame.iloc[idx, 0])
+        image_path = os.path.join(self.root_dir, videoname)
+             
+        videoname_depth = str(self.landmarks_frame.iloc[idx, 1])
+        image_path_depth = os.path.join(self.root_dir, videoname_depth)     
+        
+        videoname_ir = str(self.landmarks_frame.iloc[idx, 2])
+        image_path_ir = os.path.join(self.root_dir, videoname_ir)     
+        
+        
+        #log_file2 = open('temp.txt', 'w')
+        #log_file2.write('%s \n' % (image_path))
+        #log_file2.write('%s \n' % (image_path_depth))
+        #log_file2.write('%s \n' % (image_path_ir))
+        #log_file2.flush()
+             
+        image_x, map_x1 = self.get_single_image_x_RGB(image_path)
+        image_x_depth = self.get_single_image_x(image_path_depth)
+        image_x_ir = self.get_single_image_x(image_path_ir)
+		    
+        spoofing_label = self.landmarks_frame.iloc[idx, 3]
+        
+        if spoofing_label == 1:            # real
+            spoofing_label = 1            # real
+            #map_x1 = np.zeros((28, 28))   # real
+            #map_x1 = np.ones((28, 28))
+        else:                              # fake
+            spoofing_label = 0
+            #map_x1 = np.ones((28, 28))    # fake
+            map_x1 = np.zeros((28, 28))
+        
+
+        sample = {'image_x': image_x, 'image_x_depth': image_x_depth, 'image_x_ir': image_x_ir, 'spoofing_label': spoofing_label, 'map_x1': map_x1}
+
+        if self.transform:
+            sample = self.transform(sample)
+        return sample
+
+    def get_single_image_x_RGB(self, image_path):
+        
+        image_x = np.zeros((224, 224, 3))
+        binary_mask = np.zeros((28, 28))
+
+        # RGB
+        image_x_temp = cv2.imread(image_path)
+        
+        #cv2.imwrite('temp.jpg', image_x_temp)
+  
+        image_x = cv2.resize(image_x_temp, (224, 224))
+        
+        # data augment from 'imgaug' --> Add (value=(-40,40), per_channel=True), GammaContrast (gamma=(0.5,1.5))
+        image_x_aug = seq.augment_image(image_x) 
+        
+        image_x_temp_gray = cv2.imread(image_path, 0)
+        image_x_temp_gray = cv2.resize(image_x_temp_gray, (28, 28))
+        for i in range(28):
+            for j in range(28):
+                if image_x_temp_gray[i,j]>0:
+                    binary_mask[i,j]=1
+                else:
+                    binary_mask[i,j]=0
+        
+        return image_x_aug, binary_mask
+        
+    def get_single_image_x(self, image_path):
+        
+        image_x = np.zeros((224, 224, 3))
+
+        # RGB
+        image_x_temp = cv2.imread(image_path)
+        
+        #cv2.imwrite('temp.jpg', image_x_temp)
+  
+        image_x = cv2.resize(image_x_temp, (224, 224))
+        
+        # data augment from 'imgaug' --> Add (value=(-40,40), per_channel=True), GammaContrast (gamma=(0.5,1.5))
+        image_x_aug = seq.augment_image(image_x) 
+ 
+        
+        return image_x_aug
+
+
+
diff --git a/dataset/Load_FAS_MultiModal_DropModal_test.py b/dataset/Load_FAS_MultiModal_DropModal_test.py
new file mode 100644
index 0000000..d78385d
--- /dev/null
+++ b/dataset/Load_FAS_MultiModal_DropModal_test.py
@@ -0,0 +1,151 @@
+from __future__ import print_function, division
+import os
+import torch
+import pandas as pd
+#from skimage import io, transform
+import cv2
+import numpy as np
+import random
+import torch
+from torch.utils.data import Dataset, DataLoader
+from torchvision import transforms
+import pdb
+import math
+import os 
+import imgaug.augmenters as iaa
+
+
+ 
+
+
+
+class Normaliztion_valtest(object):
+    """
+        same as mxnet, normalize into [-1, 1]
+        image = (image - 127.5)/128
+    """
+    def __call__(self, sample):
+        image_x, image_x_depth, image_x_ir, spoofing_label, map_x1 = sample['image_x'],sample['image_x_depth'],sample['image_x_ir'],sample['spoofing_label'],sample['map_x1']
+        new_image_x = (image_x - 127.5)/128     # [-1,1]
+        new_image_x_depth = (image_x_depth - 127.5)/128     # [-1,1]
+        new_image_x_ir = (image_x_ir - 127.5)/128     # [-1,1]
+        return {'image_x': new_image_x, 'image_x_depth': new_image_x_depth, 'image_x_ir': new_image_x_ir, 'spoofing_label': spoofing_label, 'map_x1': map_x1}
+
+
+
+
+class ToTensor_valtest(object):
+    """
+        Convert ndarrays in sample to Tensors.
+        process only one batch every time
+    """
+
+    def __call__(self, sample):
+        image_x, image_x_depth, image_x_ir, spoofing_label, map_x1 = sample['image_x'],sample['image_x_depth'],sample['image_x_ir'],sample['spoofing_label'],sample['map_x1']
+        
+        # swap color axis because
+        # numpy image: (batch_size) x H x W x C
+        # torch image: (batch_size) x C X H X W
+        image_x = image_x[:,:,::-1].transpose((2, 0, 1))
+        image_x = np.array(image_x)
+        
+        image_x_depth = image_x_depth[:,:,::-1].transpose((2, 0, 1))
+        image_x_depth = np.array(image_x_depth)
+        
+        image_x_ir = image_x_ir[:,:,::-1].transpose((2, 0, 1))
+        image_x_ir = np.array(image_x)
+        
+        map_x1 = np.array(map_x1)
+                        
+        spoofing_label_np = np.array([0],dtype=np.long)
+        spoofing_label_np[0] = spoofing_label
+        
+        # Blocked modality
+        image_x_zeros = np.zeros((3, 224, 224))
+        image_x_zeros = np.array(image_x_zeros)
+        
+        
+        return {'image_x': torch.from_numpy(image_x.astype(np.float)).float(), 'image_x_depth': torch.from_numpy(image_x_depth.astype(np.float)).float(), 'image_x_ir': torch.from_numpy(image_x_ir.astype(np.float)).float(), 'spoofing_label': torch.from_numpy(spoofing_label_np.astype(np.long)).long(), 'map_x1': torch.from_numpy(map_x1.astype(np.float)).float(), 'image_x_zeros': torch.from_numpy(image_x_zeros.astype(np.float)).float()}
+
+
+
+class Spoofing_valtest(Dataset):
+
+    def __init__(self, info_list, root_dir,  transform=None):
+
+        self.landmarks_frame = pd.read_csv(info_list, delimiter=' ', header=None)
+        self.root_dir = root_dir
+        self.transform = transform
+
+    def __len__(self):
+        return len(self.landmarks_frame)
+
+    
+    def __getitem__(self, idx):
+        #print(self.landmarks_frame.iloc[idx, 0])
+        videoname = str(self.landmarks_frame.iloc[idx, 0])
+        image_path = os.path.join(self.root_dir, videoname)
+             
+        videoname_depth = str(self.landmarks_frame.iloc[idx, 1])
+        image_path_depth = os.path.join(self.root_dir, videoname_depth)     
+        
+        videoname_ir = str(self.landmarks_frame.iloc[idx, 2])
+        image_path_ir = os.path.join(self.root_dir, videoname_ir)     
+             
+        image_x, map_x1 = self.get_single_image_x_RGB(image_path)
+        image_x_depth = self.get_single_image_x(image_path_depth)
+        image_x_ir = self.get_single_image_x(image_path_ir)
+		    
+        spoofing_label = self.landmarks_frame.iloc[idx, 3]
+        
+        if spoofing_label == 1:            # real
+            spoofing_label = 1            # real
+            #map_x1 = np.zeros((28, 28))   # real
+            #map_x1 = np.ones((28, 28))
+        else:                              # fake
+            spoofing_label = 0
+            #map_x1 = np.ones((28, 28))    # fake
+            map_x1 = np.zeros((28, 28))
+        
+
+        sample = {'image_x': image_x, 'image_x_depth': image_x_depth, 'image_x_ir': image_x_ir, 'spoofing_label': spoofing_label, 'map_x1': map_x1}
+
+        if self.transform:
+            sample = self.transform(sample)
+        return sample
+
+    def get_single_image_x_RGB(self, image_path):
+        
+        image_x = np.zeros((224, 224, 3))
+        binary_mask = np.zeros((28, 28))
+
+        # RGB
+        image_x_temp = cv2.imread(image_path)
+  
+        image_x = cv2.resize(image_x_temp, (224, 224))
+        
+        
+        image_x_temp_gray = cv2.imread(image_path, 0)
+        image_x_temp_gray = cv2.resize(image_x_temp_gray, (28, 28))
+        for i in range(28):
+            for j in range(28):
+                if image_x_temp_gray[i,j]>0:
+                    binary_mask[i,j]=1
+                else:
+                    binary_mask[i,j]=0
+        
+        return image_x, binary_mask
+        
+    def get_single_image_x(self, image_path):
+        
+        image_x = np.zeros((224, 224, 3))
+
+        # RGB
+        image_x_temp = cv2.imread(image_path)
+        
+        #cv2.imwrite('temp.jpg', image_x_temp)
+  
+        image_x = cv2.resize(image_x_temp, (224, 224))
+ 
+        
+        return image_x
\ No newline at end of file
diff --git a/dataset/test.py b/dataset/test.py
new file mode 100644
index 0000000..ab9d0b8
--- /dev/null
+++ b/dataset/test.py
@@ -0,0 +1,2 @@
+import Load_FAS_MultiModal_DropModal as dataset
+
diff --git a/dataset/transform.py b/dataset/transform.py
index e69de29..d20cddf 100755
--- a/dataset/transform.py
+++ b/dataset/transform.py
@@ -0,0 +1,52 @@
+import yaml
+def read_cfg(cfg_file):
+    """
+    Read configurations from yaml file
+    Args:
+        cfg_file (.yaml): path to cfg yaml
+    Returns:
+        (dict): configuration in dict
+    """
+    with open(cfg_file, 'r') as rf:
+        cfg = yaml.safe_load(rf)
+        return cfg
+cfg = read_cfg(cfg_file='/home/air/Spoof/patch_light/config/config.yaml')
+
+
+import torch
+import torchvision.transforms as transforms
+import torchvision.utils as vutils
+from PIL import Image
+from Load_FAS_MultiModal_DropModal import Spoofing_train, Normaliztion, ToTensor, RandomHorizontalFlip, Cutout
+
+# Load an example image
+img = Image.open('/home/air/Spoof/Implementation-patchnet/images/LCC_FASD/LCC_FASD_development/spoof/FT720P_G780_REDMI4X_id0_s0_15.png')
+
+# Define the transforms
+transform = transforms.Compose([
+    transforms.Resize(cfg['model']['image_size']),
+    transforms.GaussianBlur(kernel_size=20, sigma=(0.1, 2.0)),
+    # transforms.RandomCrop(cfg['dataset']['augmentation']['rand_crop_size']),
+    # transforms.RandomHorizontalFlip(
+    #     cfg['dataset']['augmentation']['rand_hori_flip']),
+    # transforms.RandomRotation(cfg['dataset']['augmentation']['rand_rotation']),
+    transforms.ToTensor(),
+    transforms.Normalize(cfg['dataset']['mean'], cfg['dataset']['sigma'])
+])
+
+# Apply the transforms to the image
+img_transformed = transform(img)
+
+# Resize the original image to the same size as the transformed image
+resize = transforms.Resize(img_transformed.shape[-2:])
+img_resized = resize(img)
+
+# Create a grid of images before and after applying the transforms
+grid = vutils.make_grid(torch.stack(
+    [transforms.ToTensor()(img_resized), img_transformed]), nrow=2)
+
+# Display the grid
+import matplotlib.pyplot as plt
+plt.imshow(grid.permute(1, 2, 0))
+plt.axis('off')
+plt.show()
\ No newline at end of file
diff --git a/dataset/transform_visual.ipynb b/dataset/transform_visual.ipynb
new file mode 100644
index 0000000..df64d09
--- /dev/null
+++ b/dataset/transform_visual.ipynb
@@ -0,0 +1,378 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from PIL import Image\n",
+    "from pathlib import Path\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "\n",
+    "import torch\n",
+    "import torchvision.transforms as T\n",
+    "import os ,sys\n",
+    "ROOT = os.getcwd()\n",
+    "if str(ROOT) not in sys.path:\n",
+    "    sys.path.append(str(ROOT))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import yaml\n",
+    "def read_cfg(cfg_file):\n",
+    "    \"\"\"\n",
+    "    Read configurations from yaml file\n",
+    "    Args:\n",
+    "        cfg_file (.yaml): path to cfg yaml\n",
+    "    Returns:\n",
+    "        (dict): configuration in dict\n",
+    "    \"\"\"\n",
+    "    with open(cfg_file, 'r') as rf:\n",
+    "        cfg = yaml.safe_load(rf)\n",
+    "        return cfg\n",
+    "cfg = read_cfg(cfg_file='/home/air/Spoof/patch_light/config/config.yaml')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "orig_img = Image.open(Path('/home/air/Spoof/Implementation-patchnet/images/LCC_FASD/LCC_FASD_development/spoof/FT720P_G780_REDMI4X_id0_s0_15.png'))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plt.rcParams[\"savefig.bbox\"] = 'tight'\n",
+    "orig_img = Image.open(Path('/home/air/Spoof/Implementation-patchnet/images/LCC_FASD/LCC_FASD_development/spoof/FT720P_G780_REDMI4X_id0_s0_15.png'))\n",
+    "# if you change the seed, make sure that the randomly-applied transforms\n",
+    "# properly show that the image can be both transformed and *not* transformed!\n",
+    "torch.manual_seed(0)\n",
+    "\n",
+    "\n",
+    "def plot(imgs, with_orig=True, row_title=None, **imshow_kwargs):\n",
+    "    if not isinstance(imgs[0], list):\n",
+    "        # Make a 2d grid even if there's just 1 row\n",
+    "        imgs = [imgs]\n",
+    "\n",
+    "    num_rows = len(imgs)\n",
+    "    num_cols = len(imgs[0]) + with_orig\n",
+    "    fig, axs = plt.subplots(nrows=num_rows, ncols=num_cols, squeeze=False)\n",
+    "    for row_idx, row in enumerate(imgs):\n",
+    "        row = [orig_img] + row if with_orig else row\n",
+    "        for col_idx, img in enumerate(row):\n",
+    "            ax = axs[row_idx, col_idx]\n",
+    "            ax.imshow(np.asarray(img), **imshow_kwargs)\n",
+    "            ax.set(xticklabels=[], yticklabels=[], xticks=[], yticks=[])\n",
+    "\n",
+    "    if with_orig:\n",
+    "        axs[0, 0].set(title='Original image')\n",
+    "        axs[0, 0].title.set_size(8)\n",
+    "    if row_title is not None:\n",
+    "        for row_idx in range(num_rows):\n",
+    "            axs[row_idx, 0].set(ylabel=row_title[row_idx])\n",
+    "\n",
+    "    plt.tight_layout()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "TypeError",
+     "evalue": "Image data of dtype object cannot be converted to float",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[0;32m/tmp/ipykernel_770267/3133487428.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      5\u001b[0m     \u001b[0mT\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mNormalize\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcfg\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'dataset'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'mean'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcfg\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'dataset'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'sigma'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m ])]\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpadded_imgs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[0;32m/tmp/ipykernel_770267/3470795261.py\u001b[0m in \u001b[0;36mplot\u001b[0;34m(imgs, with_orig, row_title, **imshow_kwargs)\u001b[0m\n\u001b[1;32m     18\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mcol_idx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mimg\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrow\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     19\u001b[0m             \u001b[0max\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0maxs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mrow_idx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcol_idx\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 20\u001b[0;31m             \u001b[0max\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mimshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0masarray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mimg\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mimshow_kwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     21\u001b[0m             \u001b[0max\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mxticklabels\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0myticklabels\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mxticks\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0myticks\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     22\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/.local/lib/python3.10/site-packages/matplotlib/__init__.py\u001b[0m in \u001b[0;36minner\u001b[0;34m(ax, data, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1444\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0minner\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0max\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1445\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mdata\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1446\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0max\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msanitize_sequence\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1447\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1448\u001b[0m         \u001b[0mbound\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnew_sig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0max\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/.local/lib/python3.10/site-packages/matplotlib/axes/_axes.py\u001b[0m in \u001b[0;36mimshow\u001b[0;34m(self, X, cmap, norm, aspect, interpolation, alpha, vmin, vmax, origin, extent, interpolation_stage, filternorm, filterrad, resample, url, **kwargs)\u001b[0m\n\u001b[1;32m   5661\u001b[0m                               **kwargs)\n\u001b[1;32m   5662\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 5663\u001b[0;31m         \u001b[0mim\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   5664\u001b[0m         \u001b[0mim\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_alpha\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0malpha\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   5665\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mim\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_clip_path\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/.local/lib/python3.10/site-packages/matplotlib/image.py\u001b[0m in \u001b[0;36mset_data\u001b[0;34m(self, A)\u001b[0m\n\u001b[1;32m    699\u001b[0m         if (self._A.dtype != np.uint8 and\n\u001b[1;32m    700\u001b[0m                 not np.can_cast(self._A.dtype, float, \"same_kind\")):\n\u001b[0;32m--> 701\u001b[0;31m             raise TypeError(\"Image data of dtype {} cannot be converted to \"\n\u001b[0m\u001b[1;32m    702\u001b[0m                             \"float\".format(self._A.dtype))\n\u001b[1;32m    703\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;31mTypeError\u001b[0m: Image data of dtype object cannot be converted to float"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "padded_imgs = [T.Compose([\n",
+    "    T.Resize(cfg['model']['image_size']),\n",
+    "    T.RandomCrop(cfg['dataset']['augmentation']['rand_crop_size']),\n",
+    "    T.ToTensor(),\n",
+    "    T.Normalize(cfg['dataset']['mean'], cfg['dataset']['sigma'])\n",
+    "])]\n",
+    "plot(padded_imgs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import torchvision.transforms as transforms\n",
+    "import torchvision.utils as vutils\n",
+    "from PIL import Image\n",
+    "\n",
+    "# Load an example image\n",
+    "img = Image.open(Path(\n",
+    "    '/home/air/Spoof/Implementation-patchnet/images/LCC_FASD/LCC_FASD_development/spoof/FT720P_G780_REDMI4X_id0_s0_15.png'))\n",
+    "\n",
+    "# Define the transforms\n",
+    "transform = transforms.Compose([\n",
+    "    transforms.Resize(cfg['model']['image_size']),\n",
+    "    transforms.RandomCrop(cfg['dataset']['augmentation']['rand_crop_size']),\n",
+    "    transforms.RandomHorizontalFlip(\n",
+    "        cfg['dataset']['augmentation']['rand_hori_flip']),\n",
+    "    transforms.RandomRotation(cfg['dataset']['augmentation']['rand_rotation']),\n",
+    "    transforms.ToTensor(),\n",
+    "    transforms.Normalize(cfg['dataset']['mean'], cfg['dataset']['sigma'])\n",
+    "])\n",
+    "\n",
+    "# Apply the transforms to the image\n",
+    "img_transformed = transform(img)\n",
+    "\n",
+    "# Resize the original image to the same size as the transformed image\n",
+    "resize = T.Resize(img_transformed.shape[-2:])\n",
+    "img_resized = resize(img)\n",
+    "\n",
+    "# Create a grid of images before and after applying the transforms\n",
+    "grid = vutils.make_grid(torch.stack(\n",
+    "    [T.ToTensor()(img_resized), img_transformed]), nrow=2)\n",
+    "\n",
+    "# Display the grid\n",
+    "vutils.save_image(grid, 'transforms-train.jpg')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import cv2\n",
+    "import matplotlib.pyplot as plt\n",
+    "from Load_FAS_MultiModal_DropModal import Load_FAS_MultiModal_DropModal\n",
+    "\n",
+    "# Create an instance of the dataset class\n",
+    "dataset = Load_FAS_MultiModal_DropModal(data_dir='/path/to/data')\n",
+    "\n",
+    "# Get a single image from the dataset\n",
+    "image_path = '/path/to/image.jpg'\n",
+    "image = dataset.get_single_image_x(image_path)\n",
+    "\n",
+    "# Convert the image from BGR to RGB\n",
+    "image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
+    "\n",
+    "# Display the image\n",
+    "plt.imshow(image)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import imgaug.augmenters as iaa\n",
+    "\n",
+    "seq = iaa.Sequential([\n",
+    "    iaa.Add(value=(-40,40), per_channel=True), # Add color \n",
+    "    iaa.GammaContrast(gamma=(0.5,1.5)) # GammaContrast with a gamma of 0.5 to 1.5\n",
+    "])\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_single_image_x_RGB( image_path):\n",
+    "    \n",
+    "    image_x = np.zeros((224, 224, 3))\n",
+    "    binary_mask = np.zeros((28, 28))\n",
+    "    # RGB\n",
+    "    image_x_temp = cv2.imread(image_path)\n",
+    "    \n",
+    "    #cv2.imwrite('temp.jpg', image_x_temp)\n",
+    "\n",
+    "    image_x = cv2.resize(image_x_temp, (224, 224))\n",
+    "    \n",
+    "    # data augment from 'imgaug' --> Add (value=(-40,40), per_channel=True), GammaContrast (gamma=(0.5,1.5))\n",
+    "    image_x_aug = seq.augment_image(image_x) \n",
+    "    \n",
+    "    image_x_temp_gray = cv2.imread(image_path, 0)\n",
+    "    image_x_temp_gray = cv2.resize(image_x_temp_gray, (28, 28))\n",
+    "    for i in range(28):\n",
+    "        for j in range(28):\n",
+    "            if image_x_temp_gray[i,j]>0:\n",
+    "                binary_mask[i,j]=1\n",
+    "            else:\n",
+    "                binary_mask[i,j]=0\n",
+    "    \n",
+    "    return image_x_aug, binary_mask\n",
+    "    \n",
+    "def get_single_image_x( image_path):\n",
+    "    \n",
+    "    image_x = np.zeros((224, 224, 3))\n",
+    "    # RGB\n",
+    "    image_x_temp = cv2.imread(image_path)\n",
+    "    \n",
+    "    #cv2.imwrite('temp.jpg', image_x_temp)\n",
+    "\n",
+    "    image_x = cv2.resize(image_x_temp, (224, 224))\n",
+    "    \n",
+    "    # data augment from 'imgaug' --> Add (value=(-40,40), per_channel=True), GammaContrast (gamma=(0.5,1.5))\n",
+    "    image_x_aug = seq.augment_image(image_x) \n",
+    "\n",
+    "    \n",
+    "    return image_x_aug"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQEAAAD8CAYAAAB3lxGOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAAsTAAALEwEAmpwYAADxwUlEQVR4nOz9a6xt2bYehH2tP8aYj/Xar9pVdarO4z4w4MTcQIR/ECVEFhGJSBwUZOFIPAziGin3RySkYDtREsEfJ4EQpEgotkDYEoEgOQaErAQLKUryw8QXxwjb997zrjqnXrv2Y73nY4zeW3601nrvY865Vu06dU68r271qrXXmnOOOR6999ba197EzPh6fD2+Hr93h/vbfQNfj6/H1+Nv7/iaCXw9vh6/x8fXTODr8fX4PT6+ZgJfj6/H7/HxNRP4enw9fo+Pr5nA1+Pr8Xt8/MKYABH9w0T0O0T0fSL6E7+o63w9vh5fj6826BcRJ0BEHsB3AfxDAH4K4K8C+KPM/Ld+7hf7enw9vh5fafyikMDfD+D7zPxDZt4C+PcA/OFf0LW+Hl+Pr8dXGOEXdN5vAPhJ8/qnAP7gXQcvT8747Onb5TWBAJoeQwB48od9sHPgF40DyIen/7z2eQ4ebW9SvRbpBzllbNYr3N5cY7teg1PSL/CXuvRrjd1p4QPv/S4au8u+Nw59eNfzEoGI4LxHjB1m8zn62QwxRtlPdy0H6d58jZu976gvswxfasnumCB7+8Mf/uA5Mz/Z/fwXxQS+cBDRrwP4dQA4e/IUv/F/+LNgOJDzIJKpJgcQkSwaAND0OQtTIKevZavszQXXP5gZyJgScWYgMxhZCJe5fKmoS0RgovI5c0aeMBQCmOR4znI3nMEpgdOAnEe8evYp/sZv/lX8l/+f/wzbj38KjFsACeAE5Fz4wXSi7vn7EKE3TIja93e/p1R1kJ9ScyjVH4f6PUCeNU+nS9bO1ZMwuHxO7XXY6fkdQAwg6wFc+bQ+g3MO5GTuc9Y11HXOWaeOAb/DTxkAt89LBDgHggPIgXxAPDrC29/6Dn7t7/378Hf9/t+Po7MzZCI9h5P9Zzete410M5a50/PbISBCZII7QJRE0OfVvc0Gx/cPJgY87mc8u+r8IfU+IwMg/PF/7H/0waFz/KKYwEcA3m9ev6fvlcHMfwbAnwGA937172RHDnAe5FRDaSa0cAA6IBGoMO/yhghhnhxTOAYBcCy7w45x8jm1Ulw3OdmGsE0kd28HNdckOKqEAc4gELbDBucvnuPi/CWe/fQn+OCHP8T1+SvwONQnaXft7tglYLvfA0ipBUUGRHj/Vus8HpBY7Z53DQMgVEZMRHLucot14si5yX0AeiKbJSpnkjknB+cA8oDzrlk7PZZImADJ+zlnYcCZkVNCSgOGkZErD5kgxsKATPHNDCbhGiMzrq8u8fFPPsDyaInTs1N8s4sI80UldhVEVIje7o0bxEqFuEkn3j6j3R27M+GO6geTj3h/bQ4NYyR34NLy+X0n+0Uxgb8K4FeJ6DsQ4v/HAfyP7/uCSBCnTKCdtLpTjSBtWnc1AXvNbBt1f/Jtqvfmpe7LiVTjiViqVEhgOGQY4HcQpkIEeN3AOTEuz1/h+7/9W/joxz/Cy2ef4tWnn2BY3QC6ERWWYPJg9wwnQmz/2ctU1QcRJjA9YcswiwDflbyt9N+BB2RzS4K8CCwISdkEkQN8O5lyUUcE7xwcmXQlgEleewcfHboY4b0r13NEcM6YgExOzhk5ZaQ8YhwHrDcbbNYbDMOAnDIyH55GzgD5qp4xAGIGp4Sbq0v85Ec/xHK5BHmPp++9h/nySK5bnosaQlMhQvKbHLfbdLIm9heZhKHpJ/uv7nnzrr2h67631rZmh26uGb8QJsDMIxH9BoD/OwTR/FvM/DfvOp4AkHeNlNBlqjtbD6ySeHehqdl3htrJ/ti9v/Z8LOeCB8AOyFnRfAPZ2u84V0QsGXpoBTpncM5wYKxub/DxT3+KH/zOb+OTH/8Q66sL8HoFpEEPzkDK9R4PqQJU//QBiN7DB5VSzddYRTO1E8EE5tyoNE5oT9UVZv1pLmfT4lRCt58YnzJ1jcs/ItEFBYhKV5iGE0L25OG9/DgyKENwcPDRo5v1mKte7hoE4BzBO4LzDsyMNI5IygSGcYPVao2b62vcrtZYr1fYbDZIqSId5GbdGUqMVCQ2Z0Yatnj58jm+/73vYna0xOzkGN18Bh+CLrAwgD3moucTEEAVRbUIoV3Yu1DAvYz/kH53eNylNnyR2ewXZhNg5r8E4C+91sEkEkF2nQEvupMJ7G7a9r1D596/OZRNYJ+Xo5wDsMMI7F8Tk0xAtk2haIAZrJKK04hhHHD+4iU+/clP8fyTT7A6fwVs1kAeRCxxAnISe8TB+5YfIXwH7z1iiOhigPdVMoIBzqIrZ9FDJrCY2d6HMgAgc0ZOCRmp6s0F/QCkxOdaqbV7kBKS6c7OOXgf4Fwo3/fewzmPEMQAF0PYYwIEh9hFzBZzLJcL9F1fJD8ZgvAezlUkkFJCSiOGcYv1+haXF1e4vLrC1dU5rm+usVqtMaY8hXsNwRnbK+wvE8b1Gq9ePseLF8+xWt0i5QTDOgp/6mm47ikqP1wEGJEwhbrZ9pfXtee7g76pNXDcsdlp+oXdd/Twvw1I4GcaE4WWKjdtpOEeQeuCmqSra1O58heHQTSi3L7tnBBqOxwB3jcHifQDA0hZkT2Dc0YaR2xub/Hqxed49eIZNrfXKv1TtWTl/etOzw3ESOhnPebdDCEE9DEKIQVXpLEQBoNHRsoZOU9FX865GNMYQM4J4zhiACFnQubKxADAOVIidjCWbLNk8z2Bmc4B3sP7gBAivI8IPshPDIgxout6zGY9uq6DUyZAEA7inEfsOvSzGWazGbqug3e+ECiBEIwJKKQWm0DCOA7Ybrc4ObrG5eUFLi+XeHXxEueXl7i+ucF6sy17oJ1pMyyWzaVwjnNCGoVJyxNm2YuuSna1sdkyVXths11BBCroa3cbNQyEGsh+z16wX0V120GB7aFmtCzPakrb7womMBlU9ZiGCVQ7gMxCq88eUg3kbzqoGxfiNwZil7IveydQHRAYXVRV/dyM2nqvmVg5NyONA64vL/D82We4PH+JtFkDyTwABv+bTdJyewKCB7ouYDabYzFfYDGfofMRs65DiBEhOHhXLdecGGNKSOOInAzmq/EsZ5H8nIVJjBnDMGA7bjGmUQ1t1eJu1n3nPKjZoqYHi+FTpFtwHhQCfAwIsUfXyU8fe5H8MSDEiJkSeIwRwYvx1+wH3ilKiBEhRnj1Dpm6QqhIwEwJBCPajDEnnJ2c4Ob0FFc3Z3hwcYpnzz/Hs2ef4+XFOTabLXIG0kEaayZebQ8xBMQQK+Op8h0gAjvAbD91yeoxrmUsO9d0u0Ksmd1DwzwyBbQ2B98p2/Y+MDq6Wxq+MUzAiN7sAgIHUV08OthmpJH2+skdZ+YCLSsf4AKX6/UrVy6jGKnkAFbp1W5CqOS1axAYw2aDF88+w8cffoDzzz/HuFkLCjA3WIvXUZ/Pe6DrPGZdh/l8jqPlEZbzJebzGaIPmHUduhARu4AQvOjfAMYxYxxHjOOIPDbE3/yknJRRpMIEhnFEyqJjC1LIZR6dGWonrheaqBcheHT9HN1sjn4+w3y2wHy+QD+bo4sdQgiIMaDr5G+zCXiq7kHvPUKICD6qIa6qAuaC9c7BKxMQ/77xYmF2aRyxPj7Ban2Km7MznJ6cYjlfovv0Y7x48QI3qzU4VdfjdPpZpb0TtSV4xOAQvBdEwqj70fafQXmaUmQrt4qahV3pfxcSaE403RZVfbWXO6/bZ5ItWvUgued7YADeJCaAynMdkdrfgUZzKxbaOpHtw1braEvr7XFm7Z9MCRlhozDNiWuwOU4mWmGqxgO0aqcDwClhdXuN81cvcHVxjnHYYoI6DAW02gABwRP6PuBoscBiucDxfIGjoxOcHB1hMV8geK/qQESMAr8BIOeMcUgYxgHj0CCBLHEMKSXklIUB5ISUEoZxFCYwDPI5K7PgJMjA/G1KjHWTuzrPBMTYYT5fYrZcYrk8wmKxlMCbKFLfBy+/va86vpO1Lf85QQNe3cNODYzOhALUQOgJwWwVwcHrehDJ/khpxHq7wur2CKcnJzg9PcHx8RE+mH+Iz549w9X1DYYhFdWgdfrIesra3Vxf4+Xnn2MxX2C+WKLrZ+i6HhRQmEUL3uo5BHKbMlZiXZptVvYq7RgRm+N2T1t4TmsHoMnWQYk0KHrPVNWc8PED441hAgAKEbav0UyYkjKqJLegosan3wSS7A+F7LvGwPKxEjjV8+1+vzAKva/KGDJSGrC6vcbV+Tk2t7fwAIJ3GKjCbVEH6unggBAIi77H8dFCNvDJMU6OT3B2fIqTo2NlAgHReVEDnEjJnFS/DyPGMSLFrERsjABIigKSQv+UEoY0CgoYR6RcUUBOGSmNahTDjl6lxj9yYAIcPLquw3x5hMVyifl8jr6fIXY9ujhT+4BXBGDnyQUBUBOxLt4Icweaa1Cv58TbEINTxCDuRO/tfkgdNoztuMVqdYuT1QqnR0c4WixxtFzgeLHAx598gpevzrHdDEhZiLVYT9RVuL5d4aMPPsB2O+B7v/NdPHr0GO9+4z28/e43cPrgAULfYRJk1iICYwT20V0qviHGRp2Q3wf2Wkv4OwH+rSt451v7FL9LVzvjzWICrVhVKdCSM03+2nHZTPCSEeruN3fYaXtN5h0D+M60cXsf7X0JhM4p4fb6Gs8++RgfffghXj1/jmG7qeFsJZIQE0YdgsPRfIazk2M8ODvFg7MzPHxwhodnD3GmsHbe9aJ/6xPnlDGkEWMaMQwjhmHAOIqUT2OaGANzZiTORcLnnDGmEaOigoKemJGVWaSUyi0WCE4eTg2A3jt4FxC7DrP5ArPZHLHv1CgYEUMnTCAEcRGSzRiX89VNbLo/K+S3mAJCCF6YXwgIXRRDY/BiE/EOzruCDogEDWzncyzWayxnc8zmMxwt5jheLrFYLPDhhx/i+fOXWK03SI1XJgNAZozbLV49f47L80uErsfx2Rm+/Z3v4O/ebvEd73F8dgoK4v0wZDgJCjJpv+NVKgS/ywBIjr3PKCjXqOJvoiOwGfya6xGAXPduVXl+F9gEKh63iXL66EpuLefU3cnt13CQAaKZNaA9huv3yvu8d7h8ZqiA63VIX7D64terW3z6ycf4wXe/h48++BFuL8+xvb1GGjYCr+3KVbdBjAFHixkenp3iyeOHePL4ER4/fIhHDx7i4dkDHC+X6EKPPkR4heFZJfl2FGk+bLfKCEaMigzGMTVMQNQCVgTCrMjAPAmqYDJEdUgakcc7G1dcgKKOiHFSdPyu6xFjjxAiXAgC7X2EdwEu+ApnSeasQmQqc5tzAnEq8D44iG4eA2Ls0HURfa/GQzWKChOAxhEII+A8w9hlzLsZVv0My+UCJ8sljo+OcLRcYtH3+KH/MT77/HPcrjdwWaI7TfXLzMjDiDRmDNsBaRzxcQg4OTnByfExYhfRL+ZwIcI1niLa/YsmZFnm8a6xo5nsjcPfPbDp6+acMKKD6KAZbwQTMI5aOaVNMAPkQMiYJDyWh6xPZoxiF1aVDdcogYWpMLATK3ww9rpGKioCYdGZ2Tmwuqouzl/hpx/+GB/86Ad49ewz8LAFD2uM2y0wjsWAqCdEjAHHiyUePzzD0yeP8M7bb+GtJ0+ECZyd4nhxgr7r4OERvYdjArNI+q3GIWzHEduuw3azwbAVRrD1I7yvRG7S30JxxZjGxQ5Q548LIZi0Zr1X0+W9DwhemECMUYkxCAIIET4KcRTk4HwFaMYEGOo+Y9XNzb0q7ztyCD6g7yL6rkfXd+i6Dn0fBQV4p0QP9WI4OKeWfHZIPqMPDou+w9E4w/F8huPFAseLJY7mC/SxR4gRz56/wM3tGkNKSObxYFFVSvh6zri9vMKzTz7B40ePcHJyojaOoM9QDacmkRvBXPeMSqpKyzSZl4ZrTHYugUGUdz+Y7Neyf7l5t5wulzPdpxC8EUxAAYAsKjUhlvrZwYznFlLaW4wCOSekzQCTQnLaeU+Parl5I6yVi1ZjIqstolhcibHdSsTZZx9/jIvnn2N7ew2XkzKCQYOCRAslIsQQcHx8hLefPME7T9/CO0+f4Olbb+GtR49wdnqKk8UCs26G6D0IHp4k3cEMfWEUJuDHESEMCD5g6we4MMKNigpGQQY5Z1DOZUMqAi1uxOk8y2YWz8BklxZik3gAjxAk+Mc5DwpuoioApBGH5sGwk2eZXc5gTg3DJRAHEABPDtF79F3ArA+YzaIygIDgHEJwCL7GSbReDCZCJg94h5wz5tFjEQKWXYdFNxMVYTbDbD7H93/0Y3z06Wc4v7xC3g56bUGghkQJjO1mhVfPP8ezTz/BW0+f4ujoCCFGgASJlP0yEUoG4tWwWnG9op1dgjwEZe2FBK9NFkn3Zss8eMIFMNmvvzuYAAQGEjHgMirJWdBQq+PwAa5ZH9EitVpbAhuOn1jkdtWFukqTdAEos8houG5FE5mA2/UtXr14jovzFxjWN5IdmEbwoCjAQoMJiDHg5OgYbz99C998/z28+/Qp3nr8GE8ePhAbwGKBeYyIPiCY1RwQ3Tln5BDgQ4AfA/yYMIRBDGZhgB9GbLcDfBgwDgOGccSYzPLfbEBlKFBEU+aY5BnJEbzscJUsJAzAebXUe0EEIUjSj3clxt9ZFigBRL4QlIh9yQshTmoLSMqcXPEYBC/Ip48Rsz5i3os3JDhC8IQu+OptYLtt2eaZAHYEZgKcA7NDdF4Mqj6g7zt0817sGIslfIzgD3+CV+cXGMeMkrEqEAXIQB4G3F5d4fzFC1xfnCM9fQqkEc5HyzsrDKDYURrj83RrTe0BJVEK9b3DozWiThTYw0Zsrqoq2e/fFUxA4d2EWKn8s3PwgRNw+3b70Awm9YA35zaNolyChIHkwjltYrmoDRNNQRWtNAy4PD/H588+k00yCAPI44A8bMFpKAbBGAJOT47xjXfexbe++T6+8c67ePzwAR6cnuLs6LgwgD54Nb6Jq8zpxmR4gBkhq299SBrcojA9jIhhQBwGDMPQIIKMlDRQydQeNBPQGKtAAHkheovhr266oFDcIziB+85LwpBTa70FAgGaAtxEBxruJ/Zqn6iL6SCeD3GFBsy6iL5rEICXz4KX12Vtmi0xUWH0rOajZ4JEK8aIEDvEToyXBIecf4yLi0uJf9Dwb2TJnwADaRixvr3F+nYFHkd4EIJCqqSMrHCEPSIF3A4J3mcfaI5qVsqEYX1W+6ON4JQltX3bzs/913tjmMDumDzohKkefqCJoEf7gkCskIpbOyzvTaqtodMJJ65egJZnW6hyHgdcXVzg049+imcff4Kby0vkYQSlBB4H5HGUwiGcEYLH2ekpvvXN9/HLv/RLeP/db+DB2RmOFnMh/lmPLniNVKvE781l1sDKkAGfGMFnjKNX1DDC+wExBHQhYIixGAyHIWl0YCrGE5vTum91ZhxEsvsajFSYALkJE/AugLwDeyWwktMgGz2QEzQAtbWYXcLcpEwAEghi3AsuIHrJJuz7gC4GQQEkhkCxB9TUYth50XqKRJ20OBPvCN4TArxkPjrgwckpvA8a4djBOYcf/OBHuLy8LIFTJhgceRAztusNri4ucX11heXRCSj2YkPJrCnZVvMAE4Y62aM0ZQAl9LtsStqX9Nwghb2936YzowYRMab8CDQVYDvjDWMCootOAijc/XHP954LKBJHDGstPtgZhQacXs8Jl21UvcIO1Li1Xa/x8tnn+Oyjj3Hx4jm2t7fAdgDSCIypMgDv8ODsFN/59rfwd/zKr+Bb77+Ph2cPsJjP0MeIPkZ0IaLzHtETvNpGPCS50ZEV9FCwqXqwJyGM0Qc4N8B7LzEAMUr8wCjqwXY7YBi8+P+b3VFBrDI223heNrTp2sTqx2+kdSDxDsA7ZIfiCvTOQnwJnpwmC9nFslAhZzASwCSqAKGcN3phYn2IiN4jOoveI0VHMj+EJveq8Ps2ecrezPBEiBb9SQCRgzt2mtfQIXqP4Bx+8P0f4fziAsMwqKoiBM7jiPXNDT776GMsFgsM2xEPHj/BbLGAjxFeGYkuj0mMmnuxi2gL8fPOR61dYcpDDtoRGuZhGp3ZWWre492A2sYbwwRag0zJsFIU8DPxAFSiLVNxFwxjQgFtJrnUcm7ravDf4saJgO16jVcvXuD85Qusb2/A4wjkEaSGQGKGcw6nJyf41nvv4Vd/+Zfx7fffx6OHD7GcL0RH1Q0YSANfSGCo/M1wYK1Qw1B/FggOngQxsElpRxKhlyKGLGHEwyCMwQhsTGOjDFHJGTDy1zxIsGs8NY5UGhECSchvcPbb6bEASJiSb1x2jho0YZK/CZZiJoCyxAQ4sQXYT7B5cU51ekVFJbtRqzpwvfdChBDLuhGZV88B6x4gV+0e4Z13dO7FA/Pd730PL8/PkVISO1AiZJewWa3w/LPPkHLGxcUlnjx9G0/ffhsP33qCpT+BC8EeClBBZuJMNa7qKrUYA7PS3rODiyrVjrKNXdnbZsQmFvW3FXgNWDg43hAm0LoHKySisnt+ttG6+4rxSzfNbky8GCRKukZj8AEqh1YGwEAetri6OMeLZ5/h6tUrpM1WCB81+MM5wsnREd5/7xv45V/+JXzzG9/Aw7MzHM1mmPe9uAAdgTirtGf9fi6GsnJtZQQSW48i0UCA86wptw5jZoTEGLwvATXee4TtoCoBN96BSkCZCwtQIUNl9zoAXhmP18hBp0QPR0gOwgSUAXjLQiRf9GGzZpNau8U4iDJPhgKEGbhiCDRG4AvxcynbZVGyuRoYio5sRj4PiQUQJzOLLg8CPDQicQF6+jY4MYbNFqvbW2w2G1zf3FSiSgnjZovrq0skzlitVri5uQHA6BdzzOZz5BiF6WlFlkP72fa0MQDaSwJo/9bnaNTW9hx1V+8oCcSHGcuhWmc6fmYmQETvA/jzAJ5C1uLPMPO/TkT/awD/HIDP9dA/pbUF7j9f0T7t9VcfNPmn8RfwzlHOqf4//awkCplOoMU48rjFxctX+OjDD/Hs449we3UJTuNE+jgPLOYLvPvu2/iVX/oOvmUIYDZHHzv0IaBzqrmSLjbaOoMmQ+yeubhQpeyCbi4n8sCB4NnBZ2B0Gc6OJQv0caISpKRBjPI8zJUJZGUCleXJZw5UpTxVZuA1cg6KGIwBSJyAEq4SpN6yEkFWCUeAMrzovMJ+UXGiJ0RPCI70WZo1ZS67ZQqgK7OsyE9xDnOxsXtSHZ6EqR7N53jnyROsf+VXcHl5gevrK3z0yYjNdlAtJmMcBnELEyFnRowRNzfX2G43GIYtwhjgXAcgoPUCtHvRjKTFFrBz0N4re4y7j2iQT33sWvVIDzxQjq4dXwUJjAD+BWb+a0R0DOA/J6K/rJ/9a8z8r7zuiQyMt0zg5zGKtLeJ4qZYKFA8L2UzCevXgiE8UUVMcqZxwPX1JX7y4Y/xw+99Fy8++xTb1S04jcokMpxjzGOPt548xne+/S28//57ePTwAZaLOWadMIBQYDIbVgazE8jvzIrvACSFdlw2l1NICZXAcpMZxNSUBvMF4JCrBjVhAlM0kDMjc8KYM4hzySU0d6xtXGM2orKQ5vi3TMCYjm9eu1opSO/dkYNjQ15CnMZUjAlYFp9zrqyBMQARoJXACWiEH9d/Lc5fXZLGXG2veXtGRzhazPHu20/x+371V/Di1QvcrFZ48fIVxjGhJGSpigW3xnqzxrDZYFivsF7dwrygXV8rK9XM0lbdre+17m5hilNpXb63DwYO7XY0XOAwLdwxfmYmwMyfAPhE/74iot+ClBr/mcZdoOgrY4JCxQCTWklN3YCqqWimzSSJSgtW6Wy+7zSOOH/5Eh/88If45Ccf4ubqAnm7FXtASnDM6LqIBw/P8K1vvo/3DQEsFuhjhy4EzQNgQHP9jeGY2ozspD4B8QSWsxVHZQY5LgTI4CIpM2korfnklWF4rfQzpiQWcADQSDnJMnRAGjEmKbkF1I1jIJ7qBAlTUke9MSWrI+gdlbJiBY3ocd4YCLSaFFjVIFULHGluQBMjoZLcjPYMqw9gzGxKP5UBiF3HwqbrGldruVNGEbzD0WKBd99+il/+pe/gxatXWK3XuL6+kTwDvUYeE5IbsF7d4uryAufnL0HBYUyDqB+aWzBhAJYeXfCubU0qDzRVBCoOtHm5Syu2t03FsPTre0zge+PnYhMgom8D+K8B+M8A/AMAfoOI/kkAvwlBC69e+1z1nCiVZA7Aqy8zmIGsfn4hqoqThPAKXCgEX14Yp9b1GoctLl6+xPPPPsXNxQXG1VriAbQiTfAOR8sl3nn7bbz//vt48uQxjo6W6vO2qjpiuMmcNaY/A46k1LVryoGBkQ3uO1lWwQgOoCyw2td7L5sGEOMUuUKco1P7QHIYcy5IIOeM7LLGaKjdQ0umWV66IbWWIAVkmQ2j6v1OmZC5Oa0ei1OVwEHUU+egcRDKUFiYinkWiEwdkydjhWr7W5pNkVJuoAZdsrBktXc0XKKUYwMXiA8wnAMWyznefvsp3nvvG3h1fon1ekDeDkApkCrX2a7WePXyBY6eHUn/gq7D0bGspaRiZ1iRRmqeaRfcT7Z1c/6K+qi4rA+OJkcAsPjCVnc6jAza8ZU7EBHREYC/AOB/ysyXAP4NAL8M4NcgSOFfveN7v05Ev0lEv3l9oTxiL05aVQQz5vxMPzJKMQgyMjFdQI8rn9WX8qe5nRhICaurKzz/7BNcvniBcbNGGgbkQXIDPIBZ3+PRw4d479138fTJExwtl+i7DjF2IO9VclcCZI3rzwbLMzQVWNshZC7w3QIPMwOJGSkncClUKj+mPzuniMDXKLwYpNxXHzvxwQe1xAcrqCGBR9GLuiI/pOG0dUrb4iOkKkeF+kbgDI0jKkZPb94O9eM7oMB/C46aEkxZPdPsD/xUVa56OlR1y7mmSk9+pBgMp6aPgf5473F29gDvvf8+3n77HRwdHYkrVFVLKy6bU8Lq+hrXlxcYNxsJdw5BCqZMDNI7akAzkeW/nc+tz4KjWp35i35QUEejtoHUy0T38oGvhASIKEIYwL/DzP9XoRX+rPn8zwL4jw99t+078K2/8+8WGU0EIEFL/6LZdT/DzTXXMnWLgElitmLwcihJwYo8io/YedKaoJI0tLm5weeffIJPPvwQV69eFjWAU4ID0IWA06Mlnj5+jCePH2O5XEq2XYmhrzb/as22e0GzmaePnCHSk8h84wzHEubKzCCD75pX7yzc3CSBOPoBNl01NyG3da44M9h7E6t791H4qEqmXf45QQNqwGzRyb7kqyelAosrAyj6vs0Z7X6xzlVbUEOQQUP0DaLj9hSGLgwVcQaRw3K5xLvvvINXLy9wcXGFzWbAarWWudM94wFwzhi2W4zDFpxGcMqglOFcgBVna4umyhaborbXAbitPm+qzuSzxt5x0JsAAt3jZfsq3gEC8G8C+C1m/t8377+j9gIA+EcB/I3XO5/cLppfO3++9tg1rxDEhcZmkOGdrc37eliBvSwEuNls8Pyzz/Dj738Pn/70J9je3kpy0DjC5YzoCMv5HI8fPMZbj59gOV+IhdwIX63TxpUZtRS4wD0HJkICmkQoUmOfvF8eTomUiJGRK5zL+rTN4xUipPpGcXZApTgzMgnz8ExgX2F0G2NZGBhlJK2/F8r7cmxxc2rgjtXobF2FlWk0xK0LwGRnMmepsM42aqPVrDMYmQkjmhLwqO7OlglYrH61GSgDyCSoDIKeYuxwdvoA77//TVxcXGN1u8GzZ59jGFPtLwECUsb65hbnL1/i+PgEy8USi36GEFUy70hxG7thxIdGYZw7erDMVyvhbOdWobKrdpQgqjvGV0EC/wCAfwLAf0lEf13f+1MA/igR/Zrez48B/PEvOpEI6CpOZLPIQluAx33jYGflCZ2bjjl923RaBkp4Zh4lyo8A7UGQkIYBFy9e4oMf/gA//t73cfnipSSRaC0/YkYfOjw4PsFbjx/jwckp+tgJlHZO0mN4ahQydYAAsGbeMeum1llxuqJMlu8u38+5sAQJGGpr6aMoMIWZmbAgkkw5U0kqYaHAUGYI/GVGQi5BU2bdz+KTVBTADRJQu0X5DHUt0a6rnUuuVyak3dcyQWWtsl5/d5kNOSVVpYgZLgn5Z2WkUk2ZyzeI5BmF6I0piIpAJOpAYGDWz/DWk7fwnW+vcHO1xmYzSH6B7g1LId+sVjh/8QJ912E+m2O5OMJstoB3HrnYZZqtCJuXu/f07ic12ejQcbKreefd9lo1m/Hw+Cregf/3gfsFXrfXwGTIZFVoSPdOErAPU3df7x5b4jIOoiKdpKbXgCdC0lZXN1dX+PgnP8GPvv99fP7JJxhWa5DWtafE8ESY9zM8PH2AR2cPsJzPNRRVVIGSiMOkKN2s/mSAQw1ZksBkuXUgNfQwgKyVbiF6NnMS+A4Gl8KdMo/cTBBRI1EYyM5gdKNGUKFnQSqOQN5LtzbDGRabYKRjDFuJ36L5SiUhtvvRQmI7hFCIgQzCNvZsZUBOnXkODaPnST8RsY0kKUFOSVy0zFMUUK0JUC9BC6/VHsPSZ0AClwK63uHk5ATvvvsNXF+tcX29wrAdcbu+FZTDAFLGOGyxWa1weXGB58+eYbk8xmJ+hGUvrcyMI1pEQ4uKDu/EA/Nk811vujmmWY/dD/XK1Bq+D4w3I2JQNwMXJRXNPR/WZejOF9PvGYDUStFop8qWospoLseKXu2wXm/w6Ucf4wff+y4++fADrK+ukIYBQY1LnoA+djg9PsHDBw9xenyCXsuBFQu5MTWTboR6Xf3bgnZsq0zaaZkx0X7KlGRwpgr3lGImJoGGGTBVdJHV7dTCS2ECAMjJ/vUoNReYoHETJFiFMCF65/Wn8UgY82n14MnqcN3ALSMwf0R5VvVGmD1Eqj43BsEsxVSpKeduxsHcXngyx6jIS5vLCnoQJhjIYTbzePTwEb75zQ2urq9xvbrG+GzAOErxWGIWE1ZmjOstLl6d41n/CZaLI3TzBYI7kpDlZqMa82TUKouHOpQVRk4HKEADgcjWBe33D3zB9K87xpvBBOyJmteVJHEfE7NvTzfYjk5svxtQCEsOId1QchABgUBJxPOw3eLZZ5/h+9/9bXzwve/h4vlz5M0GTnMDfM7w3uN4ucSjhw/x+OFDHB0dSbltp5Zi3dYGv73eAeuDFchG9Y6laAnKBmgKqaGE9ioRmA6ei5Ewaz/HKSxstGEJU2ZWqz2pPUDVCPVssZry2OdiPzAdWioCUyn06e23/jhYN12I6w8mkXZVIrkxC8qyVl6FPHRSrJRDXdZq5ZdAHga4elnsqzXoqYqEsvYQt/HIwAixPbD2VXBQQ24AFkuHJ0+f4FvrW1zcXOB2fYPLi3NlsCwq45AwrLdYXd3gVfcSJ59/juPTM5x1HXxwgHOayq7ESI2hlKvEN1Yphmxu9sSBYbRuKmOzvw/Ry511DPHGMAHAorttOkol4S+yB2CXwHeZHhWGUt+Rf4s73pkmwMWwlIYtXrz4FD/47b+FH/7W38KLTz5Gvr2FzyOQRjX0EeZdjwenp3j86DHOzs4wny0Qfag19I3QdadzacPdiGgYp54SL6Ma1kRmmW1ATHCZCZ5y8cebnHYqOacTxWpbEKsDEUvdQipsCUgOSSMmQQznTOqiWNozC0x3mtFX3IjyrjIAJWO2lSx7fwf9KDPTRROi2O11cMe659QwAGMCVXwY5MqwasqVDah2pZLffuTuDL1kvU8fA5YnS7z97tu4urnC1fUlxnGDYbOVIq7DiHEzYOu38H6NzWqNzWqFza1EkRKradMREilyQmUAuyU0qtSifWnW6nnYOR67n1XhQ3ufTccbwgSUTCkLBi1EMYWrd3/zwNhhi6aV1Y81lYWa5BlKIGZ4ZFxdXuBH3/8efue3/gY+/emH2Nxcw6cRLiUxIgHoDAU8eIBHDx/iaHmknXWlyAa5hscbJbQMoD6g2kQaRNI8cikDlhnsoMYtLnuCKan0suNV4usbe91qG4kst+XgnDAnApCKIcokLiTAhjM811Bgr+nMTgORSgEUMsmPqg41j9ZuS1sVLrUeMhhuwvx317jEViRtrGq+fl1Xg/3Z1AIj/Qlc1LljlLqHouvLQU4NkURAFyNOz07x/vvv4fLyArfX13j+/Ll0fNIybmFMGLZbrFcrrG5vsV6tMA4DZuCik5tKimZ+qN71BKVwnaZm4fgAzC2LjjsH3f/xG8IEUCLcWuIviRaH8I0NOvySd9+1c3FLJFB9U8pyU07Iw4jNaoUPf/RD/M7f/Jv45CcfYn17K5KmgHq5t9l8jgcPHuLJW09wenqCftbDh6bUFk0l+96dOVSkgCb7Te9Z+p6yascomzaXoKrWjQYE8oBrib4Sn91Ga6mXkCmeBFKxR+2aDlLpL9ekXNFKZQCkVX8hyT5qDW+9ADZfU4wDNVrSZM2MERREsLeuStrZmEeDApUrmi2gGgX1BJwBDVU2e0SdKUMs5lKUmAEHArzHYtbj8eNHeO/99/Di+XOsbm9xfX1dmCWRBHbdXF/jk48/wfLoBCcPHqCf9eicnKMysymTp/KJKV1fZtS5rITerPvuBB4YbwwTaJe7xFlPDEqHn2If/t8/bBGKfqxuMMeMtB1xe3mBn374Y/zN/+Kv44Pvfw83l5cww5SFpBIR+q7D6ckJHj9+hIcPH+LoeImujyXf3RmOp3plIWCLVdwpCwVd/pK1xIXorfWaJYe1sLDGEwBM5mo0AknNHJLmmU+JxD4jbUUuuijXDcVOjIksxkSLrqvJQlqFWNFBDfu1XIGWxJtVJtToQEyBa5mvAuubL5VPdCLUWMD1GxOJSdAppalK2Ex6Ib8yt5Zn4FAbqDrCcr7A0ydv4f333sfNxaXUcdxu1eAs9pBxGPH82XN03RyL5TGcDzh79BDdYgbyrthK2uvX9azPy/q8BUDa07SPsBMA1Nq3WsQFMHLeefZmvBFMQDaBSs1iTd5RCfa+UbfVLiM43D2o+bZ+iTMXKLjdbHB1cY6ffvgBfuu/+Ov4/m/9LVy8fAkeBikSkpKWxJZQ18VigUePpFfA6fExZrGrbrJyiwZK1eiki5wh5xFitHAYaLVcsTVklVQe4gZT8pZgItCkGSqZYajskYa57AZGNX95CCFnx5IkQzQ5ntsNyTVUuFU3rALSbs6ANzTgDe0cgGzUvs+FyUIZls1jIVK1FbAp0xDUAicG0WoTgKKshvXoPw3/rATGDcNNWZpGIwMhwAWtm8ge3HU4PTnFN955B+cvX+Lm+hrnFxfSiTqNiOjhyWMYEz7/7DMsjpeYL2foZx188AizvkFh8ocj2X+7RlK7QQI0UZTaB6kPMZ3Q+pKnnzm3M//NeCOYQKF3mjKBXWvyodFWlyunu4MBcJHotjmEuMZxwM3lBT756Cf48Xe/i5/84Ae4evECtN2KJyAlUObiE+9ih7MTMQY+fPhAEoT6Dt47WHimuYIMnnLdjgCqGbTcV/MU7dMk/ZbV6ofpqlzl2l4giW4Wk8p6Q82cNW4y1OSd3dMUSzuAEqRQ3pHnKR4Bsw04J/kCFl5AqOs5uUedH57Cc/lM54r2WIcSBtWkLwukEN2i6PTGPCp2QDPhVIINqFQ6apQD4mLHkHUX6vTksJzP8PjRI7z7zjs4f/UK680Wm+0WacwYxySFXMhh2G5xdXGB81evcProAWbzmaiKIYC0HwPtPl+zCYzeC5ukyRI2X2jHviLBr1Gb781gAjCiadjgZBHv+Z4d1Xzv0ODcThCLa4eljv/q9hYvX7zAi0+f4fLlK6yurpGHQQiPWaLmNKIs+ICjoyUePX6Ex08e4eTkGPPFDDEGEIyQuBj9AZUwbEY92uH2usxFok83BiuBJGVYQvwMburzFSu5b5iPMdWCTKZSojAQQjGOtUxAXIF1V7LedMt4SjwA1QIm3hPapaxGwvplmqyX3EAmqgQMW9JdF7E+WE4lutEgMXHW6gRUn6sQBTW/GiOhNT7R+WNFEySiWgyFJrkJgHOIscPJ6SneefddnL86x/X1DV6+fCXdm7YjXKeNVZ3DZr3C9eUlbi4usVzM4aNH750Yce12pg84mePyxO3Hk7k4RPR3ffymIwFjc3ezvLu+VVWCL+IYjqpPCCi68XazxfXlFS5fnuPm8hLb9RqcRniuZsCUWdw9ROhnHR4+eIC3n76Fhw8eYLGcI0ZtusG5pgG3j0GmxSrMJUy2515xVUAkPsxaXe+lNL9y1KqQRb+2DDR7T16Lb1+Ot1TlukMyAa1T+j5Lsh6hxCLX9IA2BiW9j11+btzQvjM1+rG6FnmSRdooEa2EJEJ2XpiyLnpWJpSZQckYQZ7mHChSANsD5pq5mZQBKCiQQC1R5Yi4MG3xJhG6GHF2coK333kHL1+9wmq1xvXNCsMwlLLsxIRB99bV5SVOH5xheWz5I4bqGvRHwKQuYINKbBKmZHEIN+4QAEERHt27qG8IE9gfdwdW3n3cXY9Z9UAqr4kIKSVst2vcXt9gdX2F1c0NNlpbXjaq4EcLQXXeYblY4NGjR3j8+BGOjo9KyerCkEzoTBBNjWADqusJJvmNauwWCwoi1CgZvYJ+j9QrX4JwtKU3+Vqo1br8liQWJ65FqVwkG52QkbOESMs8taqCPUujVpga0lj9g6+GQJP8dX3aswkpEcyVSCjkxjWQpyX4EjPQIAuR3hZQBA1vFvtOJhREljPgRLvf2zMZDsy1XVvOTdwA14hNWFMc613BDHKEfjbDw4cP8NZbb+H8/BKbzSDnyBkuM9hJZ6qL83O8fP4CDx8+xNmDB40NR/eDqwteprhshC/ixvuflzyD5qNpoNX+eCOZAAET99kXsQOuzLIQuLzPk2PqlpTAmWEcsVmtsV6vcHt9g6tXF7g6v0AepTaAJuuVIh3zvsfp6SkeP36Ek+NjzGcdYvTwxQG8c18lwMfpNbkygOZhuSWIYgzlug8ayG1GIgvNMQQAk8LOKva016jSlwE4aOkxSymGQPvEGZzs3m1OW51U1yPjbkMTVxhuAKNGaFQJaA9v15DkJNJya0bwuvoTKzjBMjAK5WQALjfZkVw+kmXJzfWLTIexQdX6xBVqjEDVsGzcxIyvus4+BiyXR3j46DEePXqF29UatzerUrDEMSONI64uL/D5s89wcnKM45Nj7YLkAO92hPhuTF/L/OuerhN7ePqbWW2E3/3jjWICJSlFuaNthPuYQDH2yQlg+rWsd8auddxCX1MasdlusN6ssLq5xeXFOV49/xyr6ysgZd3skmTjiOBDh+OTEzx56y08evgQi/lMawUYCuDpZrXKNkWs2fXrvwdw8+RlfSYtEuJdZQJsBSc0yUa7/zg1TO3wmfq3q5vKGCw7JZos8QBJpWo1bHCxwnsikG/gTstoc0U9BNZa/A3KmdxNlfD2nrNzTqCv7vhmah25SWpxw6UEFTAjYRTUogp+QRhUkU7W7zBpGTm9PmOiHZVnZH1GQCop9/M5Tk/P8ODRI5xfXGEYE/IoTCNr78nNJuPF8xeYzeboFwv4rsPDGBB9L9N3cG4OjYoUrawbQDu2rnrs5PbvOSvwBjEBC7Gt8h9lk06nRnw/NUhj+qlB2soIdKNa9twokW+b7Rbb9Rqb9QZX55IBdnn+Cnkci0GQmDXsE1jMZ3j44CGePnkLp6enCDEKQexOsQWbyN01jKBiPVYxlZnhjau75kkbxkcKP6lEIUJTk51K9JqWawFKzjVdf2DMVdFCA+NJbld+skBpJiF418xr1mxFYpLcCmrP4yqjU1dX8eNn1gSaes0SVdis7tRQOJnK+uYOUfrmNTtCyirZC1OSEmwm6W1vFCOtSBuYzl1UnxZ5tNfg6THWnHW+mOPo+BhHx0e4vr3FJm+FkXCNZry9vcWnn32K2XKO49MTHJ0cIXa9qGcFwpIy5OaZhVNN5qDVGu0xJ1uwRQ92mi9wmb85TMCMRWpYMtQoPw28JeySXfsRYHKokVATaUCSj2/tute3t/j888/w7JNPsLldIToHx6y1vMTi7IPHcrHAg7MzPDg7w2KxaEpO2XWkXmANUd1J6tBR2IEyKm5N8y3EJoPGho5U0luqbvaacKPRe9pjYIKKqNkMxgDMPkCqnbObbHD5ggTLlNLke2tV7RC2IMwZINElzMo/IXSqbkRqmYDdpwVXtq7CRqJx868etnc/hdht4rkiyuoFgARVsXK+wgjs+7qLCOAsTL4GflLdfySoKnYRy+USR0fHmL26xLCt/RRs7lJKuLm5wfn5Ba6urrDdDJgnST4DLFlsSrj2/NDbaxnAZC0aJjfhlUXmECzd+K7x5jAB1CUvgTAwhLDLqdtvySi14+oJ6lAYCM7IWnLbARi2W7x8/hyfffQxri8v4TgDGcjjVmMDEpwjzPoeJyfHODs9xXw2Lw0yKw/Yn+KJPaL5aZ8lKwMw+wOB1T4Aw8ZNXlVj4LP/qBrYzIiZWKzaThFTaxRsUUAJ8lEgbO5Lp0wwK2GXUusp63kaQ2RRFwBjsqRqkdMOSeX6jIIAisom3KkwfqvsXJZWn1sntF6rqftQlrfd6txK7maPZJpUda6dCAwNmKpAZV1Zy8+bGmWuxwxh2qHrMF8scHR0hOXyGJvtgDQkUavM2Cp+XIzDgO1qhe1mi5S1iYrd8h1EXhllK1J2D+SG6NsjjNE6FGPPgfGVmQAR/RjAFSSuZWTm/zoRPQTwfwHwbUh1oT9yX8VhYYRVDWhuv/ls78IHCdAgXzlJ+UDCgwmM4B0244jPP/sUP/rB9/H82adSJgxASgN4uwWyJJh673G0nOHRwzM8fHCG2WxW2nPL6U07PcxtWwZgULm+U6WwMZQ2bx8EaJLfgedXSe6qdDWrcHaCSJwl4jQMZDK/TopiOmW6rtV9J5KVlSHIp1U6N4QJwMQWwVqROX2XipSaeEL0uauUk8Ipkw1c7qi+2wjscn+tB6CsRdkHVO5WqgxbINSUkQgbVgZuEn+Xg7foBtJjoOt7LI/F8LdarbDiFayItKyDMM00Jqw3A7bDUM6Zk+ZuUxvEbbftdt8BdnwdbbEV8z4J8pmi5/9/qAP/bWZ+3rz+EwD+U2b+00T0J/T1v3j313UXWChoMVrVohw2jGDMJfBFPm1bfmaAsxirxmGLly+e44ff/z4++vADrG5uBE6nrDYBKZrhHWHWRckRePgIpycn6LsOpd12Uyew7fJ79zigIBR1AHuULnvOlKHdDyvMNgldNgI3CGBn8ScRhFpxQ7wfdk69lvPluEKKigpElcrISdUfNvVLXJDmbQDUtqBIoFJ8fcL6+K3E25uFqZRU474RaU0WqgjAsiwNNDCTFhBhJJ2nnLUisX4+jaRsrD2txLaFcl7sMxpANJ/PMV8s0M9m2A4D0pALw7J7H4YB11fXuL66xrDdIsRQUMJukJjNExVuZJudpkh3b8Pt4s0DTGFn3P3JVxt/GMCf07//HID/4b1H050v9jdx8z41n+8hhj3ElIs6cPHqFT740Y/w4Y9/hKuLc8A8DKz1BUkMT10IOF4u8PDsAc5OTzCfzzU0WBeu+NS5cKODDJdaaF3u9p45AOqu43J42aAmOXcty4RiYKyqA6r60PzXbuoJATX355w0APE+IPqIGKV0eggRvmmh3sJRUxWsgEYppKEJVQKnaUJkhcYKhm9xYH1t91cIvfkprr2CNKTegrj+atl2K+OeMmPUkuSJM5JUHiht2Np5ZTYEYShCFkHauwX4EBG7HrO59CXsux7eB+1EJLmayIRhO+Lq6gqvXrzC1fW1GjN1fbRvuvSU0J/9TaHv6TlBjUG5qopFqLbp6QfPJePngQQYwH9CwsL/T1pK/GlTcfhTSL/C6aMQ/TqAXweAx++8K7fIBbmh7U48eQCq0p0ajscmbQyuKkM0acFWL/D6Fh//5Kf46IMf4+byEsE5uM6D1wnII4CsdfGBro84Pj7C6ekplsuF2gGk7gHD1d1oUBbtJm7uXMWd2KotFYhgd1vrDu5vbMvCk+o6kogE8urWQtVxoZuJjOhrgRbYPUzuiosiA6C0fDDrOCEV96vTZgKiXkDakWsQReLahcAMjqyLZAVCAfM2NPPSQHWbo1an31/2auw1grTHyqxITGsSZJCqM6TJQFZCzJiAEn4SRmC9BzIZz7WN40qRV1sE1pgQ1s/NMBtCQN/3mM/n2Kw2GFLCmBOYBzkPE1JibDZbXF1f4eryCscnp+i9l7RpY3QT5m7Sn8tcYYIZdo1+uezFyeTt7Mnd8fNgAv8NZv6IiN4C8JeJ6LfbD5mZ6UDR87bvwC/9/v8qO5t4ArC7gW2jEpVXLQMo2WW6sal8Lkckha7btTQS/fSjj3B9eSXNQXPG7eUF1rwCc4KDhPZ479H3PY6OjrVkWK9rkxT+qiqwp48YEdU7NykLDUFVs51+XvXQStBSRts1UpOMWRRrvsTbF8YJnjSeNSnDJDo5m1Gu9RpM9gUXBgIAlAnksqJVgrTxbfMJ2J62kehc9Fg07wO1PqDNEYFLOTFR1WprtKo5qOFTU5ilsEmVyFORbVCkdYdVJJD0R84BjRDkUqy1LUVWgI09nP7O9UEm1xVG4BFCRNf16LoOcbvFMI4FLbaekZwyhs0G47DFDPOm0nbds/ZIBXXaWzsxIFO72B3Anu5jAT8HJsDMH+nvZ0T0FwH8/QA+I+0/QETvAHh23zlaotXMjcYW0E46T45UsVNOwupJcOYXJW31lRnDOGK1XuPy8gLr1RrHy2Mc9T0un3+O1eU5OKdikHeOEILHfDbDcrnEfD5HiEE3bIaEm7rCBEqQk37fjHoizauTpu3oJ9Fx0Np+1Qkgm50A1wYbsf0PBov30kkDEtO3KWucfAaIhJFlzk0Jq0ZFaOwIE6zV8GoiAmXzFujmZICdq16YugkqI9D5mLjwytrtHl/z3IUgi3yvzEqZF7NAeAnhRkFd1UOxQ7FUXbSZxeNrBUUNwEkbMmNye3KqEUrtrXP5yF6bCiWMIBRVKQQPRkTOWUqx+YBZP8N8NkcXO6lB2TynqE87zFmZIU1e0uReiufiYOBQuwaHx1ftQLQE4Fgaki4B/HcA/EsA/iMA/xSAP62//8PXOZ9rW10XAxawF5DTwkqqMNGRxIQXlQgoRqtxHLHdbpHGhKPjYxwvFlhdXeLi+efYbrdyLkcCzQq8m2E+n6PrOoQQFJ1xYy03JIJmkUwtkA1eCEL1VBSpXKG8DVNxWMUO61cy2zxA696TlBozuMoGYwEw18QZYxDNjLUMYFL6S9GEMbU2FsBpzoH3XAxMRrBy7Vrg065RJbMiiykPKM9rotfiNso5mnoAPDZlxO020aCWQsNUicaIylQDk/YTrWhHRE4I/A7x2TAQgMt+EOGhjVRLi/UA5IxB5ySGgMV8jmMNLur6viZ8qf1E5JrBf/nnoJ2pzDMm83bHkTj8MDK+KhJ4CuAv6s0EAP9nZv6/EdFfBfDvE9E/C+ADAH/ki0506EHpwL2X9W4lTfNlyUabnoQsko4Ifd/jwcOHyJsNbi/Osb69xbAdUByUKnliiJj1PWazGWKMhZhZJaxZwic3rjcmEDCXXHrnSoGwVlYJcysSXiAqXE2IAZHW+xOUY8FhDmKRJ7CUJCFBJsYEPJqYgGYKJy5YQmEABFIbEhX1wukGlCQkL9KfUcoI5yxp2CklkdAGe3PW3IXqIgRpiG6zWeufqo+3WBwoeQBkNSBbm4HcWbNBdsSn06RiJpB3oCSlwqQsQC7ft0AgyhpByJX4ynpNmASKl8E6SNUmJpAW8MYEvEfIHjk5UJaMxhgj+n6GWd9jPpsjhiDRnSTNaBtOXVWignamQwQcTxnBHYDmF6oOMPMPAfw9B95/AeAPfblzoQqPie6IPXxUX5lk0Img9jt1krz36LoO/WyGo+MjOADPLy7x4vlzXF9egnNSgpRQ4eAc+i4WFGCRXfV65Z9yz9xIhVKk05NsgCSEkSmDuLaPtoBbg/ktoRBRSV4pkY5KlLZhzRBqcN0IOlE1DTZT1SAXahiAfNEVZinz55RNSfkwLcKpxkjnpG1XSgljGjFmlBTqTATLw/cg+ALNeU9i1TJozdyBhQMkTNQqQV6kDKpBL2aDUMKpXgIHcmIncWB4hiACiwLMWZhtztLm3ZKEeGrPsWXm9oeNMdVgqsKHyJiBA42azKXPFULArO8RQzdFvHeI+rvke4vqdkOCK7qqB0+DuvbHmxMx2BDTrsdUPp++V0Mr7LUdOPmWbGjnEZWoeRxxc3mFzz9/hs8+/RS3NyvDdwDLBgshYDabYzY3FABITECFa5VnUYXqYGQthe2aGgGZra/fVM0swg8oULCNsAN0w2UCUc16y1obwPQAylokU6FjDdvVWVAGYHNbm6JATTByTZc1NBnqhCLS8uakAS3q32AnSIAZYwZG7aYMVhhPmqIMK/ozXaUJpFdmzTk3LcMaIaDw3r5JrPCeLCm5gcVyRFG3iFhyLkiQlJfussJYieCynivVugFQ5FVcbTB3JjVPMP3L5rowBdsfJicsmnMckUbtdAQq69Wu1eT8OkEH6QFTNWCPETTv/65iAi2ByGg47A57m8SKHz7jZIKdc/DBgxm4vDjH58+e4frqUvK/VYu247quQ9/36DspGWawz3tXpHDxQjRuQpPYVo7blT7hUEbRWOfJBJlJhCb//8DTJJPi2fwEChqypQOrNUHRTJtT3tSlAIjgm1JpzhgHSVNSsKAWh1owlZVJysdikMwsYbEpAynp/akQF9e11GRMTjiDpB4z6r7luo6QDZ1KB6F6TDVe6jzVT8raFrTIdZ6h6h9z1tgBC+Fz0kFYCVuMnxVtWHlweZwpAp3utoq9XbOmJiJKRKIKBOc8xnHEzfU1VrerIpym7FrWoVV6Do2WAdRI0cMM4QtOBeANYgITmE/ND/bRUlHdDD1X/F/P1X6mRJFSwu3tLZ4/f4HL83OMw1g4PqnEcs4jhiD9A4JXwqpFNs2ybRCeGHAW62oSVcunW0iv815+NAlI4vhVxhA11Xgai33e32y6pwqnb4OUAFYsXH+XjWKzq0SU1I3mWOsSuEYqsUB/r7YMYoH1mTKYspQXt6aeiTFm+SmBL0XyACBFKS7D5UrwqiEIwep85uZ+97dB/W71GBw6pnlWzSKURrDymWcCshpeiYDsJG2cHBgJmRPIKg3vChhqX9geq3UVq5qi6C/n5ot1pJyRcirIsD6XXU+YuU3QvnP9bjXB5v9g0tebjwT0gQlAIxnvUpeM6RfooC+oiLudoZJ8s9ng/NUrvHjxHKvbFVLKBVLLN6lYdUMINVhJ4Sq8duvRjWvXLsoBoWyIQtDOw01+6qYRaF4r8lRXHleXb1MquoWkxgBMgrFFwihjMj8Y6/3b8wkv0GQgdvDMk8w+I6LknKRRJ4bPQGLBSj57q2wGzhB1IOUJE6jUqPaBXJlDIWKDuoVoeCLdbJ2FnKtEsOUmoKAxh3qcK583EpUIBGmo4AkABVGvnAR+pZQa6Q3kBCkAk43hk824nbDOlEblyTZqGGCddjmnMjnvxfNkK2qen/Jw9uBfdtB9ZH4HIel4Q5gAdBWpKXqhbxeY1Qzj0lS/2nLvcspCpMKB1xoncHN9g2EYkFPSfFnZwA7iy40hIDgvPJkrvMs5F79+vQgX4nTt5iWBpKRQ0JMxAF9KfpnkcMQaVVt1+4Judji7oXx7J7F04pFiqIZIqyoAbo9GKfIhEZmmPuQJA3DOwYGLqpMMUpGTRqbmvmMUJDCmDIswJDJ/tzUfMbRTfwPNbygja2eWKxPwFgVlur4+pxRdzWKMdKJne1DzuE1DUrIrealxQFaQQ+bXZSfXYZSoQCBpLYUs6ccNIRVGZRlfUEXAjL5E0l26EUzFoAhtmU6qgvD03FWPo8nLybZr9kVhPGyBVvsE/7sACaBIhddRZ3bdNlOoxge+IQswjma0c8gpI43SztqzbTZx7cQosfF1bk3H5gl9yWdCvPYMLVcnkh4FFvUmbkpXO/m6an7avWWLDOOSBWoPWW8gsRbK1Lh46L20OiLZlNgGAQNOwp9tU5oeL8xHILxvntKpQYCdGRe5qFuJGUNmjNrElVTVMIhbkIFKScpqMS98zpiBzSEadEYC4W1kLcBOuUJ+WwRIe/TQuEfbdSjIBAa5hQlmYlXP7DVgAa5ShzCXmAC53YpKYOcqC0jlGGqEBTmSfIsQkHLGar3GOI713qtOO9nKxiLr43Bl9HodWdpm/x1QBerZDo83hgm0cPQ+raf9ZDJhtKcdTL+lxL9YLNDPeoGTY4LLWfW5GuDhXa3dV+G0hptYsEyRBGIzaKMBq21AJb/XLretAckYQEsAQO2U1T7h9BAAbVLMRH5W3bropPpdq5xJJJK/tDS3UmLGw+RiSZEFCGDycJnhWTwCzjwdLPebWJuXIOnGrUVA5Wy5JBDJPOTKLwsaqnaRYtRsFGKG6Nk1qpDKfGVDQcoEvBZfIXtegpZe86U2Ipf7E+L3XozGPkMawpgAMDTZEmojHApLMZVKA94sXbnsT1UDGIztdlNtBrs6b1mDylZo+mHz9FDGW93OB42C9zAA4E1hAjS9+V1CP3g8TAdrP2i2hxIXpwrRur7HfLGUCsHelW84cgi6QbxV7TUih0XQHbgPW2Q2jbGJtlNfcdDAEUm+cWWRS4AMGM5yDdh6ITQPrhGPxuCt4q014TSCMTeb1c+vkIUreKCG2aryTPr8Rb9upIn4zEk67LiEMQdBBMwlnn/MGeOYMeakzw/Rt3V+igEhsRKk9vgzQ4h+xzfqEVT9ImIgO2QipJyQRq0IlXKdD+YSo0CQFum2Xs4RyHt4L0E8IfhSg9FgVgWQVBGZfZ+cJBWBURo0oJX+th+rQdjmzXJBEmeM4wgmQq9l630ICDEieA9umAY1FD49ffNqR8LZZ679eG+I/eeu8WYwARvUkjHvTDQOQGZUfYwP11GzrEwiidjqug5HxydYLJa4igGcRq0XJ408qBjJ2gvv3kCVJgwuxS1ZKW035NY5a9ptBjD1Nqh/35gAcUu8OgoTqF6JXDwAls/PtXkGLN0IwqQag1sxuoLgtOAFsUNWlOK8BLaQq6Y4c49SykiUxEXoHTw7ScwpJbslLt9pkpHdM+Wqu5oq5pwrOQM2T4xaTEmOzcgs6ltOGWMSBpByQh6T9AooRClflPqFal4lUcV89PBRbDw+yE/w1T4DoEhtewaABKl5XfVc1Z+yLLuejAbN2OcMsUUNKSExY7PZgAHMZjN0fSfqgU60+gT2BCLVB6xvHKD0Fg0cGocRgow3iwnoqNZhKu4z88EXAQmgdIXg/e9CPzc3nfcifebzOZ48foKfHJ/gRYhIfqwGPVQdvaa6okH5co42Br3Csnr9er3qJiR2Al05IfGInBI4ScknhyySUouatqGgVsseaCBmkfR5QuQOaGwPTXai3VuTL8Cu5iYSrDKRA3sPynkyjyX8Fwabg4S5wqC4JioxA6kGRzGg7cKqopZyAmktwsIooDEJDbPIKkHzmITwk8UmSE2IlCzXwKjIvCwy38E5+BDgByF8pzUYvfPootVGqGoaGqOeCQGxE6A0cp2obbtJVPa93XLvMCCUsd0OGIdB7iuEcrbKyqhO1c55vzg/4E7+MNlTh8YbxgT2jYPUUj4Ov2/++r0JIJRAGuc1anAhocAW9++ddt3NqO19WuOL/lcDQsjqUsrnReqb7klls1XiQTlxzhnDOGA7bJG3WhabpaIRN0zAiDdnzVXQWARhflmi3rKkSCNb3r/YMiSLzQujmNyfMKfyzPo8RkwmvSQOQG0dJMTTSnPvuTxbVuQiqMEIWN1tColbzb6EVGfp3ZdyKnENVMJwtdjHmKQobDLVR5BISrkmHBkRN4zO+ygenj4gJg83CtKzQq3DGNGlET33iDFq85jKTGSiTbURJMnGdJt5ADRKlGT7jHIDJR+g2IW8B0OCocg5zBcLdLMZRuZiW5owBG5lj4WGtWRwmNwZO8xiQje/wBqDP4+haljRVwvAI0yi7Q6NImMKhG8kn2IpIknz7GOHW3J4dX6B6+tr5JwRnSR4SNUhKESnKiEIstGcL+3C2M5bbr4yC2LSIhG6sZSICRl5ZKQ0IG1HpI1IhZwTOI3Iw4iserWpGbYjkkbrOd3so8HinAVNqKHOKQqY1PfTjEgfO81qC4AnwKu6ZQk15ESiZ6lTUDd5Rk4SBJyQEbxHYK7GTp0DK4SZuRJoMVKqzaSEB+exJCAN44hxHJFSQk4yB0mhf1apzxrhWNSbbIk7AKnrtUhxJzp3FyP61CP1ASEYE5B13Y6DFPwgAZOhJPJYoRiuiWgeuoZJENhOEFBWj0J20rpdOiBJERG9oRoV6j1812G2WCD2PciRqgPUnHJHB1Y1ZLL/zZJre7+gUm6Yej2XGLj3kYuNN4IJyOBiNCpCnoqmpEfUfwEUSQ9lFtPwySnfNCK9vLrFJ589w/XNrVb7BeAyeBwFDjNALgI+SPUeNfIR6SaxezJ02OjwZBFpmSX0gLSuXR5k444JwzDIz2aLcdhI9eNxRMqp2AqKJIXGoWcGKzGw+uTHlKQqThpVjaAS5ReaKr8hBHR9j36WwXEGDlJtZ0yaQYdaRdg7B/ZZE4RYkYc+c07w2YM5IjnxFAQfRAef2AU0B0BRyiQ5KGdJONLsw2EYsN1ssNluMaYRKWf9bAQn0f2TMghxL6KRxDK/noLo+qrzwzn4kFSFYjA6pNwyAQK8K8FNQjSAD1CvjCn/iuwAkJOAp2qV0cNgaeK6FdRVm1JWtFLjPrJKfXIO0H4DJXPQfk+GiTRVVQgSt6GfWUzJxE5hhouGqdwXH2DjzWECWrKLSCCTLQJU6sL+3ImjLG5kFml0SHeSFl5S2fXVy3O8enmO7TiIrYFE2th0C0F4iFWIapiv83pfwnEZeWKIKUEjrB4JYnE1MSOPGWlIGMdRyk5vtxg3GwyjBCyxVUK2RhhqcEtK5GlMGAdBDmkUfXjIGWOqTMCRWNi9awxfRAgxop8vkBIj9xkhdBIOTUGYgNf5cQ5Z3WSWL6DdBwTiktPnG+EDQeClkxZsGjGYtSFrHrNK8zRhAuM4YhhGDNsBo6pEq9UK67XOBWekpMjA7AHDILYBLQcPhhpyLRTbS4BX7NDPerjgBXkRCuFnTkiOQOoRgncaMwIADjzL8GOAcwHkfVENanqvMMk2evPQYNTIx5wsElHQCRVvjjFMyWSk4CsCmKjBRuoo6J8n16qF6gBN1UZlANyeSBHqXePNYQKoDJFoyvHqAahcblcnsol02CsBRQ7wngDKGLZbDNuhcEzTYyVrzhVXz8Sy77zkpdtCsd2Xwq1SathCTTMyRg3EYYzbpJt/i2G7xXa7EUYwDKXteck81ESbNCaR9sOAzWaN7XorRVGGEeM4YEhZy2U16gBB4Lqv4cld14vuPSZsNluE2CHGiBhiMZZaMQyOIvm9n9oynLYoyubxSAx2lj4s6MsClkxnN4ifctXzh+2IYSPPPmiRl/V6jdvbW2w2G6Q0TIq/oElXzkk4AJHUeui6GWIXERxryLQ+h2b7e0cYBiGwkF2p20kQJOD8WLwBw9hrRSD5sRBv8h7sqRg3Sfn87pZE6xVoDIzmcYAnhBgQY9TiNLsEuc8A9l4cMBjyhDEcoofDhsLd8TMzASL6fZDeAjZ+CcD/EsAZgH8OwOf6/p9i5r90/8lQLeKQiDVpSLHj9iscc3dGTILWRSlsRPVo53QD+SBxAuQwJOsZh2I0I5V4omMLcZBVGDYrsm7GqpWRVAJS8heRwOAxgZNEKg4bJebtBsOwxTAMSMOgt5/VEFWZwDiMGNOIYRiwXq2wXq0xbAdhIsMgbqcsxjKDiQ5aGs08Is5jNpthTMKEfIgIsUPfz9D3PWIMcOo/Dz4UwyA41DBfeZSaZKTVjOouM+ishsXEpdbAoJLf3ttut9hsVooE9NnWG6xXa6xWt9hu13LMdoM0ZpvZ4gIV9cYh+gjvPGKIopKYYY+rcTKpAZaZMXrbY4B1bvbOC2wfEzabDUIICCEi+Kh+/A4+BlAQW1CmGpV5YPuW67LVdlRmMKYRgMesn+Hk5ATHJycIwSPnhC50xcvSMgICJt6prMJt4mgpF6/UXkKTdriIGRvvGj8zE2Dm3wHwa3If5AF8BOAvAvhjAP41Zv5Xvsz5inVd9fuJ1Lf30UxY+SJDFSbh1GqOpuY4sS7LIsVOqrsAhJQyfC5TB+vlZ++QWnq91eBvTbhqrLGNSkCpaJF4lFj6nEWnHZIQ7maDzXaDcRyQxhEEaENTlWYmbSC556Pmn4ukA5JC6WE7FINaMVg1UyapvA7Re8mRyIw0ZikXHgeF2aNI0iibP0atupsBdIALU++GI8k6NKNpuxbC87TGQJJrjSNjHDLGbRKX3jhivV5js1ZmNgzCKLZbjJsBw3qD7WaN7bDFOFjePYqR0zu1b8QOi/kC8/kcfd+rUU9sNj54ILqiTubEGPIWUt8LGjPiEGIEBy1AmhK8ue0UCfgQBGn0DSPw1G5HmLbtncOo9gdjflZtKKtHgMeEzD2Wx0c4OTuDcw7bYcAc87L3d6sxV0lum9n2eT2ETR4aHWByg82pjKgOj5+XOvCHAPyAmT+4zx951xCpC8AR9pNwUF7vs8Fqoecd/ckgOkOi22B+ZeeKbs9G7mpkkhqHdmbZMK2rj5nLeoAtu40bKSRnHEeBvZv1RjwAijjMEJbSCIARHcHFCJOkdvuA+eMtiAhaR0Cs/4ZBzDtgvvOavKIBOyGoeiOZACkl9CzaJDOQckJMHXLXRB/q8FDXmTLClLOUDlN919AW65oIoxECGDVVllVdMYi/2W6x2YhKlJLC8WyuK3m26INUd9CMTe8IXel3IEbO+XyBWT8Tg6APEpUZOjjvpSaC7p3ikeCkxkqAINd0WpjVDJopZTg3aph3wDgkxHFA6DqEPsJ3WjasdUea2xikatCIYRzLs1ksQ4KgoJxzYbpSsAVN7Ebde3Z+2+1tzYrJmLxHk6/TlExwT8Dgz40J/OMA/t3m9W8Q0T8J4DcB/At8TwsyG6UdeWspVQTAEzyzi2sal2A7DQWtciH2wkgaR7+5sMi7PVeMldwqfnaUmwEVzkvl/rLqwsN2i816jc1qjXGQxTco5x3BU93g1kacUG0SRpCxj0gpYUtbBBIX5xh7rEKH2/UKMQa1NSi6SEmZk7oGfYCnAGTGuNlqWXprXW5BR3o8y0+CZgAwg32Ai16fFxgTATSAOMOzB0IAStSdtANPGMEkLlEQaziehPoiZc38Q2GkwXkgduBuhM8ZiQjZqnwApTSc1HoMiF2Hrp9JtV7v4VyQStDeo4udGDMJ6sIUJpVyEoms6+qdfJ50b1gU55gyiBKcE8Y6IiNwRkRCR52cFzYfpga5gt4qEuASWUnsSkTp9fU1rq+v0XUR8+USVli3tBtrjXo2T1TTow+bx6b2/3LIThxx/kUaBomoA/A/APAn9a1/A8C/rJf/lwH8qwD+mQPfK81Hnrz7DRgUbu0D9dhDCs2ugqYQoNK/ftd+9PictfJP5TBEKHCs9n8zTr/DBGDn1+YfqiiOKWHcDqr3rrFdbzBuNkqYZo/wCL6Dt/be9hgFzlfdWucI3kn34UwBOSSMLkhasvcIQxR3YwxibFPo76Ahs95rXQTxf2eF3wTJB/Al5h6F8RhyyGC4nOE5wMeqDzMYQdeKkodzxgybuIlmfSraqs80MfPofXYxgnJCSqQZdnI+Hzy6LiAGjxhF6gdXYyHMJeq8R/AOKEFBXtGKpu2Wxhx2b4Djpmko1e3Eqj5RyKCUQCMBo9cajLoujfHUBJepnGXtvBejpsZErFUwiMlL60VahKGrpmbSf1jv1eJP9mA+V1W0mAt20IQtsLsHoP88kMB/F8BfY+bPAMB+AwAR/VkA//GhL3HTfORX/8AfYJvIQhxFLbjHoqFSuKoK8l77uUjYmusPiOsoaLqwS051aJp8y+IC7L6kp57TSha6tbUCb9botu12wHq9xnq9xrjZ7ljuSY1wASFolhtD4/2nEgAGM3fYvyU65RAQUoBPI9hncBCVwmsNBO+sjiCKl6OkwGZGGgYMamxzpPMRvErDETQQIoIUUTF9JEghHqeeEeIMwQ21CnPharY7OUOCkRJAXPI4nCeE7JA1IscxgOjhKGAcRVKncRR3JZG4WdOInD0MUmVOcmonKb9e18O5AKfGQpbTN3WaoaqjqokspdJaN2bNxpOvWLxDGgdBKZEUDRiS1FoUxUDHhQEM4yiMQNWj2HVYLI+kB6F8yxa2lWE7O5wmh5aRUb1pzdtF4NP+sXeNnwcT+KNoVAHSpiP68h8F8Dde5yRUWJURgbYSKQaTw8xAjFL1M5p4DiS5R+J2qFj6vQ9qETc9r0pE0e1ryKdFCZbMQrUbSLguIVNSxCuwc0xJ3VkER14CTYDi164JSg1yIQkmMb3eflJK2Kw3WG/W4FGOTeOA7WaL1WaF9bCt0XZZoHbwHt5JoxSnvyfzpQFV9ToZnDU8N7vyk5LoqpyzRr/lQsiubD7p8kzOlT4JkolpjNOWTxiD8FGdW+9AWqWYJ/OxQ5AJZS4ySyNUMBByBsco2YyWYpzlJiwXohiTyWwXujc05KEwAfXsWLKU8GGJoEyZwGkERsJIIzofang5AEuNtv3GutfMjmTP673H8fExHj95jKPlEt41DKCc7MA239dwy/vUvFd+M6ob0950AKe7henPo/nIPwTgjzdv/2+J6Nf0Nn6889nd54IhgWaxqFxHj9qF//LegdCAcg4zMBIBIUpXIQmWqYk+ZMkgxdADWCsYyQXwxUhmDmfmUe4mZwvlV/1auhdB6/PJ2XIJ57XIN9GXq1dg3G4xDGpA22wwDBJQs9nIa0GzsiG32wGbcYutBh+lURqpOpKQ2dgF9aVLLADBCn0Kc81E8OLUrwwgJWRvtXksg9PKcVbpaG7MUkexIWyxz+i1vEOyeYMVUUExgpHZZVjCiFOWIKgxjRjUvmFxCBaV1w0R3TBisx3Qxw5d32PsOonO63QDhKTBXlbmzXaXhnsrZ3K615gl9Fc3X2lTBpD2Jmys/t4jMwsO0Ocwd2mR2GacdV7tDfJdp23tlkdL9PNZDVxCgbLTbX1gtHR9SCa2n+2ZAH5RSICZbwA82nnvn/iZTtYuWAPfd+HO5Frt1xtdeme65HzeIQaP5WIultnMpQYgJWkOUer/oep2pluLoYlAJP70rGpLSWhRS7B3Hi5Sdd3URvVCCHp7bVz8sN3g5vYGtze3ojduNqXyTM5icHRmL9BNZY+aLY6eM0ZmYBix3kDdfhGdWqPFlUYaQVdLY1vCEYcAsGwH50ylsBqIrrw2VUN0eQk1RmEwAo9zEhhgwUgWgGXISsKSVcLnpNGDGgOx2WA7bDCOqUTdZWXSokoJg+u7Hv1shq7rtDr0HLPZHGGbEGJEjJo2rB2UQQ5MLLkd5Z5N9avCAl7LumtSUzaMbr94imiKJlmyEct2Bues8SEbZLCER48jvEIRttJ0VafdPwc3Ru12wzsU9LVLIMXG0dLHPUaBNyhi0CaBVf+u+tCh2y8WgEYXa5SC5ny6OUGldFjWOH2xlFuqTwP5AZRiIl7SUC35xFQGUa9Zw1wlEcjaVRe5kC24s0b2iZ4p7rT1eoXNZoOb62tcXV5KkIyqBCEELXMWoABXdoLaH4Y8YjuOGLoBg/nWS0LOgHGUyLyNl2Sa2Hfa8cbBuVQz+EiIK5cKS1R+vEUfNq21ikFO4wiCEhhIrPqcM9h7jJmLd6UWV1WJrNLVwog3G80hWK+w3qyxViRU8gYg1nyrBRBCJ16RlNANI8J2i9mQsBlG+PVGmZ4cH2MnpeODBzwVQ6Rk99V8guLuU8kuodNiryGL5DQ1iNSro8VYZJ+pINrZlymJt4iZcXtzg81qg6TotUCcssmphgJwc+Jmz01owJWv7dPHLhPgA9BBxxvCBBqOWgh/13e++42WM9fJb82D9v2sUsoIN2tCSjWYsRjQqG2dZSnBpl9qDgFqlxqLA+c0gnPWfH5X7TyUFBFIIlEaJfw1jwnr2xUuLs5xdXmJ29sbpDEhxoBZJ/5ukWYRPkS5HdOS1K89pIQuZaRZkjBkVQuGYcB2u1Z1QlSHcUzoUkLqYkm2kcIeCY4I0Ud0fSdRecpwbC6sh0IgJ4U51BIvCCmoaqWWeLU3ZDWmTdOsp77wlBI2g6g6m424VMWousJ2s9W8CkVXWh2oi5L6a7kCMfbixw8R5AJU+RfC02hMoluNAAzq6w8I0ZfQaWFwmn4dvAaq1fv1RKBAGmVoSMYVJlBVJYJVk7bn9dpXwPZJZSBNfAFs41Oz0VW1sj1O7bv7NLA7dntc3sUobLwhTOB1hkl3m5opoZtBZn9SJNLN8tsz55JeS4XgbXFqSXEz5jjv1cBXC4OW8GSxSooV25AExHZo9mgr+QWt/DNsB6xvVjg/f4WXL5/j5naFAMLR0RLL5VLsCcXsK89rxUAtE3EcRQqW+AjzAESD6Q4hinQdtoPGx49gMHzyCqkFFWy3A2LcoNt2SH0NOCpSr9nw2CFqi3NwPoiOq9/NKYN9xuhStSEUhKGBSsm8KRJUtV6vsNZowpRZIzWl3mPoIrrQoeuj1oCUdbGFdw3a8Gp8dU6DtsYR22EArxikxO6DRz/rMZvP0XeCkHLI8Mzw0ZcioVYbwnnJspqUjDdVCSQepqaMmblmLZoxhA6zxQxHR0dYLOaCniAqKqttpLTQu4MRTAADyqPfTdu0c9zdQOBNYwL7vE3Vrb3juNHVgMoAdiel5HVDNkE/m2GxXKLve6yLnq8QEVRy1QlUCnAYkyiIRUG+Bc86hZEKdlF4vG72rHHym80atzcrXJ5f4sWLF1iv15j1Pc6Oj3F0tIT3rkTcjXnEerPFeiOVaZkhtfVGMZ4xudIt2SR+8YA4D+cZPkgrMFJVJDODxoxMCex9Kdc1DCPGrYQ3p8QAKipyTs5HJvlIKzL7AO8CHJm6pJ2LQ0CIUgjEj2ORmpk8nMsg8mB2SCNj2I7YbLZYbzcYRm1xFmIpWmL2GYC0Su8GjgZVw7ScWQjou4guSgBR6IRZzPoZul6QA0BISYyu27RFQoIPHovlEscnx1gul4pktmAO8BHyzM08wNFEyhdGSIqIdK68Mg0XlBnEDscx4MHDh3j0+DEWiyW8j+Ju9Q4lhGkq38o+b1X+3b1tsuL+wQfOOx1vDhMgqzHXGGlw972bN8FmgU1aHjgvIFzds8Px8RIPHj3E8ugIq6tL5I0vemtrfJH8+lAkGUhcX6IKyKyaFb0yARuaSjqOGDZi7Fqv17i5ucbl5RWuLq+w3qwxn89wdnqG4+UCwQdsthvxDIwDNuMGq9UGt5uVwmIIM9EkIhcijo9PcHQkG3hIQnD9bCaJKytDChVqlpLnEyMUlRj6pMyiWvAJVlLNab0BH7UvQ6hx9mLplufPzomv3mVIOrbkK5NjkBOHtZUJs2uaYRPQwigQ3b+LEUQOG024ygSAEzbDgNV6rUlR4vGZdXPELiKpu28+n+Pk+ARHyyPMZzPEEDCfzZAz43Z9i9W1JGWNwwgwsFgsxG5A0qDUwQqdAshqTNS+jJrPWPosemhVaUU5mQBWO0LXRcyWC3zzW9/Ce++/j+XxcfFS8MQzMLVo3UEirzUqZj5EEPvjjWECXt1GxTbjXuPuDwzaeUWoNgHnHfqZx9HRDP08wkcPdgQ0fmVWX3jwkm1WGoQADZNQ/7pGoTnD/lZElBW2bwds1musVivcXAsDuL6+wma7RYwdTo5PsVgswSDcrjdYrdcSJOOADI+RCdsxq/6esRkzbtV7ANpgS4wcZXO7XioHnT58AADgV6+khNmYS369FVYw41iMkkBUKi9r8VJongBlCQryRIgxwHcRIUjxThekhl/0FlQkiiiPCWNisBuleIYLgJd2YJwYia1jkUhb7yOC1wrCKYE5gdRYuVweI8aIi5srDJnhAyFlKdl9tZV5iM5hyCMyAYvgkBhS1z8zun6GGDfIY8Js1mMxm6HvO3jnMGy2uL6+xrhN6q0BZouZLnJCyNKAhR1L/Ucv+ySDkFC7H3loDQcVJCAJqmJHcMosj4+P8fTp23jnnXdxdHwkpgtmMFuact28FW/qW/cY9F6HFvYM6AfGG8EERJq2DOBnPM/eq2pYJNaaAY7Rzxxi9LAQdSkaEiRTzEkEnRjQRA92rRGRsqoHAMBwTlpLZSV+Vuv9OGyVAaxxc32Dq6tr3N7civTyAYv5HF3XI2fGZthgvd4gc9ay6AthTq9e4XazRogdHGQv5tsbDDkjI8MPA4Y8Yh4cHAf03QynDx/Ck8MwSt/F7bBVviXBMM7VqssxRsQuInYdYhfleTXpx5CV6LTKMLo4/R3EuAYL0WWA3CjZmT4UIkhhBCerxyBzGWNE6nqMg6AlM54BjBADlssjPHjwAP1shkSM9TAI4sgZCRDPiIZkY7tF7AbM5gw4KRPezWZ48PAhloslVtc3uF2vYeW3uhixXCy1lsEN6IUaLY1kMgERCGrgIZe1o7HZogQRmNvWe01rVqNrCEHCxQGErsPx6SkeP36Es7NTzGYziWZ0OxZ8okkYsI2fnQXYzm/UjTvGG8EEytg1kgI4YOc8MA75BtpvcZncLnicnp3g6PgIPlip7aC6tCIGR/DBrMG18IYjSDAMVcu3c1KSizIJFFXvg1UQqkUz1sg5aZqqBLqknDGs19hs1hhTwmKxwIMHD3D24AFcDPAx4Pz6AsEHHB0doZvPkSDVaBIzFoslZvM5QowYxhHdrMfR8TEcCIurK/R9h+0mFMImEIILmPUiFWMnOnSMAV0nm1gMn9XiHVw1JMYgVXq7boaui3A+aOt2nV0mDHCSqhwThhAwhojkBmQSCe/JoYsdMJM1GbZbseewGWQdYuywWCywPD5C3/dYrG/R3VwDGt3Zr3vE2EmJMHLIzsF3PcJsDgajZ8bp2SmevvMOjhdLPP/8c7x6+RLXN7cYU8bp8TFmfY/lcokxjdhs1ri5vpYmtORL70TnPZAziDMc57KPxMCJEkBGjsRbof0rhSkEEIBZ3+Otx0/w+MkTHB0dIfpQWqvnXRLfN4l95VHDz+8ebwwTsLDRJjmvfFKegtv3mjdITYVmsi9+lfr0jiSqsO8iHj9+jMePH+Onszk2/hIe3ERwocBl7311BRU9eqpbC1fXFFYk1XeTFvIYmsAf0sq2Hi4EZAbWmzWGUTZhCBGLxQJnDx/g0aNH8DFiyAkfffYJNus1jo6OcHp2htm8x9XVNcacEDW7zqoFG0PI4whrfRW7TkurOSXAiMVsjsV8jtBFYTYlIKr60MUgq9ZxS0byXrL4FDlYB2ept0DqJXHiqoyj2A68FCxJboQnQvBe/PbCUbHSQKY+9vBODLPeaYUfL3M1W0jq8EiA7yJOGRiZsV6twRDV7cGjR1gslxi2A/rZHE/efguPnjzCvJshjSNub2/x8vPnGIYR0Qf0sx7L+QKcGZvtBjxmbDdbxLiV9Y8jAseiGrUCtXXzEUn7uq7rEEMnNhQ4RQYBy8UCb731Fh4/eiT2mlKcRfasw/00eh+Mf53B5sr63WIYJKCoAtQSuj5E6y+tf8nTsTKC+h3LXqsWfVIX0MMHZ3hLOfN1eAFt9geGxrF7Dx+jEsD+1UhfCANwYJdruyr1LuRSNFPcZH3X1wCSzNWPP2wxbLbwS68hvx1C7NAtejx4+ACPHz3GZ88+Q2bG8XKJGDscH59iM2wxsiCO9WqN2EUhgnHAdiUeBefEt85OkoMcpPHFbDYXWBp8DTiBVlKyIh3mcmsZhNoAuhAl79/q+4UIgkNKgoj6EDH6iA15eJJIzeQFKkfvQV0niVApYzbrMWwX6GNEVv++d66EYufMcr/LI9xsViDncXR0jND3GDWwynmH5fJY73+Ls7MzvPuNb+Do+BjEwHyxQN/3JRBLmK6oOMdHR+i2nao/LAVOtexYZoY7SD3VsOogjG0WemVkksQVQ4dZP8NyscTp2RmWS/H+WFtJInFdg6rMatX/JptiAmxfp//A5E6pxrXcNd4YJkAEdQXeAf8nasKhaACbRLO4SoioxRE6kBI4cLRciI724BTnsx45r8FqtSYSe0CIUmaq7cZT7qjohmiCYNoiFsoIIIEuXd/Bgp9SysjDCNaWVE6v571HyknzAgb4HDGfz/Hee++VjspXV1eQnokBztV6fUSE0xPRN6V6j7RdDz5i1jMIvaYXExb9DPOZWNJBUlJcbBtG5FbA0yn8V/uBSjZDBFKKS1UFH0FMGJGAxBiVOZgakVNEjgljHJCTlAazsuTjMMCRw7jdijdFS4KFEDVxKMMHYXCrccBmOyB0AcujY7XmK2NNYu84PjrGe++9hydP3oLzHsNqLfERIWB5dATvHGLX6Z4jdFqdKHOW6kIWNt6IlGID0nVv1SXSIi+WDh29qAHRBywXS/E6OKcl1a2wqAom5xvDoJ2zAmFjAxOKuAMZWGxLe38T+njjDYPlH/s99fgfvn/ee7UbNyhBEjKrxMYVgS4GPHgoaODl6Se4TRkYJYkmaCCRbfgSSmwMps3AQ9Ogoq6ccm8xGHazDjwGWN2BEEV/7FNfzgE1wME5bLYbrNYrQCXxgwcPMY4ZH330U1xf3QBZ8hNGlsSfWeyxnC/x4MEZutBhs1mDE4vu2c+QQlAY7tCFgL7TMFrvpKcAZUUMUcp1aTHMYAbA3uC/GhJjhy5EqfbjA4IPwgS1P0ryuQTNdF3E0HeFKXYaWp2sO7TGacSuk8AmDRWWCjwSLel8AKukXw0D0s01cuJavKOxAy2Pj/HeN97D07eeIsaI7XqN7SBxBfPlAm+/87aEQQMl/8JSvAHNwAyh3BeAJkiMytYkJTj7MXWsix260MFDbCnxaInFYontdovry0uQ9+iPFiAijBq0ZgbmEkG8q/LSDkQoNEF3vm7zaFrmcNd4I5gAgCrAgeYPi3Iwh8yBLwGw7rplQ3D1CrDj0oVIaRgEYDmf4/TkFCfHx+DbNbarFZAUEsegsFg3uIWHGiOw2tflxu0+zbwrDxOCh0OH7LVOIEGjD+u0mw7OmkTinMO4HbCitQabBBwfn+Ctt57i8uISw2arTJPgokff9ZhrUMw4SlFPHhkO2gxVN3EXxCDYxYigQVDsZH5CEMNg38+U0IX4Q4yFKcj7fU3YiR0CaYFSWIae1PO3kuBdjBj6iJRG+DGg73s4eKmNmHJRPXwI2MSIjVZjlnNIOJZzHpmA+XyOR/4xlsfHovIkbVCq2ZPL5REePXqEx48eIoZQWrwF70GzGR44Dz6WmABOuRRstbLotgFdYQRNiLCqR6Lv7xjaiAqNOtJIVAjhdl2H+WwGzhmr1QrdfI4w6xFU3HNT7aigg8nPnv47GV9E3Mw7pHTHeHOYAFCTJ3BI+k/RQUt0xgDqd3j6jYYpUAbGMUmFl5TE2BUC2HuwVt7tm4aREmevTqGcJXXU1A0ye7GNysotlhweKCm3JR7fimNSMUDKl2pGXtbEmVH1ubOTM8z7uagS6orMmmzFibFdaRlzLUue1RvgnFYTDlZKW8J8nfdwnkABCDGgjx36rnEZavadpUCbxTv6AF/yCLzGGOiWZUJKQZ+JavhsjOiSdSMe4YcBY0pwKQNOOypxLqyVB60SnBJ4swW8E7fhfIGjoyOxrDe549Jyfonl0RKzrpd1YpZ7jCSFV2JE1t4PnBX6q11GGqJIanjWsGtLmrIipo48rBS5JOhP962lhNd8FIkhiN4jOA9HJOXTtwNcsJqVhhoLzijqQDvoLi5wz7CcGDHY3m9HeIOYQG64gEn4HTbWZF1V1FB/lQip9nulaWk9x/p2hZcvXuLm+gZgzaILAcQZseukX2HfVZVAvRaSa+DhyKSdnC9na1CiqIG0WYlPYuf0VGCnZC3WfnVthh1crVhj7csyGWmIjs7spExY2iJvBwyjZg4OA9Jo6cmSrOK0EYkUt3QlvNf89z46+OgQQ0AfY8k2DNGqEKtEVGu414Qap3mXbcUiVrTlWpeqEzQUOtHvyYnXgjzBjWI4ZTDCMCJo9Z0M7eunWZEpJbAjjOMAnzqETuIT+ij9Bp0XO0bsOgQXtKtaLqDMjHBMDuQZzF4IPQTEvpMchmHAZthKQpWTtbOCo86JymM/3onHoxaZoQLZyTmEEDWc2+ucqZvVCTpJg9hF2NP9xE1NaPzPPMy6cf94LSZARP8WgH8EwDNm/q/oew8hfQe+DSke8keY+RXJrvjXAfz3ANwC+KeZ+a+91v0qtLbIQZPnDVPDxFcDNFAcTdVlbk7aMAYG0phwdXmJy4sLpHEsSKAwAe1LEKxRpQVxqDuImDWuQFQUzhYwFOC9VKslM67lALjcZORZmrFGIqLGGhjHLopFymCWVF+2UuYpYdwMGLVxiZUut5Za0gcRKrVq/n2IIvXFKBalNbZF/wVX+g50nW7gkqUnf5PzZcNO069LWnuZbYLVYFDbSs6I6i0xKziIQC6DkrQ375IiLLWLCLojDMxFdZCciizMQI2Uo6ouHILQ/ZhB0cqDa3B3zqWqDhFJtCNUz3di++/SiE4bouTMmoJsapB4Q8wA6oMyA2+MXw3DnOG8x2wuwV7Be/RRgqI8EdJ2ABxJD8LdLWzzggM03xgKv9xQsTgRiofH6yKBfxvA/xHAn2/e+xMA/lNm/tNE9Cf09b8IqTn4q/rzByGFR//gF90vKeSuOrbBoMN6ER14j6efYvclE7AdBlxeXGAcBvQxYjGfg1cbUEoAUUnKmSSLwDLgBG14ApgjLK2YmcEhwwUJ8AkaD5/VCCHQ2TaLGZkIpce5VobIjTRk1F4JOTOQJANxu9lgu9kAWlC0pP+62jyFnJM6fqoG+ODggtgI+r7HfD6XqkPBwXm1gzgp6Nkp4UtEYYfgO4XAxgQaHzm0zgEIybwwVJNqQsiIev/JmABUNrksFZ41cAYWpu29Ig5XErSyGYwIpS5jHkfpAqyVjHlkpBDBo9fn0mxASwjTyEcrglLay5HYY2LfS7nwnIqaZhGRIYohNKjR0Aepcux87UzFWWIqutlMyod5j0UfMO9nGIcB11dX6PIcs+VC40zafTzdr9z8O7EN/AzDjOH3ReG+FhNg5v8nEX175+0/DOAf1L//HID/B4QJ/GEAf55FEfkrRHRG07qDd9xsyx5FpJvltM4BT40dsL+p1hUo+k8JP5Jvkmye7bDF7e0tmBmL+Rx5uQStt4gEUNdpZ56uwHVLoPFwIMdSDYYAnzPAvlbpyVkyx1T6meQDsxbj8M2CkhqoWH7s2SABTcIIWBtcaj8A9V5AUYn3opeTSdbGvmC1DC38OUT56bRf32ym3YccFSTl1SXYd/KZuPekrHfxjphGBRTfszADB4K2UoMijuDBOZSMv8ixbGsp1KEp2D4UG4VJVaexHZ6k4UjK1tNPJW+jQlnijjBVtSNwhstcz+mECVIpquJV8FiNCEFNsbPqw2K/kMIkFh4ttg0Kmiyk6pUUNNV06eAwm3fIg8QEHM17EDNub1YAMY6CU6QkfQ5z2e8NrZXdu28F+zKjtQMQVaRxaHwVm8DThrA/BfBU//4GgJ80x/1U37uXCdio9e0AUQUqEyjujsZ4MiV8M4jQnjlAlpZLIwzmXGLI3WZE773UmI8Cl2XzoxCYNCIRazpGMTa1g3OGHxO8H5FVithdWi69PSHBaUFIRna5GJVa7EPWXiYp1PceERL223cSdxC0PFot4TWtmmMtxqL2wYt9VOu+ltxSTwcjSzRh1wkTCOId8aGpp9A0PSFmqZrEUodfHs0J8ag9IJBDdh6jl4YbXdnS0g5IOj/J2oWYxBin0XZOGUz0HjFmpCwqgVV58l7zPEwpUfThyIEp16IaBLWD+Gr1V2Zp2aFUDL1leYTxKqPtNNZBbCQe8FazoNZ9MFQaYkA/m8FlOW/nHDbrFVa3N9KL0EmVJ+ccvH4vFdZYY1om++p1iOYrjp+LYZCZme6vDb43qOk78PS9b8D6DpKqBnrmyc8kyYMqTKqW0Gr/K0YFPSe85ATACQQdtgN4GOC9w2I2Q+cceiLEPmKurjJx/2SAakoxsQN7wGkbc+cFFWQfEMKIHDw4BSBq0YhsWIQK9PMQwmLN5zedFzmDtEKREQg7a1YKOafp4kb4ZBWQ2iAUDXsOoTAB28QhChEJ0hEmAFiiUCw9+QoDMC+GeRbsGsWoqQU1NduQidQmIXYTnz2CS8ghSJptNou1ojSW+TPjWXAeK5IgqjQExJBKt2MqzM3VBrHWDESRI7v6PF4lNSnRBiV+k+Au1HgAEzAmZKDRksGMq2oPMJWllaysxpEQAmbzGTqSZx1vrrFarZCGAYvFAovFHF3fa8h5LTRfi+HUfVyMjV+GqJqxKxzvwxRfhQl8ZjCfiN4B8Ezf/wjA+81x7+l7k9H2Hfh9v/b3qL2oySQsxwEwnbA8UzVTFZVBjy1IQD8vcMARHDH6XnTh29UttlcrdBmYwWHezzHvNK69l2YXk557heM7LaknUXvZ+gaQ04afUrvQh6D9BDUjj6Blu6S+viPJPKSUkNwobaqZJX1Xr8P6GgCcdusKSiBW4wBAcT1CDYuSpWeEL0U3g7fqSJb7QJpaLBI0qMWcfCzw3Icmb0DzAFzwhRgthTaprx7k4QnImmAlElqyMqMukzQWdQ0zYHh2yGoH8I4QyCE6j+12gzQkZDJIS8V+pDANVDoC6V4g1kpGXm0kdZ4sScxQUuvOK/vKkJ+XZiZB0ZS1OyOdk+RL68lifCOSDMWcvTQbGUZsVms45zCfzdDHriLZhpna/mp3tj3TLhR4nVyCNqKxvHfP8V+FCfxHAP4pAH9af/+Hzfu/QUT/HsQgePFF9oBW77c6dbIgKhO9fjhB4DRhFvWBd5gAqFilmQndrEPfdwAzbm+usdkmUDfH/PhIqtF0Edlp1xfbQE4NdTAjoUoDBhhJpJ/CdUdeUmdzkjRZKwkOK19XaxI5rsE1FhzDZSPKXDgWovWZyhNJCLTeD9k51VbgNAw5WOiur66+gqi0g46ms5auPhoS7NUmEIIQujcDow8qxXwxDO6qYlZgpWx05+DYwTOQPQukBiFpgfysKEJaEwQJb9agm3EQo9qoRUesbZjAdSjhhQlBeW8QnUqhU+PgYgOxCsi677jeq20yJifMUm0Cplb5IIZAOILXnIvMZh8h8cB4DwqMzVYqSaVxFIMxOwQmhEE6P2Xv1fZAdbvy5M+y3obwftYhQuhuNvC6LsJ/F8A/COAxEf0UwP8KQvz/PhH9swA+APBH9PC/BHEPfh/iIvxjX/KWm8wng2iNgm8girlA/8rslQGw6VhCvAaNMoCuC1gs51jO57hxDtvNLbYjg+YLtYw7DKhNQKokkWISoaggDlKFRsNOiUDBw7PEyiNnpCEhDNKBN6dc0Ev519w3bAjIF4miDynHMoqxrGwStq8TyNfwV5NaXguitHEIbIoyqd+ctI6DI4W5DhSc+PEDSXHOoocr8TiVxI6k+InTJiGOIX0MMshlBDN+kebKOSmikYL2A0oC8WGhv2rAC9GILmiNQCmUmlIqjVYSS8OX4roka3hCGtcgc9QyAUFvVJ7fpt+YYlkTRVXSmMYVBmjlwkSdhKojZhvRWgPKSClkcB5LWzgMCbwdwEMCxgw3iBE52/Lrbp1ikmoY/CoMoIx7AoZe1zvwR+/46A8dOJYB/E9e68bKMFuA/F1krq1mrseUbxBbCz+9LibFFK3xJZfzWQCNw3zR43gxw03XiStv3MLlrOW1CSKsFG6yIBJrMpHIym95yTNPGjSkdgzHAHux7HuvkWkhSnMPvadSOY9b5GPPReV5LJxVEEH9jm0Qg6/OSTqrUxuAD2pFh8Fk1TkzACaF0xrF6LjYO8ziDXNn6g403d9Kfttv8hp6bIZNZd5EVNqa5cxgb8QOxHLvkGcjrToEwAXV8lmu4ccAP0qBjjFJefJh2IKSKwwQGn9vVaJLZx+gBDoZIzc5UbXKCv9NRTKjqm/yRywXQiI6XSOdCXC2DyXWQWwQYlgFoZROkxb1ggqzxS00671H6rT3zmuPfWP5/ce/ORGDReAqR1foDbQb3g5mY7x7uk4TO6SIoDacJIiBre97zPoesy5i5Rxcqr525wgIrqmyO5Ue9rcjcW/5KGgg51zEMxtHUtdgCAE5ib/cODtBGBUXpbLqcmx/cy4tvu1ZDBHYvZToPNXXQ9Bw4AMrz1qE0cqry57mEkloLjgrrFks7GZM85JXEYpO3UpQJcisBVc8wWcP5xIoV6bjvW46VqOrXiRDY4VMhWMplOqTSP8wJjgv1YVoGGS+zaWoKIVh9R7ledtaiS2ktudivW9jAmZI9JZAZTEBvulLCTK9rjy76O7GkAnwTsqYeS92Gm00YwbgbNKLXHNPuXD3cuafgQu09oDXTTt+M5gATf8o0XR7s9DIQDIJ3ww+dOT0tSNIssysR9D8AKcBIhJV5wHHWmH3EECrUicQQBSRydVimaytxaQfNdgBvghKIcIiq+xYrjEBgEkPu2QTK8DcqAXKjFzjGoxOCXQ/MkS6Jsl5TW9vbIt1+kxyqh3EhvUfaF1rRPVcmSF9R/W4DGEuoKZqkK6bMC3AMYO1lp8jgLIQoy0qZ4ZnRQLjoCqLMCQLPoIz3d8DmgouPdtccc1aP8ndrSS2olo+zgjeXKRmPLQKU1MGoEFODeO2yFJHUkBm1s9w7RxyBpJ2U0rDiJRHWAymAyORCKEWEdZkuL2l3BtVFX49ot8dbwQTqLAVhWNPye8wS7zTXGIcdTKvqncREKO2sdL0WErV3SZRZNW6XaUy29qrdDSsIi3JLD9eegxkCWPNgggIjRWaAbTMQs/NDSNILLEDph6hCRpybEVPa2yAC5b04mpwD+rl5Px5Ih1I9WQjhqx9cdhEUfP87TBGJoVYjNnIhLeIzYPES6DfMQYz0U2JdH70P5Pswl0K47TOR17LwPkQpXoTV8ZJanuQZ5fYBW/Rk9YNZoIFqDynxQ74UkHZVSaiKEsXo6x/eQpTQ80zo/MWQsB8PkcMEUPaIGu7tVHTpX1hWDvz2q5bM7v3Dd7b6xURvM54I5gAUCEyjBmUJmstvkchBgBoq/6U8+wwRCIVyuVD8eeKl2COfr4A81oMYiVUWH+X1dZ7mBgl9JdzWsTX/PoMsANlSMx6RjlnGXmfCQCiLmSWclb2CK2R0CLyHKEUuXSNy8uYglmcGdr1l8UoBwBkeQZFy2nP3xCsPTWL4a/dUtnUnsxahVd1fk4AarDXZOVayz6zwt9cbCnETuwvEFVChIHMmfMOlBxcVi9FGjGmhKBl3EruBJQtUYs4XEFubUxAtQeoIbB4UbRvIcxWonaAlrE2S2mCy7w6jiRWIjiPWT9D6AKGzVaaraqhM41J3AqUbZKxO8o2fk0B/2UrDrXjzWECZJJJH4YKGsZ0FurfGQy3xycL+TQn11fKWIKW8eoXPebLOXIm7UjkNRNQCb6By0WGEITQ7X1SROKp6nMMMXb5htAriNequaxJQlw2gaiQXEKOi1ELNhdcg4XKJgasV96krx40Gs1p2zVlRmjRQNGfK4MzwufEEoej0ylSsdYflIO5FMu0ZTKvTWaWlGZN3UV5ei6luyxs1ozAxMbAauainNa8GxJhSd7DsfRTxLgFqQsWgAaa1cAfS502tFkPpELkUlhWsgYt6CrrORyRRifK37nOUtlcwjDEW8Ak1Y7NuyJMBfW5cypekWK8xf4wF6hM6oEDvmDsIoP7xhvDBNonvRf+UJ2byRdYERs3bzXHOABJP3ZBUk9j32M2n4GzQz+bqwuIYE0y2vtgNcsX9GGb14iC62YGSOvVQWvpm07vUOjOsVjCGltAkfYW277DBOSHK+HDiGRa6cbuu3ynMAsgc42bmJ7PF4lHjUg1Hd9QUgk0snllOWeBxFafb8xiDU+DqCJaM4FHacySU0aJvXCu9HuoTU8MqhhCFCOb9x7ICVAPASPC2snV+df1a841mUt77fUYbTFGTiIRDdbbHBvTtT1hlYQoq3u03Zus2cVwmpZd07ENCRXXL0iPZ1Q2VjVGuEYY4fVHuT+qf993hjeQCRxmXxOJWE2oE4QuAs1YoKYjqyGNG+LwwcP3Wj6r6+E4YL6cw8XQbDpzU9a7annPJIaALMGIysKaGsDOV+6vQ/POQA57DKDq7FBU0hI2F3uC6asiKBpGsjtnE0WxQkwLxBJkLPdukYFOw3crnK5/7wAseR6CtGpvJssuK0VJACaJLLS5y1m6DzE5OEhizwTGN+eTWgTyeWZIXwAaAQSd+1jWZteKUaS57Z/GPkDq+jQE1WaOGt0YAij3opMorIZ1DtXmYhdVAu5jh8V8ie3tRsuRuzKPBEjymc5k1cpqfkxh1JNNbmu5s96NWre3B8AgHDiHjjeICeyKd33XFqy+2Plc4W37kdUXZ6BGSmkqMIuOGbWEmO8iOoroZ3OE4DFaeWkG0ATGFLhc9ObKBMiuqRvOgeS7WYubkoiI6g6s5dJsgWvabJ0NkWTa5QhKJMVI6QoxmacAPGUGjqHwKGtkW24MhIKLLMTYmqEEtbYHK0vmo4QgOy0kolNNGuRj8txcX0k7EucsNRb6HhgzIzGDWKrt+pRFN04ZCQnB1Q6+h4Yx4CJqiQDn4QIQFZllqL+euRjwS4JQu1+M2ZQs0Yb4dd0qXLPvyHGtB8eSlLjZt7K0goaQgRAjlsdHGNYbBHVBeucL4rR1Rm1f29yvNivVp58+hdl4WgZ/H/a/H0e8OUygEHv1l5a3oTRIVfecfLVZ6PLVhhHI+zKZptNZaW/fRXSe4KNIFSNwNNepeqqgi1zOp4dp+K3cox7b3L8EHLWP6hrY2BxHNfKtHmyRfbppJutumy8XJlkDjKC2CY1fyALDxzxWl5j3iFFKY8/6mWS46T3Zpg3ae9C1upYSveQ2CFrJnIrBrUg2AhwFeKoqUUBATBnbwZUEKhDgIcVYiLJs8F2GX1AtVXRkaEgPIIcSJFbQ0y4TIJJ8iUbqW3zE7uVkGzUrpHEWnMX1W+fabDsSMclcU5H7XrofiyoTStkyr8bHcmqyiM6djX+AgL+sEXAPEe6MN4MJGKo+BPN3dH/i3benOhkK/IcygmYamZUBE0LvEWZBKwgB5F1N6yzQr/JhUw0IJfIf9ZVdv8JIwD6iek/M8nfDAKwIqlPDnlO/HdvVZc9WOMtc4IL53nNuNkpBKqm4nQy9ZG2RlonQ98oAul7Sh618FpkRDOKTVyJjTDdf1qAgR8oEweWehUDqBApzc6riirF0uw24zcCwkcAfhyBpyRDCzExlZh2oJA3J9aq1v3iKwGKQa0AhTe7bslCboihmN9hRIibk0tgWJu836lsbx6F+D+lXQNKGrJv3UiVaczi8DxObR70UoYgXMuLF/riHBxyiddknbzoTgG5cMi7OOFQF4R7muH/QZDbaL0hCkg9eimr2AW6TKyKjSnD23apQTOQ2JJGGmyN3rmUMwaCfEq+nahUurj6DpQY9dU5AUk+/nFVjD8CMzKomABq6K3xIUGlzN6zuR63A46PUO+i7HrNuhj5EZQBN6TBXg7YmgythlUQeyHJlldRElSUIwpbEKtb7TyFKDcfokdcZaZsk9dgFYYRMYCZkrWYonN9yAiQzkbwr6pVBc6t/1DbxbJlAi+zsvxbf7D2kSVBT5dDYBorrNZe5aJkOA0jMcIoGmBmhj5rGLeipZfd3jVamlPecKx6X/fEluQbeICZQRwOHjCjRvFUMhIcejEp7ctpRmVQUlxM6bw1GHGisOh4MHpIRYfmgSkJShsBmWEOFh1SvUfKeiGqX7mxIgpQ41EBVGIEF+8gGy2ApTYZ2M2t3nFKyq33YCkOYpWYeZ0ir9CTQ29p+zWIvpcN9rMFPpmtmzVSU/tvQLmvarITE0MmMzAkIVNq41TgATO+p/EkIwWGmZc5ubm+x0QrJoxdmUJrTqlT1ILWFKBJQ6Vx2DDOSPrbHDhPgJs6hrF9lvGbToQaKS7HT+jcU9RSGYugK9TeUmMX9KSqNyxnOO4S+AzKL+hlCYULKC0CYMpA6dabEHtjpLSMg9QQ0xue9cc9HbwwTsAmxoUxfJZE9QZV2B6eG2z8a7N6c1KCatxbbPoD8WL7FmmZqRrldRlClhAoJ2l+oquspw/KykSV5p2UCTsNxfXG9TYJSrPkp2tNpkZEkKa9SdISQ7Px6q5wZKbPkLKSEnKQngempVkvQkS/eDMm0rMZDSgR4rSCk/u6ULFJPjH85J2QnEs8adFqH4WxMlyEcUI2bjgh91+FouZSiG2pUzGMCO/EYMBJYayYacRiDMm9GWfKMaoNAg9hYGGBFhzRdl2LsNYo2tQZilNO9k6CMhcWin7mGiBeOoKfOLNWrBBTp+sYIYmiCWq1j4ALBca5fL4ij7rH7YG/LCIqAOHzkvXjjjWACiiJRmTsXGj4o8e9ij/rhDpqvc+Og2WxajSd4+OjBm9G0Wf2O0wkW1aSCd5FGkrvSVEEGDtgq9P4bg9PEfahQV0pN7Ue1AcZ76tUBgDVJhx2JhC+Gw0bY2qbOKFb7rGXKQozotZgqAKSkbcPJaEP0R9OZcyLk5JGDVA4CcymUIkxgQAKDgtOipnLeGgbb4DhlEladp+ukM/AwDNhupYZiSqkx9oldAoXRMiyQSDaILoBTHRzCBJ0uRKuOoL2VyW6x31yhvDJ4mGR1hiQapFMQj0FVKnsgjaPUSHBamiwErVKtuR07CVp1cau8aYATGra2ZxS0GAlRT/afr7Wb3DXeCCYgg3f+LuwRB5/ujlG5e9UjZG/LOZwziUml01ByQ3X/cM0LsPJXlSlToXaxAxlqqBthejPQvVp1azEEaogs1SpBh3zB8l7VWuteqZKsZM2ZCpFzMRsgM3jMSGNGyrJhrJQ2kfRFFEnSmsZk7iUZzmF0hK0TO4aHNFNNmt9vOnEmBoWA2EkNvVbCipRTDm8ZfyEAWt15Pp9jvdlgHG+lrPg4FGZkD239AVvtYmKrIII5GB146kGxudurIoRqWOUplOay4DpyE0pdGIDp5MqYgFKzIAPIYwZ3QtVOmacLku5NQass7wo4ZfotorMb2qeAw0Rf3qJG/rWC8MB4w5iA7F7Z02bRnC7c4efZlb9T1UIOEdFIEAMVESN4qbCTSJqR5sSVzhsDkKgVNdHFNdcxMVwlqb1tb8iiFmlhej+EqCwybff+7U8CGh27nSklXGUyzgPIQOLqWWBtk56s7Vf0JcHIahqmJHNTJbc0BBGUQqUKjzPka92Wx7GoQ5kAigPGJBl/rsQwWBMQqjH4ComhBURiDJjPZlivNxg2I9KYSgi0lDrHlFhYS7B5Uex22AGgAThVUtseOgAfWylpTHR6QN06qKyY9b2aGF4hvdOIwyFnzNAiNEL2DjnI7zaVxEYmKg1KK9O5C/TyPiEUgdDer/19t1rxhUyADjce+d8B+O8D2AL4AYA/xsznJGXJfwvA7+jX/woz//NfdI3mTqvELd4BE2vlju7QcLjCwwY9cHMONlVBcD585+G7gOyVc3PWXnMMztLJJ+csNfEB1UmhxFkrHoiUIjGPu0r41EDFou+oEcdRVmmgAXD6ZHbfRTZrFUvpW8cwazjI8pAYTBlJfaHZZ2ROGGnAkLcY8gZD3iBzRu8lR55zVhSQQJy0Nn+NepMiKg45q+HSJpIhdf5zrsFYWrcwjxkjj+CUJ0iAjEEmMeY5F5C9xgSA4agrYdzjII1CREIrUap9gaBVg4wCE0AuV8ZLVj2qJf5mb9j9UC1Pb4ZdBiq1asARTb9aGHF1hNqH1b/PUMblXJHA5vJkQmGEaCB/YTAN1Hk93CuMZOIlaEhm8voeBgC8HhL4t7HfeOQvA/iTzDwS0f8GwJ+E9BwAgB8w86+9xnmbUTd+8UrzDpyh3WObVwUXNYxgAhkal1WJyZPiEU6ZwEgZYCkSWny+LUQ063DBAcYAGlZgjKCBBTvOQNW1GeR0AzX353gqHqZG0fYDOb/orlp4RNWZrAE4pQyXMjPbdqzNOmTalKBZPAfDMJZc+DY81rWOtJz1WknPEco6MADWepBWScn7uqpAgvMMz3IfI2e4lCSaEMJ8BHKYTOZSm8Gs6PsbmpTn1z1g935o2HFZ17glmKLfK1FXBtBsscm16p3aZ8bvoaqeC94Oa9KSlfk3aCU3jOHwqAFn0+tr/QRgUnWKi5FRv30Aedj4QibABxqPMPN/0rz8KwD+sS86zxeN0kKMpst8Pw+zh24ldHOfCu0nIQcWRUiaouqp+rhhv6kaKnM9f51TKjC8+pzLVffuvgYW2QMyUNldOdLcb3a+aZBHA1uZYf7GTFPTac5avCKnpuOuGsfUAp9Uh83jiO36FjfX17i6usLtegVPHscnxzheHmM2m6NThsBs9gbrFqjXwwhKYqRkpzENzmmWMIFHxmZYSa+HLJGaXT+TPI0xgEJCBoGTVCzO8uDCaNS4US3xh3ZDff9uA9hEiky+OZHIjEloMFD/ttB0uQ1ZoTK3hvbsalTTmGvSEmpkoqkebNiiuYcDPG5X5WmNfYIG7njsCeO64xj8fGwC/wykJ6GN7xDR/xfAJYD/BTP/vw59iZq+A2+//43dTxWuGcHczwoO2NSaD5ULEFBhorrq1ENArt0kNZrMQTZ2Vo6wG0REe/p8e68tG959vzWYmeQzhlEh59556pXlCLufRkKwFiThZBK7XjnnjHEYina1Xa9w/uI5Pv3kY3z62Wc4Pz/HOCQcHR/jrSdP8e677+DRo0dYzBfqqtONp1LGYLUxzJRIkAUJElitV7i4vMD5+QVubm7gnMPp6SkePnqMo9MTdLMZfOykKEtTdw8MKcKhzn8r32bxGwWGo/pOStAOQbl+y16pSoL2o0bllEpnreW/zn1Zj7qVSvbgIeLyk7JkTbDZruGo7Ibp67rOd4/7rf5cImUnKOWO8ZWYABH9zwGMAP4dfesTAN9k5hdE9PcB+A+I6Pcz8+XebTZ9B/6uv/cPcNlMaObJOOyX62tS76/8q0CeSFM25RPnSC22tZsMIJV4S5kr5lIoohwCTEi6LPNkoqnsP2hpaQsCEsq0LVxDRWqMd1s6bfrshxa+ShJVCRqrvGX4gVkrII+S/MOM1c0tLl+d4+XnL/D5p5/jxYsXuLm9hXcen559gpcvXuDb3/42nr71NhaLuVYCVrivabQi9QhOiWi72WCz3eDq6gqffvopPvr4I7x69QqbzQZ9P8Nbbz3BN9//Jt5+910cP3iAbsaA81IGlqtElzp8SewnySG5BMpOi7fofGWS2g4ljrpBhTu7YDJvPCVek8elOhTz5PgJIe3JpOmJiAg+RHRAiZsAoCnqrthIqvBu9vcXwd72qveRBO8wgC8YPzMTIKJ/GmIw/EOsM8bMGwAb/fs/J6IfAPg7APzma51TJ9h8o80nd0/QQffJXffcMJgMNVRZ7z4Ce4XtahgrwlZvTGXOlJnrPZe9YcdPEKguNO3G9tlmU6QBFmZzaAPqs9qbrcXayMAYQbkNkhJb7MSwiCwSOlky0WZAHsUY2vmAzkdsyCGNI9arNa4vr3B9dY3T5a0YFEEI7Au8LMhKxWPmjO12wPXNDT5//hwffPghfvLTn+Dm+gZEhMV8gRgCTo5PcHxyin6+gHdBqgxbR6EG/gqqcU2GYtKwZoiBDaiMINsamNn4APwvYrcaBOvPjv/f7EK6ccgQRgEUdwfghGg9D0tIIKzjUX2PwK7hKncIurv5Qos0K95vmRe1h/681QEi+ocB/M8A/LeY+bZ5/wmAl8yciOiXIJ2Jf/ha52x/FyhmwRj8+mztrpPz9E8GAIdJA08JaAswCm4tz0bUh8B/+U2t7tbAdb0iWWgb1XftL2KGmiUnVoBJGXWgfkp2jw2k1fctM847aYQh6DBpPCwjIyElaXc263ucHJ1gHBJiiDg9OYX3HsfHJ3jw8BEenJxpteSMcav9E/w05JazOBYNIsfYYblY4uzsAW5vV5h1kkU3n81wfHSCvpuJepHEy+CJQM6LR6KdWEAMmRrs5FzWhrCWLkxlTTLZzOwTQzvs7bZkmu20ekwbB4CKMBq16yDhGRJwVicRkg9DTnpSaLQg1A6lKz/ZKzui7+C+3320+1SDdgfeNV7HRXio8cifBNAD+Mu6Cc0V+N8E8C8R0QDZcv88M7/8omvcj4O+CvU3ZzcOTlr9Vptu+KidZZy1mZY0FNZjJ8K8RfhUmQmhURUOo9EGHSg8bY4THiduMHXSYdeYawzANnrxSdj57F9jAqThyHp/mQh5rLn+nDOc9zhaLOEfE5aLJbaPB2TO6Loe88UCsetL7X0wNEgowwVr6qlFPHU+AWGqs36Ghw8foe/nePrkKW5ubjBstyCS4KCTk1PMuhkcaq/G4D1Yk4xMH89FXJthksG+RjOCxLZTiNhocWLYm85jbo4pRxGmCODOPcd7xjtTvwAUv5Ex48zC3L3WpZA+Da6pRaA/e0Kh2TZfgOu/KBpw74QHxut4Bw41Hvk37zj2LwD4C693V9NhNgE9089yivvPr/DNOeWaDEECwSN0AS56cJLCF5wV+FsdAGUABb019zdB/XrvlThbrAA9J2v9/7vDNyxxpr3cboASG/63axmDIWiVIM1RI/HPZxBG7e5ruq9zDn42Q9d1ODo+kbbeWXVZLQdWnlLFEmdGGqHHsbblcuXemAQR+djj5LTDyfFJrbmvcfJSp6CT44tdwcGFCLY5Yo1l4Fz0/GpXaSa/nX9Cceu2jKDNq5moMXbPXNWBnTM2aG46polSMjJElWvdq17PQQQJFS6uZnUN6lrv1ggpz2s3OHm/PsvumORDHPjOofEGRQxWaFcgTHGR7eDw1z3fzkvZcIrkVM8vZbo9qctV9bVGZ7TY80nRGas6ZMS+Zwcw45yqAGyQc1/SlO1IO+pFsVIbOuDJtyxijZyDh0digLLAUQ4BINGpXRbnY04ZGLSsVa7dkMhL6zLSqEmFQdW+QJZVKdcloAbtFOlpUMnUFK6MJgRYIJQVGSUztmr5shAifNeV6+aUQSSNR6w6U+uJEVVJkI9J3ik8bwKBUAlmSrz7/x4cu3tvDy3o/miJk5QgnSEWcw8WcDN5lt2rH4LxtHcE30n0kyOdU1ZzeLwRTMC0ISGERr+yB/vSDEBP0L5i45K6QfW8pB1jCre2zdl8ncikUCG7ZpGmEr1B/CiaZlEhm0XbW3qa/MWTncJgOOT2SgRpRGLcw2lGoXP1e8Z8ckYC4FIq0WwjWxARlTRmQP30hGKFL7CbnJZnayiLeMfKbenQKn3Nys81xsCKkYQY4LRzsrcOyjGCvJdKxeMo8Rs6v5ZUZBAbzNb+cHf6ynrvs9rdv6oqUZmFMT7aO7aszc7rKTihwgy8D6WcGZzXYq610KvZEKrtafdiTem8HVJ4bTWgOddd441gAkCFzzb17Stgb0V/hgtAoL5yYqM08tJ5yDr07s2VQewdlGK3BUJrNG7Yw/TibalHnvyeMhG2m929Ftr71usQIDn21LgENequGJoI1rTRjSNccKDkwTlploCk6Gr5jqYmYi2/5dTI6AAtn2U5+rmWxi7ZcTpXWY8lgDX9dlQjn9fQWh8CfJSCryFGxC6CnBfCd07tmDwhhOoGzQDvFJy/Y59PAn6+zCDaWRtbnRrpeTDxy5CB80UNKF2MDLnoXDca3h6b2r3bA8rKPbc+Peq+J3+DmAA3+s+UG39VDiDSuEKxdhadl0QW7z0GGiUjjtvv1WI+tlBkTGkiAqyt1270oC10E9nHbHj68P1ydSXub/KG3SjjNJRDTojZIkmNaTFpgYsQ4GKE5yyhuwQktiKkFfEYGvJNlWGvLjweJTcBOVWu6R2gDUoltTUDxLV/jCYEeY2Ndd4jdFLf0UX90cYf5H2Z/5yDxgykKj0hjMG1hrwyL/tss1UDbOp3ZXnJU2g/oZ3p1iOrC5aqpJ4MQ05U8xGsZLvVQGCUEmymOrSCye6wrN/kifQqNFUpvsp4M5jAnaxtjwy+0qgTSI01W+rDx77DuM6SEjX5TkUncjeHJb0Kz/IaRfa3m9O4iFFdc3zLYOzb7Q5oj52+Ue+CSDacRloWFkoAsrYrixEBEo+AgZDHsTZTLZCHRK3wNevP+iswxLZQ2okQgTTgynmpoZeZtTdAAmfJO3BgeEQ4aGnzLsLFDvBei6O40hdQmFtA6AAQSUff0jmpGssmBAmdV529qaa9j7XqbO6s8Bdst12ibEfW+yvt4LXYrXSJEpVq9y5al+/u3R5EOQUU33cnX268GUwAxo/3H8rq1f28rjJhpQBcIHRdQNd32PoBiSzeclejrCoJ7ayObUyafNbA8ck7kIWkVqJUdtcG+wCafTY5V6MqlH3eeiQaCdYawYgA7+EiwyMIMZM2TkqpRhsV15tTCS/Mw9KfJbdiFI9ABuBJKuhqC3ZyGuyUVQVy1idB4LH0FJSaAi4ESGAWSkciB5R6iwHSOcgBoFTzIAqjMgPjzkq1870LrHcl6K5NYMI4DjCE+xiAXUBSuzXM3FPtoagFUqwUmhUvERVVRYzedGVsdnBjFOC6X34e441hAqhqrIzDa/DVLlGMPs21SCK8+r7Hyq+RDabX1QBVapvcXNudd3cIueq/RDUNeXIDtkUPN4fYf79hKHpdiTHwYM7a6pxh1jJp1AEwWZANiguPnaKG4OEBZO2irDmvYE8CWT1pP/Gg12UwezEasujuFAJciKAYJG4gZ3CSkmpmQxCkpIgiOHUtCpGw0/sxLupkvjwBhJqlaK5N0dXvIVKqDKCCM9I5MWcx71F0FbY7rsgvMeQRaklz5zxijMognTyr7quJKmAIEc1+mtL99CJ2+znj4Ab8EuONYQITz22zH35eeg9BCcYx4CHhplkWOwSHrte+cRhlkxUdWTZ+uSdAko/KImtgTkXS9Xr6F5VNpVSrf5fF32HrBk6nbzbVdQx5lAo0CtUtvbcwGCpuT9H7udTISxMft51H/3au+P+J1IUYajKM//+1966htmzZedg35qyqtfY5577VfdVqSbEU5IBkHFkyiiGOMEmIIxFoOz8c5UcsBUNikCAGByLH+SFiDE6IFBwIAhsJ5OBINsiJRUggtnFIApEcS5H1sCJLshWspt33dvc9557HXquq5hz5MR5zzFpr7bP73pbOvvSZ3fuevWvVqprPMb7xRgGXVVOnm+u1VA6W1GzBcYaohe1CIbP+Lb0MSTrCuTSrh9Q+zJJIBGhiVNC9dFvETn21928m2V/ULDcAK+LUtQrv7+RxQx4s1FXmM9xgZZ5tFYmEME4TMCbURB4y3PkGGHPyTFW6awzNmaUiHAbnKZaE9kMQgjtDBIBGGZ3Tfonknu1TfJn0XOZEGMcBu/2A+foIKwzXuE1qG4NYuSjc7uvnu+++PoM37w2QVqk/8QnQ93eTeylooJF+z4yVdpSYSSVvc8oRBV3liqoSeWWR0WtBC9VlU+ZJ35LWPqCcQUnMeDSOwJBdW486AlVhvEJ3eMIMAtXsMnCtUoE3QnnRimcQMhJlrzdgzjN2ACsYnIAC8ow8ljthy8gTSdl2+Y54Fso9RgA0h0I1LqxKw01ODiEEVvYVne7Bubdc9kAt+aYlELcfGWsaBPlwSqhqUg1+XvLY8IeN3f8blI+OTiIBPxGHThvz9o19uyNEQJbfzXGQLpdAwW/IiYDnEQoH86QTye2wggDKJPnx9hLMUmfJeFtZym5VELIiZS+n3dwHzzcnYkYIFOrpaI0TdgMO90SCgHOj5/aVljJE+mrEIPoZepZ7DS+2zds4bjMHSkZcUQhKRuYsdm4AKTMwQQ+4bk5TglmR1AQQshC4RF4FyQ6QRddZLgbonERHnu4wqI6CGEhVDnmNGXV0PBXssQX2zIgCmKsTgLhO8Y+tZYjD3/JTFbHc5OmhxESrPFFqeg9/TkCMPfrZdMk/a2jgSwSOvd0JIiCTws5Vt8P0YJGL374ZCrXzZZtKL/imJIxDxm6akDNQQyIdg6iu61dzV9ij/Xvi5VsAmRY+fGYkYQNulZGnfzUCav2Wq00UkDRihhRMYShIIGlOvyEPAv2zmQZHjROAKBmqzFfJhKTVVJKawKx6knkLghTHsOYC5qbhhyoeTU9R2RyBKqjWVv5LiWXykFz1RCRIKjI0h6Xejn/ueEoiFuKWo8i/ExAW+wT2B71VXoyKwPYWc7TKxlyMeHWejq2X+uLn7N4L7UtICe4EEZB2/jA/X0FzO5HBNPhbcC7yoOkFRgxjxppKENz0VlPEnWQGPvfuD7SsjgD6b5+LMQhzRXCToPH7whK5xmzuQM1dVzMVNlObVcpN4jrspbTVQSgPA4YsKKCiChcGwLmZTI0ANPNe63Gxw8QM8cgS4mCOM0ikaf2EQEkuQkOF0S5vhECYRa3Sh1qqgrLgvajT09ubLL+kKCSpYnucz8w8wHKjE4e4LTjcZwvXOD21vULAyT4xBGbPu4Xy6wOf+6bwOdvuEBGAKOA6WmmL8sEOlT9X/3V+azkoFJclAvKQME0jhmEE0dJEhRQW2bR/0lkEJYZf8pRjtvB2e5fjbGtRaCzcuXpYNFNZba0FLjxYIoZuI536ihOAnDI4s7gRM4BAALLWA7ACGWPKEo6sTi85JaQ8oJClAltliHq/KPGoXy5TwgV0QOEHFOaiMkAVXApq6uv/OWJyNCfHx2zxHQEI89JQATXayUILqBKIsusHoiORrzmji/rrpOtwPc5xEx3UDtFtE2r/PSfvX2gnROJ2vM/n4iMRO7CdBJWATq580OfLojYhT9bbPhGZeBgzxnGAefMR5cBp6aQLHc8ztPCcftwKtUA3kN/KYgLUdwCk5bns07b13M3WxRn9OwE0JGTO+g51NU5ZvfUEtlpKLKmMpHnyYAgIknWpVqQiYc9VzYRdlV+H8sJJLV15DWvcLCsJnc6DAdW6NY/D8B0bkxx+UkJxKieTjrHidOc4cEp6uLRIbPeUNoSzrYP0m/srgKxWDHdEUmIi4+jxXRRfKDCA02MbOcOZnl3oLHtRtfPtThABwBCTHT69RnbtwyEBadxP0oaEUwKGMWF/NSGPCcu6ipiQMkhzgoufPfqTH+iDUffT3vbc+9JqeZeCEi36xzCjW3zjVjGtWKuFZzBcvpxI4D0P6iGnXCgl8fajHJR1JMU8jBiYoxABQBI3XoJA/Qy01FmBu6v8oKXWZO4EzMs6GMEx4uHw3+5BlW9YYAZzN+1NV6M8zueF3YkJJGinJe5QMKHr5gQAgBXDrW7zIwdotmYn63pmW25TkzVx4Nx34m7Y7JGw7u3Zp++TVp9vSr8MBJ6jdAdARD9KRO8Q0S+Faz9ARJ8mop/Xn+8Mn/0ZIvp1IvpVIvrDz3u+ty2u+hK3c7DNfixEN+WE/f0d9vf2wAAUFFSqwnJVnLW89v4QAM6yuuikW3Qo/mGwmZveubMLG4IJVXALGCu3n1IrChcUrihc5RoUwqpjkMQPZKQpI01iAsxZYH8mLYlmR55hWdHUr0fQQU4ZY8oYUsag301B25/sR/Ma5JwwDBnDmDVacPAsOy5G2PSpI2K1saKIbkP9G4zQGZkwxaLMIrffDeJ3k36TE9DFk9quPGd/Mnoi0HItwImc/7QvBIqm+ROZojvDCWHZ4p5bqBNubB+07gAA/NfM/F/FC0T0jQC+C8A3AfgqAH+biH43mxfLDY03lJYAD9F/frssIHVcIpoHt7czI2Xg6t4e91+7j6fXz9RnvWhyzZZko/u+U/oLlDx8FPjD+f6eHUKAHp14YMNqKIBr8bqDRoua16Jo8R10JtloCXKAs8vnZHcAzFIklCpqTqI4pIQhZfAgY6gK2xtICZw0wdOQ2WGIW9lEgsiJpM6A/r6ZpgiaXeFp00nm8NSczjzPwZmJPaeIE9AUA73CHMebNk0yPfQIMOWMMUup9ZZIRA90uLHecodf6vcJo4hA5rlKdWkfqO7ADe1TAH6CJeHoPyGiXwfwbQD+r+d+81S8Ovn9+Q84XSG5SuEvNEKwvTcRxv2AV199gPlwxKPyCHUWDpQdElN/Jm2jUTf/sDtOHYIbNH1u3wnCGWALalyi6vVWsbcaAiiN3sohZ+fSJkOnnJAgiT4kmRq5XNpicBhcChbNKpyJMA4jkLPqCjIyE1AqlrJirQWMCiItsGEu1TlpQU6Z3+ycEX44qooIyY5KpYYGjJAgEJrN4jGx0mg+M5MXCMAWFnIvm8t96t/g7zl5lFhhwv4iiAJ1GicM4yREwPpuT3JRJnZvs0v8AEfR8BwBCNc2G/C2odMfRifwfUT0xyGZhP80M78H4JOQYiTWfkuvnTSKdQe+9pOdXC3b+4O08zCOyEQi5Yq+bG0zuHRGjKsHE96sr6HMCx4/fNom+zkUyfoeV4MofBh6eJvl2WqsndNFsUFFlFIrSg32f2016CiIJILPe8AQb0W2w0/+fIsvXpcF8zyj1oohS5XdUUOvUa3i0YJlFSJkDkcwRWPKKGORcO1BHY5SrMZkCKH1vVXmEWTAW1t77cdoykEj+BTW9YRgXITVJzd2n/QH9nwjIgw54+rqCrvdDmlImgCVN/qFM++70CLai3/7CG6tILzc+Q9KBH4YwJ/TJ/85AD8IKUJy68ah7sA3fuvvZXep/21o3fAF5SpcbHe0w0OgTNhd7TBd7ZCeXIMX0a9atWI6fSpc3qQLducLm9KvbQl6UA4ChCYXEvyMwg6KEgA9HF0kIgNMWvcg+jiorauVMW9ZfWstWrxE6hSUZZYipADKMGLJkjlX3tcIknHYGpxkak6oy4A6rsjjKH4HphOgDNpQxWgz9+fWqqXQzmzlFO6vMRmNEPRzrSsv1/8n3rX57XS92w3qa5IS9ld7XN27h2E3uk+Gfz0oCU3nEkvK25hP+rth+CebxfbPZdp3I/36QESAmT9rvxPRXwbwP+mfnwbwNeHWr9Zrt2wU/huvfTjqwOHHnngRKWkgSRoypt0OeRiwrqtuLC39Czasvu36GTh65oSbrE79tYYTjQDId7u+KjrwMTG6WoTbgTUU0MNqg/tVKxWhijKRV01EakRhLeBSwGvBqpWN6pDBw9gdVvnXswwAWnIdhYC1YDnOIE3qOk07jNOEcRLxIrk8L9r8os9sSlJ4WrItQZfkKeRzZweWLqpdwpE2FBgQV6O7Wt+rPbq5/VKsbWAin5S6n3YThmlo8+Jre/NB5Nb5M3uTwm9mZ4GC0+p74uQltzw2H7TuwCeY+TP65x8FYJaDnwLw3xPRD0EUg98A4O/d8qmIYPq3AxTYwtv+6HwIDa5ZJFcmjDtJeVXmcspYVPFCwAeAMOd2qHfgfN8jdzQCwXq9yC4gtlE5phHNPjQfIUNLlBWspaCuK3hZvWSZWyeq/VtQlQCgaq7/yuCldKm7rVhAM/XZZCU5YKVIOrA5ocwDyk5Km5d1wjhNGLJEITZCWNHqD+p0UXIdQqddt18I6s8hfzOfLoufk3CwI/c8PXvuz+clLLcMRd+mupYBKQ+ax7EXNiyVWPfubcfQiJH8HgVkux52LQOngnNMuhgn4LJu/oPWHfhDRPTN2o3fBPAfSqf5l4norwP4h5DyZN97G8uAt7On/0tDDjbMtKOtMACpM0tEyImwmybsphEzzQp9JTynTw1AjRioNoOo4gTWdef+zEGnRmR6eAhn/eZ9ZvCQ9VBXrp5Qv49alCBjSfJRwZVQSsG6LljXFXVZwYtCf7Y5qL7DmCEl24s4/Jgsz5XBaxB7jCIk7b1GWVpdQgCailsqFS/MXgV5t66YpklFhKShttXzEDBM5i+BCAAxS4+tQ5vI0+ndzvylf88pbS4d/nbORAFqP36vn2Eymt29sD3zZozQtg511892mLqOnQ7mTPuS1h3Q+/88gD//vOdefmGk4F86PNDUgXRmTtwy7wSCEjBOWeBdvsa6avBI2GPnTTCm7AqqSKLgZHTzgsiK98/1vnUEQBJ3QJV6RsSiviKhKcmKlfJaFyzLgqIwH0UOOWtdgLIWrMsSiIIc5pQSxnFAThlFobllAErUUAYArdvAEnLdomlk6rmilkUUmesq6c3WglFhdEqaA0ARieQq7NO6SDLUNr8iemQ4zAvz1g5Qm3dHVT5bPSkQQmPfbmvp349AhFUlmUiLkCZ4xSyi4PW4gZE37oMzlOjMHec+pbPfPSFfXbszHoPWGlT/0jaDkaKAjISAu3sYEg2WAAxDxjRNyMOIdZ7PIIggEthV0oWw1N+d7iBQ7zNKq9Yv1gOz+brDRPi+lPc3fOkIxDc6AK1GPB9nrMuC5bhgXRYhIAC4VCzrgvl4xLMnUqp8XZfuoI/jpARRkn+SOg6NuwnTMGFMGcTitFSrcHwmKHfMnnPPkpFahqGiRGBdFwzL0CoemV8BM5Ajx2yZeWzCybIi2fz5gqjo5LqEaG6rm9WPU8yS97BfsUCbW0KYChZ/iGyelxQQixKx8PCGOEiXeYMDTk53sy70UAKgxJ5yXfbJBq+E59yUdeBOEoFTsP6leS4zmt9494m+xSm8ppbIhN1+wG4/oRxXCV3Vg9HrAppXmC++4VZ9hyl+LLAlirv+bxdkfn7UnXTotzeOJsifAbNxV8a6zDg8u8azZ09xvL7GfJxRZk0wWiTH/zwfcTgecf3sGZ49faZEQkSAQTMLjeMoDkdFRJCUM3a7Ha52O+yGCQSg1KI/7HX4UpbiIlZbYJwszfgkitfpiPE4IY8Dxv2EabeTQC4r7lIUqSUbZTvzFgPBtXompEu7xg++WVq4O1InBN5/owTi0u4wS5LNPxGy5kyszv1J0rqd7UcvBEQVR4thOMO9t5yRoVFg2qrBRLs9MIIbDtGdIQLWXfPwO80hcAts8BxqQRpL3ghldwR1MdoCUAKGnSQbuX6WUOoq5i8SX3xHDvacKmIEWWA526fssD1KI6SEhwDNLtTMlOcGQ5t/25ANOTCYi/SziGb/eDji6dPHePzoER4/eoRnT56gLCsSJC4iVU0jXkV/8Op4hTfeeoCoJKzrimVdVVSYUYr8DQBzzpjHEdM4eYpyO4cVAFVBB0claiknjNOE3dUVxt0OeRox7CaM+x2G/R7TvT3KVcX+iqUYSbJMRCR0zXe4HrYkKVQkkZKEICefVCWOlh+ChRBs3XDbrJL+P+YgtteRp0VruE5+lypLggQ8t4HL5nyWnkfrgr0/SsEXrVcnzzB02LF9xMc/j5HeESKgi2yHBT2qs6w4z2uXFCzJPzWzkwtq6BdBD6XDKpHzxv2IPA1YllVCcIOmOiL1SkaYN9MeNk8LZGQkEmhCJgNHDmQbWO/dIiQ79HZYa61iy19XzMdZoP31M7z/8BG+8IXP4/HDh5iPRwwp4Wq3w9XVFR5c3cdu2CNpEY9MCdM4quwvIcYAoywC15dlxbJKZeJ5mQFm5GHAmBXGU+rDkXMGuDkczcsiSslasZSCp8+eYnki4cB5P2G6fw9X9+/j/oP7uLfcx+5qr1WJNAWaJj8xGWmb16Hn7uRlyjpYHL7TE4JzBNi4RWpEEQ2wicjTsi0nTTfnMXtEELPyTao/RqcRDmDQ/rs1xZ6MOXS1b20sNxmw7ggRaPDuSycAbJ6PRrnPfh4CFQRuqkiQtDjJEGTUsFo9sQov61wF25jaf4N86nfq01wAVaIUZNruhfZ9ZlX8FSzLguvDNZ48foJHjx7i/UeP8OzpE5RasNtNeHB1D688eID7V/dwtb/ClCdkstTecogzkacHFw4sZsVijkQM9w4cNQ9B1sQirT6jFHtNlFBLcWVkqQVrrZiXBcd5xtPDNZ4er3FcFjx+/BjXxyMOxwOO8yyEYL8XMWKakIYBTBKe1LK7NWJpSK55eAaWSm2uLrczXHtzetzPgMj1DRYkZS7CJ7uCTNwL5KXD6OGwxv9SI2pdqfS+Q2eutY11G9fhO0MEpIm8TLhtTsFbiAj+jSDHnTPfbTC2xLEohE0JpGWzG1dv5ivrkUsTClwoPDwq/fz1HaFofXLBwLTu0AgEUmLVgQwLHVbtv6KBUgpyynjw4AFeuX8fOREG5fT7aSe+7XnAQFnCfWGmTg02IsnAI4lAAfCIUotvLFcO5oxBiQCR2Pql5qDOASVkVQgWJSQjM3ZXe9wDcH9dcJiPuJ6PeHY84rjOWJYFj588xloLrsqK3dUVdgAGMDINkgKOEjLUp4FC1gAmtAKFyafWnY/C4WuZg/udgrA+8nE9Gz1q6cPSkJGG5JGmcldFtPJUtFzGRiiY22rbc5szU0OPH6iFMT+v3TEi0LceAp8lebgNIeimMjBm0oPmaalVYSd0glEKUFYW86DDT4XfFFN5BNHgDJzzhJqRw6smoUXt6X8dSVITIfy9jUC4Qw9rJJ+KBMyMlBPuXV3har9DIlXsUYJZEVoBZf2fJk1pPg+WH0D6VO3gJE04gsBgEwFk+fR13iAIWnqtGhMiKVVGEgAloQAJuzFjvLfHPWa8si64ng+Yl0UIDhjLvMhBcxFDiq6mzbzgzN/RtGeiYPv8jCjAjaC3X7iPZnS0CncQkmSizYfBCUH3PpjUG4/9ph/9pf6T2yNke/cmYfrF++80EbBtepkebjQgFxpvP6UAvf3UOVCTQ82MujKWY8Eyr+JBSknCalm880THqJvf/ML9R57djngsnlkQiZfdY4dlu6k7GBn+aNytESk35w2jFxLNOUuoMEPiAdYCK1JqPuxgm22oG2/SasUAaSpv+GcbDkqWzFQ4ZgXEbKbzaCO1nPu9l5vmG8gZE+1xxfewliImy2VVnwT4pjbClRxhNTHAiajKBn2wULMMxH/7FgmI7Q99ZjPF6HTJO/KQvCaDf0e3gtVbiBiPfR9w+LkNor09EYgjuE2780Tg3K/eeEsAbhp20wg4Z+KwoN1ayAZa14LjLAoxZsnCU81/1IiFfSMSgNBZ3z/BDkRVkoAaNz4Z9ckG7sfVuJpNQ4O3WbktMbyGgBUGsRwB4yCEQ4gCtx9mNX+aBaT9brGHNhbS+e+JUuogaNE+JeoPp002kShSJcuQKP/GNAIkzk3H5YjjsgAARkUzltDU+uJpz7r5knc1GsrKoRsBeJ5uoN9wFJfP559SwmAp2Lz4qCqHiSCl29kRQSN+BMun6XMqlwVFBGejRpW+OALgD7zF9+4eETCt+23GTOdu3P5N/Ud05t5w3WXvCqylYFX5GtAS4Bcnlswp7kQnuEWSpFWBwjdPfYcirIxkgBESpfb5950I6IYUWE/unJNJeejAksOvimmQq2TtNVEoJvWkYFvRlzQNO7UlsAo4Cewhxm3ARjQ2029zYxmGcutrZZa058Mg38vJNfDOSZ0Y9ITUVyis65YAGHpqa3f+WW2cfHKmSJQnOgeWGh1ahEWIsMRmKdEFg6ARnegRRUuR1JBft2/CGLr3n7l+0kfcfJ7uDBEQeRRo2z4g9JvQ0rlD3V3qw0s77rt9LttFQikV61JQCjsDI4XHTtz9sEfupnDwXBgrUfgK9d0NnzW31qaAlHe2K1ZOrLqvf5sPy9FPaFV+pV+piRsJkHTj8uycZZzGtTlUAQ7UKHZX+rjVnjuBaFyPdWwmx1OwIrgC1Oo5KL6X7okTThVZrOUx9Jf1hKDtIV/MTbOjpYpUbgtp+RV9zArtLOGr70qjhalVbiq1IGlOypQyKOvwday1AlVdvFFbPsDq60kQZ4YOTrYFdUq7Hc3tFH/Pa3eGCNhON0LQU8LznPe2zTagFxBRuO3cwv8hsQLUirJWrOpEEzG/Qc2+D0oRDHq22+2pG0sTIdqGWcfoWYi2Mrf2tRGBtom7WH70nMzGGi0Y/cS0+RCrDAtSYHXQsefH3zWHgOgDG0qooKYjSQAHzXincFS9BSm3FCRAvtcNPAAQVGOlx2y6Aoy2BRRaEPC6nZvteI33cvtp10iQkhGAsLQBuPu6WoZlsKRgW0mcpypXZBZrwTASxkHqM1qillqKW0nE3MpKAMzCEbMvO4wJo2lIodvAZ8d6BiWcaXeHCFxsl+D3CbbvRaj4dfuHDQVs5UjDB8YFCaWwRNBxOEhh84iG/PTAW9co7uazbFSRyRYih/s5/vBm8/ompvhCJyLx7XbYDLbKLQ2JyPOqoq/gWquJRcQbtbr1gVmqlhvnZqjST+MDuBu77HFOKlqEQ9ZQA4UFsrG3MRh4NrNZhcrdTLDc672GBmF7tOdYJabTmW6IKX6js/ronBGg7skhS3KVfAfruoJqQSkDhjooEqsYh4w0aI1HTljXhHVdsWZgWcWcWmpB5TZOFS5gWZN08z7n4MdRsaPH57U7QgSa5rfx6zDpNxKCvl2607/BbZG9HFUIC2MAtbDCtyQuqUSoqM3bj8Xumzca64YiqaFhGEe2fR60CiY6aI/SBknEURq3NwWeFcQy7htxE50QATnwtUv6EbldIyoGf83tuKoTUi0tjTkArDZWRQCwQCGt8AMitag0F1yyWoUqS7fJabQhjtkoulcW8L/h/SVu4poTl44/OKUTPUhATY1YNqTm62c08oR+K1nKlml58DqJkoilxW4QQyjPkDHuBsm2PBCGYUCtCbUwlrVinlfM8yoEwZ3QtZ4kN84WJbNL+oEP0u4IEQBs+6snrVJujYcP+/U5jziDD/yjHjJqvvnEZt6Sw19KxTJX1BUAMlJi1GQRZ8qJVF5mIiCzb0ory+3cy+rNoxECf38HUdAGvZH9GtwPhECvkRKAHnUAhmo6cGLd0c/bHhLuyx7UJH4HpYjjUS2rJCAp1YkFgKbz0FBfGjJSDe7CWrpJCpIGHh0mg6xfm2uVTZFGDfp2o2t9t4Nis2xElG3QgCgB0RMA83ewl6cwj1v6cdJI4i7GcfKkqnY/g4FSpBScEYFaQYoeBxLnKgwZGIBpZIwDiW7muGBdlci7uMidNNCLMtYdNcVu9TO31BfcJqnIjwL4twC8w8y/R6/9NQD/gt7yOoCHzPzNJFmJfwXAr+pnP83Mf/JWPZFuxzeHa+xo6OZv8amWHUYYGqsRHS0cTtbCWFfGshTMS0GZK+raCldGxxxWGbBywUATkHLrWFUS5Np5HUlkvBSkf73diN+209Ev3AiBTU1iScCRqG18u3drdiQbK7Uz6ERFsE/Lh6dVi6vmLVxdfq3C3SxngGbccc4JzUqs8ysexymMw9aRWk6Gjrpz9z/E8QaCGTGPxQrIQUmuoWeDwqTPDQrVEw9PaiSzVyx2b+5+S6SekqOgAI8p0P3HevhZS1oWrlixImXCqu/Iag1JGoZsZtLjccWyCMHV+q890wgzFZe9JwQdt3lu+0B1B5j53wkv/0EAj8L9v8HM33yrt59r1P5tabJuRgKRcp8bdlxIg3gSacuoC2NZKua54jgvmOcVvDISZQyUAS5ezVe+ZBxyEcqepQiHvd9/qH+/IwFW+K6nPh7+2y2ZbFr2B5IGPPVPofDT2G17n+lEnLBxdY7DzChmfQj9agzJTIDs+QZAW/TRrBIBC3VJWeJa2xtc32FvPHXXO52pM3Noh/LSrBLgHPykP0BQbAbRAKLtzyoKDCREoLCkTxMU28x/8iCJvSiFsc4FK2VJvDTCkWNOCbtJczdQAtGK41JQi23oLVHfpEY3JmmEwO4zBfhzEMGHqjtAQnb+GIB/9XnPubkpl+rGKlzGN+0tnnJJFIifg6V+nsi8ggDmecXxUHA4LljmFQTCbhRISyqjicVHtyZLZBzVinEYMOUB3VSGjhjHM6ZnhJrj5jZEcAPa2U5C48DhAxeOz34F3Qm0e/XQixjLSudENm3RcP0DO32q+s7nlEHBmSe5fwK1CkXhUVsmz+Eidze0yTzhynYhxXu3x17mOb73XCoy/5wMTbI/uDvUoJYcRQlcNhlQJ6aZHm3CSHIwJI3IJDa1iURtJMKQAJqyKxsFja3yLN+B3gMkyoEQtH1JMD1XRFI3tw+rE/hXAHyWmX8tXPs6Ivp/ALwP4D9j5v/jeQ+hsEjh4u1ZI/Bcatfdq66zZRH5f1kL1lXMgnWtyHkAkLRQRgZyQk0JlTIyrSBATIjzLOG3edCIu+SQU9aySaqeiASiAKxkcrkuoEHdED3YUQaDqhqk0g6MXu8oSDxZgY+GR7tfCqk50AUDgfXFILTs4V7jTxACSWiZgozrGyFIYt6zsufJDkqk9lsGD+NcOFl7nw5shhktC8Y148HmzZchh2hDFVpXNtRJ5iSAPC4oJUtuhVwwaK58q+AEAKg1RC0EgsOkPgOEsqoxcDRAIhyPRiU8XAFecSgrCidnYBIUZT4FQVnLW1uGDe8mBzdpH5YI/LsAfjz8/RkAX8vMnyeibwXwPxLRNzHz+9svUig+8omv/SQilvecfB+4neOnBFTZZGWtWOYi8GwF6ooWeAYAqBhitZw0YEgTamIQCggJtVQcnl6D14LdOGIaB3ez9U2nJy6RBbygKT45qT09+CLYIYcU9iCp6CmNGaCqtfq4T7AB4WAxn76GC6F0i2+e6227SKUf0S8UagigUkUliIIqQwKEnMERiPXg54SqEYeD2vXtR/wBJNGIiQLS13B2tV82RFZFbWcJIJxCQjKOHhSnhjacohrhs0gR87+g0B8TOWJvyOmv/0CjI8GoPOs6MSoPEkVouRYVBYGlalN24igmUrJagzWBqyZKIUG9ko+AMQ0J2A3iYVQLjgvJrzpJ1VGKpEVnJwBhLmEEoIkyl9oHJgJENAD4twF8q0+elB876u8/S0S/AeB3Q6oUdY1D8ZFv+tbfy0nhafQFaX/0i3ShR2fua9TfZKOyFJSZUZaKskKUNxXgwqAirl0MRk5AHhJ4BgongDPAGUSDF+08XB9w/ewppmHEfrfDcDU0xVPsinEmZ9bkCr3Ckp04TKzsugSgJr9EqUreuyolyJwAkHLr2pCAc8AtnHexo5EPgmUC2nhTKmdqp1AOnSGapkizOoZouQNzVmeaUHXYBhL7c2FJI9+KjLybS7s5xZvOPTYcbuaTT9FG01015ajQZ9Lf2UOK+cCoFRirVFcaJkkvRhq1CYP8KD5vOVk5doNhjFplnpOaT8UJizCNCVRHHfuK48yS3s7QkhICVtE26VptRtEP6EL7MEjgXwfw/zLzb/l0En0MwBeYuRDR10PqDvzj2zysrXE8PRx2xM1E4Kz5TZ9onnVi9jLO2+zp0AIOpTDWUjFCNnd7dpP/mh1ZFuD9R48wEOHB/XvYX+0kGw+FrbXdtCej1o155gY3WVHrayICEqEQ2sJ2sJrgLJf6tSdSedX2YEiCaX7wXhlXkyLYPNiqdPkVretGBOwZBFAmdA41/pB23Jq+MszDOVnAxpgQkBbAqRG5Jo5c2icc/itYyBGDcX2fKAmyZEarslRFbKzKrMpQUMCoPPn85ZQ8dboEb8kTk8+bWgPIzLuC6CqpCFk1yCsJ0RjHLO9CRuUFzCvqym19oXqzhAv7q6f/l9oHqjvAzD8CqT7845vbvx3Af05ECwS9/Elm/sLz3qEv0g731Po2GODm1qCmmL2KpsRWeGbPt5p4ReAvUdZvqy1a+2gwUuAx4/DsGp8vBa+++ipeefAA0zC4S6y93g4JeLsYl5eGiE4SiJDJ76qwbMw+Hga0Smjbsr56T5xiOZe90gkkcmvWLN4VbCQhRPBF12Z2HUiy9GKdHuBkcP4Mt2gxPDz7tN8N5QRw1wagz9q2ICwJLKb+M18i7kUrC/sWUUAsIctScFwW1FqAnJBKRlbKYRaSOmZVzSSMOSENQkmcCBA1jk1VFM3JiF7WhZNzkIlAmQDKuFIkUtRng8yzUEWL5N9qwJ9tYP2Un20ftO4AmPl7zlz7SQA/+bxn3thu5Jy3bcZVNluJAcePZITAriWAtWKOVu81gaojFvZ8jQorteL9R4/w7jvv4M03Xse9qyvJNl71HcplzDO8k4Uv0IBo8+Uz14hUtidDOUbI9Ml2ps/b99pB4mb+EgQjokniBB4ErvZdPLWjGxFK0NDlZHUG0/n7bSECOnA9oaGCzQSxb+7gdBTSTkbb/9Zppm5GcPqX+yPCj5LNKYueZVlWXB8OOB5nMCynYCvYkogw5IQ6DOCxggaZi5xIsjaREQEoirSNJYRACGg4sEr0sooHGBPKbsCqCmzR/YRYA4F4mzH26sCb9OZ3x2PwRPg73y5/2lgvb66RKk4sCpATkIpqTRkie1cCV8K6VhAKamVkkm3RCID6CtjTVeH17MlTfP7dz+Hhxz6ON157A0OSVGScGEgk4oduhLbJbwJoNzeDvRbDYEk8fMzGxiIxiCzUPtf5lrLhqkxUC8dJfL5/Ly6VElE2bzgKisDNdyNFJrOedIMSZligQUKnT/C/PH0bnd0QrESmeYNvuIGOu3HLRpAYUL8QEQ/LUnB4dpCkqOuKnDKGcSeEQrl6TgnLIGnV61qAScyMiWROTM5PgXDJ+03EtELsrgV29oREyMzYTxm1jKi14Pp6lehWwMu6X5KgLv0V290hAgpvOm67WWDa/Hv6SRhq0C47nSdZCE5CnQsa9+AC1FKwzlKbb10WKagBuN3YaRTBs+EkIszzgofvvYf3Pvd5fOXbb2O3m/TFjUPV7XC2sLabipvFhG7Yiigt+KQ7sX5QDIo4BHD9Y3xmAon+s+tDO0xGPFi/E6R7ZP2+OQ5B552q/+b9ISK3cnXMnwnIUoGY1Xmpy9yrjC9uhA4BeW/iv5fmss2ViAoyIQL/hdaXUnB9/QyPH7+PZ9fXAIBxmlR8GgCV5Ze0IOeEcRi1mEoFj0oIkqKCrFw9EIEaeTUzwEWocSAGcgzk+/vdgFpHcGFcH9Q1WQm2s6otTbgFpL5DROB8axCaztGFi9+RZhvIAlg0SMc4EdgNEMzAqjkFa1mxHFfcG20baeBNsIenlDSLT0KtjOtnB7z33kM8efwYr7zywJ1JPE5ciU7edrSdy4ujSYksGxgCH+5aTNhVmTVYJ7womVnRbjLiRhC5kpyzx2ch5M4DIhGiVlabGUk3ormtOtC2+Amz/vhPOLtRt4AEoRwaQGMHhaAlzawf22lqBLdHAbFt5aH+urj5W9EWwjzPePz4Md5/9AjrumKYJnETRsJEIgQRgJUIa0pYh0VKuZcFZU3gIYGy6UrJHYTkjWYVkpyLjlasgEggUhbnMAwZu92EdQWW9Yiqae98cYSa6QiDTuk5h+ZOEYHo/yaHPlYIuA18Pj9agixETkABgVb3q3Iq05TS5HHfUVFNZDJv3MjJ7cPzsuDJ4/fx+P3HeOuttzDuJvUGa5Q5wbILasGMuBcDU/B9T2KHBxNI67o2R794cxt50xtAtPPwDxzmW8w/QEiuJCXPkhMVd93Do/adTHmmHpUb85v1ymMeOiLQEEGU2mXYVc3fhuR0pVJ4txIFH3mcDzLz6SmMdOQT5qq7QcuxA4RaCq6fPsX7jx7hyeMnnv6MFMKsCRg4yXomwpIIZRpRy4K6jFhSwjTuJMaatM/d/KoMFnaGMTpoDcZ2IlhNysA4DNjvRVSppWAuFcSdnKFzxhr7ckFWCO0OEYFAAMLBi4fw+a0NNu4Xh80KKatS5O0zCZDFrg3qUthsDQG0enrmCLPMC548foqnj59gPi7I4wgkloAb0gOVWh+3KrcwBb34jF46oLjJI4TQTd4cDtuGE607adoxDb/tXksOs8333bk56cPjXOnmregDVs6a51gk10YAmu+DNHkWs0ATBoMTtwhaVmJmirU2RUHbHyAi+X+027faOKoHaBN/PBzx6OEjPHzvIeZ5xjjtkLPVZwRWMDBIvYZKQElaV7GsKMuChYB1ylgzAJa6i2BdA++vzXGYw7Cutn5OvISOYDdm1KtJzN1lQSmKoNAciuzocG26i0vtzhABp2W28Hqd6HL/z12nze/CNUkOPqtnFknw35CAYmAAGh2WMiQeSKiEyLkZKUmqayk0oRl8s0z8WlZcH67x9MmAJ48fY5kXXFUGlyr2fDWdAUmi7FiJQFS+bfUAuoqsXM414M5xVQ6k9n3PI2Cb3z4mMyCxl0k0+tHOeAz3DbOo1LKbV/K3N4IVUEIkBtLfdHJdPw3/qn8CNdMjAZv0ZVtihNNNECwqdotxE7f4oJ/vWi1du/1d8OTpU3zuc5/De++9ByLCvlbV+GfUlBBhHBGhrgPqsmI9LphTBqPieJDQYRpH8Qb0DjXiZESWuRMUlYgTLEzaeptUgbrfD2DeAww8e3YQ0yURqPbOw6bjuSnfwJ0hAtZIDx9c2WEb4lSeuzgs8ie5Q5kcKPbkTWK7hTtvWBVtYZYFli9flFgJaUjgar7wSRGBKIfKIuW+r49HPLu+xrwcUVBEXluBnDLE4ANUdQ0F156zXVAGuqZbCUfwE7mxcSAEEU0xBZOYIRRYFOCZzRJEiw5yGqeGOaeeOut4RNvmevx8m52JVQwyAuhWDMIpRyOZy7ZPNlmN2ObBrvVEt1heCG5BP7VWHOcZjx49xMOH7+HJ0ycYBzkmOQ8YBy3RNmYp554t6UrBvMw4HA7iNJQBXgeUVVBCLglllZyOpAQhEanDlnn49yJedGwgEDLBPVETCLtdRq07lFpxuJ5Ra1QqNhBs473U7g4RCAons187JNoKy4hmO22b+RNffbP76mMh/vo5KYQDQKhacbaCtLjlWguYV99gOSVwHsBa+KJqf7O6epZa2kZYFxzXRTaYbkBTzMuQRFm0yQJwMxGAysrGsf1aCwWGEglzT+gD69q82ZgcdXVcf/MvoKGt1AbA2qcz/d1uuo6j2x3GiU0E4Npm4pSFd9uiLbqxU/bPYwiaEyj/rA9Q61K1qR6gagRl5Yrrp8/w6OFDPHv6DGVZQQysecEyH3EIKJBpkBRspaKUBcuSMB/F029XB3luIa0KlZEzoxZCArtY4CsTGJedAden6LrFmSZi5AzsdgmlDFiWgrosEJdyy3HAYHGzxMUyZrhLRACAnRpfd5cJ4Wa6bkNbi7IxLEsMdXtGaCShaBhA0sSallbIfAmAorKdGhATgCq6AFYukM1KoDXpkyqMKoB5mTEvR5VxTeHISLU2R7guqP6UALD168LnG0NqPw96zjT1Xtj+yl0DAjdX2dQoQnsAAHNWaudP+l2ZPVWZ3S5FWfrDyLp4RtCNUJmS0oJfvOMRsjj1bt3vBvocJRG5LO3kRwesmZNqRS2WPk1dyauIdk+fPMH7Dx/heH0NLgVISSozH49IRJg0ffswyXvWAqQVWGfCMiSUdUYte5R1wbJWUCbkUlBLRimk2ZYCE9gOxeYp9t7FrgaDKQHDkLDfT1hXxpPHK5ZS1dpga6G5I2+IyLtTRIA2P966M29I4AwhUJiU7Jg4w9CtmcQxJuoBSKlqUoojdmKpgFMru7JCKhGrPmCQyLE8Dtjvr7C7ukKeBjABx2XB4XBEqVXkR8GanjsukXiRWZfP+gTc5N7l49JjqYq3phFnP+AFYmjrH6364kAQvLoQ0N0tgoI4DXvEniIBy7bkz9XDnoIxPCa48PtqbQQEPRFoa6Zj6xSpZ6ahoX60Y9PAf4dcpEOS4EPzJhZNm1bVIsCVsS4rnj59iqdPn2CZZzGRaiKZZRHF4DEPyKMGSRGhrsCagJwJZc1Y5xnLfJSkU3kAkTgU5ZyRMoGHHA50G992zzci1kylFvvh5tkMTBPh6t6EdV1Q+Yh13SCujSi0bXeGCHiAzqavtpj9ZuqwXrjX5NoAv4EW0adzYfekBOSsm8mIACqYpehIDXHhSk+1SIaUnhrHEburHfb39hjHEQzguBzx7HCNpawSZlsrkBjFjn5NTTw5c0i6MZluJCjL0H+kv9Dmi/08tYPfDm4jQMmVimXzrmbRgCr47XBXmE+9dYaYkRJQzeUaRjTUx916pMVT23hqg+vUo5wTdhB/3UzcCSJSJOHAh+UAcUycqiiAaxMrSik4HA5Y5kXBNIX5ZiEG6yIWoDxgyFksCyujDlW4/7JgXmakgZCTIMpk5uSBkIqYfimefDu03ZAjKotYVzcxVFwdCPt9Ri17cCVcXx+wlEDln8NU7gwRaN3cOLlguzHOfql9w7g8UUROsCNu96RESFkCNZJ/p/lxV+NYlUN+fxE2EiVk9ZHf7XbY7XbIQ9YaeisOx2vM8xHDODTMbR5wtagyIvnGCr0/NVumljtPnA6aMisRPKqtn7Gb58hz89kN1ESsqF+wey2Iqu0pboeKRb7NkCAXycWPExm2HUgjROEZEAKSTBx0xrVRKFJ/Ytr8cbi8QQ5dXyu4FlHo1T57crMMVNRSkXPGfr93s7Bp90utWNYVwzJjKpPqNXQ86l+yrCvm44IhZ8xqjjGfjzQkqV9YCWQGgRMiHuYqLpyLVe2qBQ9RJty/msSzvRTUw4y1Vvcpj9mvt+3OEAE76qd8gM7sY9rcw755SGUlD9c0ZgUvSemZZQcirMlyzst3cyb3fY9IwClyFqtAylm0xeOEadohZwnwKGvB8bBgWSQ3YVteydZDtao8wifmTznwaIvccWWLyEt+xiIHtRbX2u8havA9FlOxgVEPRw2GMtT7UDMRNwWeHig0KK9ZNtzZ5lSeg6MRu1YVnjshCj/m8NJ4MeSwkFVGMmIUnsvh1UH550RcDzirHsiVbmFCmBl5yLj/4AF2u6L5G9j3AsPQwIplXTHWgkyjr3GtjHVesUySRhxKPCtJgpU8ZAyjKBYtAYl1w2aJAiptK5MasSA0j09GY2IZuLcbUK9GrGVBUbGAQMBlveBdIQLkGXd6qg4feJcez75jMh/kaCSVlZInyGjMUw6ObNukCTKL3yQpxChlDHlCHlYAotUVqAynpMSSNCPnAYMSgN1+j2EYcTzOqJp2rMyrBuaY2MIAyYakWkBFOhsdXlKtaM4iAIrmBTIznkPz5uFoWCn+I69zQ6AfgoAuA6EBxBxKUDfCwMU1E5MpNSF5iSNSQFIlFEMKrdqu7FZXOmqpy1onG6ogIi1nrmQ9ijnNHulnwnQaUdPfoRtDGrVxfQF20TJgXDr5nBERpt0Or776GspquoBZCtOuizwTFWstWGrBWguGUpBykgrKJSGlgnlZ1IKQwTaelJQIDEoEEjRKTfap7tumC1AxhZUgbBLGtuHa+onFYNpl7JcJZYUwox4snrQ7QgQAoDeaCT2Qzd8itkwmbZzFzO56pxABbNAooZUSZ81TbyeboBFeGSmNyLki5xHMjGVeUacimWJME6OLmcYJ47Rit7/CvXsPME07NSkVHK+PmA9HgZVhg5k3nCgLTbRowkpFs2pYk2EkMArIiphqyLOgAG6ypW+M9t/K1blZx7gjHDCoHqoPGbthkFYVovjloF+ooAoU1nUgqCtyeDyJXuAkrJfFykDaT3GPZoB6kdAOO9mW8Hj6RgxiSHUSSCKutbX6vVunIEd3bO9hECXspj3qPSnAsq4r8pxFgXRMWI0QqH5gXQuWtOhijEhUUVLFeiyYaUXlglIrCgpAjHnMmJYRw5C1Xxl5gBM5QW4aVejwv30uBWqUKaDhBTs/RAnTMODeXgvo4IC1VDAuU4HbJBX5Gki68bd12v4SM/9FInoTwF8D8LsA/CaAP8bM75EIcX8RwHcCeAbge5j55573HuiQwptjH/xU2zZ00UGJo8Wzx9RN/UAATwrPGrShhyGlmBSDkHOSBA7rglJXDEPWMNt2X06SfHTaTXhw/z7u37uHJ++/j1ILDocjrq+vsa4LUp50aCZZ24JwS6IBWULPQ+cMUMUBPeVMpvosPSwy9kG2FeJpt++zw8hunhPcfETJdALGWRWWh8Ajym2zAgwrsLlN0BnfUgFQClwuECEXZ6RSBwIu9ucZ7Aexr5lxejuQVvmXADf7sgUD6SG3YiDSj0ZofMsUAJUw5AHDMKBQlTmB2N5Typhn2RuyNhXrWpBzAa0tuEzwzCzKViKsVVKSZ0pYdiuWeUVKM4jM6/T0gLq+wibI9A5QIkA9M4RGXoIthfmEUsWHZT0sXmD2XLsNElgB/Glm/jkiegXAzxLR3wLwPQD+DjP/BSL6fgDfD+A/AfAdkLRi3wDgXwLww/rvjS06dBACfOm4Fm/OdttIFq9tNJI00L46tfDpa88jFaw80SMLEUhJi5EcUco9AKqEMwKQMzgX1Jyw3+3w4JVX8ODVV/Hew/ewLiuWdcH14YB5XjCMlmDDu+DyqSFehlB4SUllI4rDtIPdshnDNvZ2InVDxw3O3ESndpDaFLJ+QRRnxunt/vjo9t0o24PI10+6xo2BnS4hHGjAH6aEGVrApFkz2rsa8oASOinoCf2sSlYogmr8ZSxN/Gi763T8bZ7BNg5BQIkyhlHWiSQuGMt81C+kIHIUKS1WgcKMVCqWZQFnQq3iLToPA5ZlwbLMSIkwDIRpinkEWjd8dvzwbzIYK8FjVxtwK8kGYMgJu2nAsoyYlwXzuuJSu01moc9AsgiDmR8T0a8A+CSATwH4Q3rbjwH43yBE4FMA/grLiv00Eb1ORJ/Q59yuOWdT2KdUL/AOGFVMJrNDjkSyzQgAid327Vuhsx3aCws8DY/tfpZFrOsq70hqBydobn3hDMM44ureFV559RXsdnusyxMsy4LD9TXmecZ+vxN7sSF5ZqBAvA/ZDk0Fs/ZcteSWw7BbC98GGojjc+KL1Z9+/ccUe0YgTuY6oqTEypCNy1AQNfiMgsnuk01aTzYwGqXzvus1Ry2t/yZzW4Zgs6owqqpE5adwBZvOxFCB9lvqJ6gi0AZOjdDIvJgrdusbs9ajKDLIlLP0V31DyliQF/EYLKWoAjlZpbFGXCokK3RllBUAFaxFgszm44x5HJGHLKnLS0WuRvw7stnmh42BCan17bshYEIETHFKGDJhN2Uc5wHrMm8XztsXpRMgKULy+wD8DIC3w8H+ZxBxARAC8U/D135Lr91IBM5ztEAIvA8Isx25O/nvKUykXRUeIn9JTjjN8GoKBcGRgQUyyrqgFE1HrDA9qSiAnMHjiLKM2O32uH//Afb7HZ49fYJ1XXA4HHA8HlHLfYCS++ybA4ykH4tVf4pAjVyBnKNO3NuWJGwvOqG0A8tt5ra+Bm512HD27b/GKl1MOOmVzXEKlZAabG9gwsyffYyBKeNkyrWgJwFgI4KqbOSqTl6m5KvNTwGs+RaUEyoRqO7QZPsIiPkUG2WWn1JZU3iJQjgPA/IwgohcwTguK8bhiHleUEvVyEzTW9gatLWrlUFF0rkva8W8iFVh0qS3pVSUVVlYtr1XvVMM9WZ1cc8Ov1k95F3J7oXawbggUcY4Jux2I+b18lG/NREgogeQ/IF/ipnf3wSKMN3kl3j+eX3dAYU059u560Yh4ZPT7t2qQYwgEKAbUGrAif+/+wpY/g9T5lUWu3ITZAFYJFcG54ySM8ZJ0MD+6gopZ5RaMc9HHK8PWqBEctBZCnEmi1tvMJcAVLUCiHjjEwUgpMLSAyKijEWaNfjs9ynTbnA5zA6bRt5oXm0H/ORf/T6MEJxZCdVFxICvprXHyeHvw4I9/AhUkofLMtDSMRmHc9TEYC0P5xYQzz+AVjvSx4tIB5qcrSHRrPNTmLFYMdGcMe4mTLud6H+qKALHRVKMUTpiOc7Sd32e6R62rVaAgmOS+BNIoRvRKQBMSaxayVgW+/+Sc4r2ia+tuqfbAjdXEosvSJimAbt1PF04bbciAkQ0QgjAX2Xmv6GXP2swn4g+AeAdvf5pAF8Tvv7Veq1rHOoO/J5v/Rdl+owQdBvtdFKbosQiBckjA6PMv0W/jnypHf4hA2tOyKliSBlrtmpBSd1Lq8uVdlgt7bdV4M3DgN1+j6t79zBNEwDGPM+4fvYMh8MBQ8rIGMQcVKGWjhA4A11ybg6enndWiYCjcJKa93pswKYlZtOWC9e082pwkvU0sCrQugNqOoeGLRuBtWd2kKP1uU2u9DUiifa7IhHts2V3it8VpWgFcVZTmWKIaLFg3f5sYwjECxDTaTxAJl44r7DsProTjBiw2EFKrSgsIbnTTky/024nmYRLRVlXEdPswDO59UFQZUbvnqrzV53Odq1UIQLDIC7StbDRdlgWYuP4LeGYWJG69erm2q7LnYkkvuBqt8OldhvrAAH4EQC/wsw/FD76KQDfDeAv6L9/M1z/PiL6CYhC8NFt9AEeBR331Zm74u8hVWM74OC4BN03xNylJixqmYIsVZiVzCKDBaylyao5mJDuHdnw4kIseoH91RXuP3iAabfDfBSl4PX1NebDEes4YfAEJNIT+5/OcVu44KAkPgbBo1/1AJU100wS7WeDoW3jRzjvBEKF11grzyMKN7N8jh6b8xEixzOCQNwShNp922aHMtr9bfxkK1fgnpueh8DGoKYzDnuFgbhvDCozm/qimSaTERak3peBbE0AEGEYB+z2O+x2E/IoBUUoWSowlf93sh6lSAQpAR5IRp2bdCA2iGKDrFlZV5SV1H1ddBdmheI4wSbShvHJjta7zElL2UfDQUBOhGn6cEjgXwbw7wH4RSL6eb32n0IO/18noj8B4P+DFCYFgP8ZYh78dYiJ8N+/xTtkIPZfp9zuud02akck7PBbaGw4VDglIpELCUdXBpZIF9pEheSKo3WtqEVlL3UyspTklCWOYJhGXN2750TgcHiGeZ5xPBwwH49Yr65QxxG1Vk9E4tAejcuBQ116aBiv+zm2UQAK9UM8fDvsykH8cOiB4AZFo27A7M4+YxTepsjE5vVEL2CEBUBNbFAu6LrJ/9kqObvmkMTIOnusvelijEDC+KCPsxEe+8UIYkRPOqGOOqL3jMfop4RhFB3AbrdDHiVqlCHVgpGlqxOrUniQoJ1F6xEkLS8u9QL6EDdHZk6MTZlpFaGz99UsOeSEsdE7JwA17gkoYrL3aqJWIxGKfC+121gH/k+cnidr/9qZ+xnA9z7vuRfedoI6hYhuOIf+l9CtpTqrnCcA8kAShxvdc44CkpoHVcamJLEBC1YpXFqMpyTdnNDoI0YaM4ZpxO7qCvfu38dutwMYWOYZh+sjjocZ67qKNtmSjyaDwwG61Xh4gzEoGewHLAGnDIVdtu4huHr0RTgPVhaiwTsmPzsBMB5pMx5MAIRW4dYcBlQUc9mbWdOry1ccybgyLuIy8sUJ6t5AfOyAFjgmCbUFAY2XMAIXNkw8FB3NURHALEN9eXRBh8RSXXm32yHlhHEaBRWSZTwSa8GUBmiWUbCu8/XhGY7HgxCprAiOGp2PoxeTIqsjk4lw1t+mqBYkQEpSI3LkMDYjEnJd+L/axjVRq5es+yjEDojzRkLwH5br8mGnTWaO2YFMnmyRYLG0n1yIkMwviryUCSUn5FyFq2dGpoQhD8hDRoWWn6qMcZBAEuEcenBSQhoGDDsRCab9DiDCWoqggeMByyJWhlyy2587R4gAZe1f2SDiJWjVkIRZlvDd9gwXCTxbrT26HWCu56B0479txsPBiiys2o4Vk6bcILoN88dH+LYndfG5V4S1XZ5Qp6BZcA2FVBWXCI3zG0+MSKj13v41BkLUHtyqP/vg5dAlEi8+mlzMIwou1zCfgRHDOIlyEMCyLBifjXjyJOE4H+Duq4Y2nCk1pSiz5TNg1JEdJUjHjYDIO4UYBFGvG6ehSSMAgLkX2yxVJe03AbE7QwRaczLoG/a0/6xcXzizw3rgpHhthGT2WCcWBE33JJaCYSCsetCHYUAeJTvMMs9Yy4JpSmFRW3eRCHkYMF2JMokSYZ0XzMsRx/ko319XDMOAxCTxBw0EnI4uQlwC2INmGpQlHSwnI5DhcIQVjyLCuak2btrPciMU7P/WwI/iZowc6tw7KAy0qrwcVodIiFOKUZXJ9QAIKrF28BmNmDWm0XrST6wTOAbMM9FMa35EVQy09JKuRwHg5eJVGTyOozCJlDBOE/KQkRLhybOEZTnKPlRXdCJNU6exAs7MbD6rEe+ACBiwACpSlOT3W582EIMcVdh66QxsUPS5dseIQA/i40Zzn3IlDq7pRSC6QLBVb59k4oNF1UHpjSCIrJ6CKQFDzqhjwrAMWNZrHI7XuDpO2E0DhqE5nDCqxnTI5ph2O1zdv4dxmjBfX+N4nHE4zDgeZyzLIkQgJ81A7Pwy9DGsnp0dgmqK4yyx/pfdjOaHlS8QAb50SNE2W5gvC/H1XdmOuijaSDkOtfsiITmXU7DHd3Yw9Vu1BmVdDXkJ1BJCLbbEPQddCdq/pxEBhdeI6s/IFuzPfvw+Z6anYCEayQ605wYYpMJQ0r4RcH1MakWAlHbTgVtq+jZuG4eIBaKzEZQZFbLVZ7wFajFYxElFAaiW78LWiFBRBB+wiQiX2x0iAs311M5ClAPJN3mTs0QcME1y05Q2wHm6Ee0qpcZBEkkp8mHIyBka780YcsYCwnyUWID9bnIvMduQniwiZ+z2e7z2+ut49dXXcHjyFPM843A44nAQ55JxmpDVwaT5rIS+ep5tW06FwLU2sxY37TGZGenMoY9EoXvNxRae4ZRoI1fpejhzsZgDvjFStc35xVcbIYAZQJzIRGE2xu43gle1wGwTK6LAYe91msvtevyvK+lW8UIkjUQzdFJrRZXkkC6CZq1ABZpwD1JXMA2yX2pdxbSo8F6sT6T9bpGNLc+BBVM1N7Eo+jg6sdVRBNRcuaufGfMhkIS5Jr5enP27QwT6ra9cmxv1tzsofG6XBSWECes4EkIEnF4DI6uCr5CKA2TBQ7pYYC0xnbDORxyO11iWPaZp6hI0WKahYcjYX+3xxptv4mNvfxyPHz3E4ckzHA8HHA8HLPOMsu5Qx0HkaS9KYetj2zUe2nYchTFZkJEdfiV+dGqfNyLwxcx+/3cN8rz2zxJ7GhAAuuw4zR7f/9h/ex68Zd86piqclh3hVDkWGvQFOwbh8PjuqeQ0I76b4vtixeMADpihCUFXMAGZsuSCMkLKaCJDzlqMRIjFkAYk2qtOifAsJ6zLEYAE8IAkqAcQW09RZ6F1FWXxMCaUysgM5NBNpwFBoupnzfQ950XmiCfoBjRwd4hAFBN15LLJdNMTd4va9ADsupgtqyFiJwB2dDprgv5tzxJ3Ykh5bapSmyAnLJAElKWWhlZMNjclUq4Ypx1efe01fOzjH8c7n/kMnj1+isPxiMPxiHlZsJaq4azqXAJ4vgFXXoWd2RSFNsDI8aGVrKt/z5RHZ/Ex9zvoPF/oAL39P84onOdLWiPfoJbd2ZS27bt9n42rdcYR7w85ASPNbQgmVDILCYeTcQ57VEUTpkht0Nt/8Uw/YdQM9eJbsK5HSSCrrsDmhWKEPg1ZColkuEUkk+iE8pgkTiQlHI4ZZS2gugBsEa5KbKoQgmUt4mFqloKKhmc3ist2pBW9RqQX5tH8UE1pQIB6HH64KMLfkZbCppfWRxUC0MNOqgykkFb8PMvbTpwlt7AWFbhGDBIxxpywDIRUIDnhBtnRhbU6nqIIrgAnEs6uNuLd1R6vvPYaXnn1Nbz72XcxrwsOy4LDvOBeKViriPimLfZ+MZxai65BkmyAGVqADDngpRYd3COfbTOo2+BwizbzG6gxSCcDZJzXbjO5PExg4Lqoutkc3UT01TZ0i1mg/jNAOpGMdDAskMACqwhoLrGh7+0x+qzKIf+DPs2tDE5ZvXiqVPYtWNcZ8zJjoFEcypi0yrIE/AzTgKz1BbVgheyPJKltJSmMeeYR5jSDFjhig85TVUKQau0YQ0t4Qt3YWIfUEbPusLCvs9sJAuKJ7tzn2p0gAgRgqNXXrOc+VZJYcgVR1qQhktMuMbWNd07mYSCqUQUZoP0N9szElpUoa/LRpD95IORRtLprZRQN/KEk0I7tAGklkzQMuHf/AV5/402Mux3meZZQTv2ZSkHmUUqRmO+6DYEFuNWws0s4OEWhsR+gToFlRG8LGPt5FlDQLAaWo8C00I6aN3nqG5Q3YlC7D7dLsF2OqLCMmzLe5n0NF90noAIxqIp1vraQRl5RgEJgdQBD1VkxR0FucnXztahu0jXX5Jwz8pgwJMIwjBhGyTKNlFT7T16jEBBUl2nAAMaodScAgf4myhjaqVWSfnCV7EUl6AhQ2RXWIIjCUBEemSi0mdvtSn0x4uDdIQJh1zi8ty1N4kPgwSc4RyzsSf3OiIzi9IAYcRAtckoS6LOQXEuUkIdB6s5rAMlaVuEO+hqC1iTIGTxUDGXA1dUV3nzrLbzy6qv4wrvvagy55JxblhnjOIBz8jTd3enz3ho3DIo/VjcQYj8E5j1n2vOOYThDMW6nz9MNR2iQOc6NEYC4uZr5rs1qF5lIdrj7A9+eyWd/P2dF6JqZCplOAK2pAcODQ2CNQGCqRrSArJUYQEGrxOwIYT4e8eTxE+zXPfb3WLwGwZJdesxIw9B8GqjVo/QUcqpJHMDgOvmarPOMUrZ7jzUEmVv9A26ZkCg1UYTjtzbJQc7P37nTf3me7wQRSATcS+SQR0x/dhBk8Ss1c4sS2CZCP2cf2fca94rZXJQjkVDylKHEQCIE01oxpAFzWdzzbxyVcOjiZ0oAZ1AuQJKowjfeeANvf/xtPH30vnKYY0tjXqvmoxP40RxkbMQB3eqGdjmRCJo7w6MK7DAyTufC5PBGSDbWhM40F78Xtx588/Uw/+RbJ+qI57X4ngqxFCLMx4nnozYiJQqOLja5FO16qKDUmEggVtCAMADz8YiHD9/D/ngPbw4DRi1FnrTiEKUWxUcJQCavPA9jTiTiYRoyMhjDsqKkBOKCCK5sXchNrHCU34iY3tspvYE4//acVquG2uZxMPAREQfGDM+SItC4uURWAAu1LUCAlgCDT/wlvYB9IUgB2gwx2Ew1N+SUCMOYcJzbAxjAvKyY5xnTbo/k+QEBJslPgJyRh4pxnPDKq6/iE1/1Vfj8u+/g8fvvY15mlLKiBfMUTTRmrsTk3PTsSDp4ns/SPvPLIRNR/LsMNz4Ta+KQZokJovyZ92pvghLw/H23Rp/62NO7KxhFR+YFZOILvJHRw+5TNpRjGZWJVAHTntXQTyf7SP9rxbMnTzEvC+6/+goe0CsaKSoZhRjKuUU26fcVASKwCHJIQ9ZkNCm8zx2qve/slHuDU32zM8wrE9yHyLuoBGyIL23Wo0fH23Z3iABU707tmg1CkAD576STSKSQWOeWiS8MdbNjIgrQ9GLiBitvTDkhV/UmVITAzChlxbPrA6b9vnEWqWCq5qMMHhjDxNjfu4ePv/1xfPztt3G4vpaCFYvFESwoqtTPBRJi7MDdlHjsyjDanFLiNle0GVdDR5tDFmhe3G1m7biZgzduXC/cmIyNPadFU+b2WZUaAez3dDs07YN+Y7ewYSVwSvCICBloKMAINzcObKnPE0lVIUFsRWT8bGXmjEGwzru+1/erZJ9KRsRUZ7C1QvSTod/l1v/IuTneYwloYKbYc4f/HHE9s+ibdieIgJJhNN6OAAktW5DJdWckgGhOic/0do6rUHdQLNe7OIEk0MpeeVgSkSasZcb14RrjU4k0G4YRGalxXS1TRgMj7YDX33wTH//Kr8S7n3sXy/GA4yyeg5JIQjYMD3E0bQvIsEQRRP6RHcZm9+V+YP5tirfbBf97o6Tj88TTifCZw729UpmRNwqrk+8EhRxwumElEEnGZW4UTYnY+fT5OLdKsRaRqYNWbhmt5Farr98iLL4euz1WLjCxqZFnYz52QO1gadYpaGo7JTRibqaABMRCAdP+x7nTvnjCEbInhvm8Ca19yHYniIBsDIuHxuZfnYZEvr1dcRgRcof3t/xkO31NfhbqDsnoUiWGIGlizpwH5AHIa0FOGcyM+Tjj6dOnGMdJ05S3JKLChZOUIh+A/X6PN7/iLbz2+uv4/LvvSHkqJQQStZgwZk0M1XG4zeSc+dtDjP1zU1ipC2w48Dc99iQ9e/iw+mY/3+SsKXoKnKyG+Y9ndOvUFFvk0OGid2a7sq4HCfN2jgmaDoAoKeLpiYY/Wy8P4wAu0Mw/klVqS2iNKDj6cZldSYXuKSlkI8lrFjLX4qCTCS+u0HToNYEToZJkFDKSU0+S7dwKeMFW6CYCcieIAMDgVICafFkshNLOtvmA22EjI59hZk4h4+X3AYoulBDkRKgDI60WTAKMY8a6Vv2bkFPGvM44HI9YlhlXV3t53JYYJQI4gYaMV157HV/xsY/h6ZPHKGUNRAAYhwFrUQA5Gq+qYTDmEi0oKHFwrVYo24Za9PC3Woc+2jMHLqX2DOl2u2frpRl/ayhF/mOQmhnwtJ+OCPpviRXjps3bHGXc/Bfkbo73OXLcPqGtqXHhqMQNk9KsGESoLMlBLHehIDZN1a0cI7H4WIi7uvaW2a0p4KSoijCkhAzCMmSsQ0YqOucu2lhwEDlCcPTBGiMTrS9958/PoSuQu2nXZb5MBu4IEQAA1bTWsPLhVPvGN+2XTYSN2pAChWvn3tFtJYN4gOSMCBuIxAac9SdlKUmeiLCuBcd5RgvdtY1KrrJnAKgJV/fv4a2PfRzvfeHzePzwEa6vD5imUSrYloqaVqwQn4SopSfL/gvjOpANFkubpZ47MLdAK6QIgOMUKEQNpcWptg0Yn+VixKa5xcFOPwMxj3/LJNzm2T5sirDtg0n/HwiIEagACOP9HPeDWwNMFtckMUmQ2SYnJiweQBdKzXQFlnptXmaspThBcuesGsUD6YVVthKXZ011lxJoSFh3mnhkTWAeBKmpW3r0P/cgIp0+zyLgSOOUmMOmJVzfKpZPyfhpuyNEQE4euccY+TU71e5Cw2jhl91oxe2yDx5i31jdu9C2oGfYJnMbFm6VBkKqigA0vNjiBNZScFQlH3n6ceHoFZATzQCoYJgmvPHWm3j9rbfw9MkTHI7XmA4jdrtJnEQyAVixFmBMg/ZMvMiE++kGqIxU+4UUN9P+WvL/SN4BMu2ifU62dXUywfA8FDqPcfr6WfM3N0WWEgHSt/OZuWZA1jY85FKUYQrXjUBbRzgc9NiXuKaUkltuKBEo504pGAmA5UCozFiLVqLWxCu1FBEHnEBqBKG7/26xOQAuMP+BpHEnwzjIz5AljgDsGawo2VjY38m8Ahg0O3Ub+6lAFP88nUsGQgn4m4SBG/ON/E434/7hx5qM6OQbbROScqONs0x4tPzT/8/kt0YAoIddnJcyEYZBEECmhIE0pSkzyrxKcYlaW3KT1NADkWqdCbi6fw+vv/EGpv0eRUtbSYWjFaVKodJSVliJbDHbNc7cosnigEwZpcRTb6ntF0ENXKWwCcTL0pRblkLNs+AkncZMKpPS8/bOaYvd5PazjeC71HxUJI5aMSNRd+gs1+BGbLHqwdli+ZUAGKKMhIurJRatKFUCh+bFUoVp2fJS2ntN9LFmTi2eRVT643UvlHgNOWHIyRnIViwx8cgTp4YUcKLAbCHEbZY2WMQAGVsyGktZFp6z8QDt+nBe5vidbUT0LoCnAD73ovvyIdpX4KPdf+CjP4aPev+B394x/HPM/LHtxTtBBACAiP4+M//+F92PD9o+6v0HPvpj+Kj3H3gxY7hD4sDL9rK9bC+ivSQCL9vL9mXe7hIR+EsvugMfsn3U+w989MfwUe8/8ALGcGd0Ai/by/ayvZh2l5DAy/ayvWwvoL1wIkBE/yYR/SoR/ToRff+L7s9tGxH9JhH9IhH9PBH9fb32JhH9LSL6Nf33jRfdz9iI6EeJ6B0i+qVw7WyfSdp/o+vyC0T0LS+u597Xc/3/ASL6tK7DzxPRd4bP/oz2/1eJ6A+/mF63RkRfQ0R/l4j+IRH9MhH9R3r9xa5B50DxO/wDCQr8DQBfD2AC8A8AfOOL7NMX0fffBPAVm2v/JYDv19+/H8B/8aL7uenftwP4FgC/9Lw+Q+pJ/i8Qj5Q/AOBn7mj/fwDAf3zm3m/U/bQD8HW6z/IL7v8nAHyL/v4KgH+k/Xyha/CikcC3Afh1Zv7HzDwD+AkAn3rBffow7VMAfkx//zEAf+TFdeW0MfP/DuALm8uX+vwpAH+Fpf00gNdJStC/sHah/5fapwD8BDMfmfmfQArkfttvW+du0Zj5M8z8c/r7YwC/AuCTeMFr8KKJwCcB/NPw92/ptY9CYwD/KxH9LBH9B3rtbW5l2P8ZgLdfTNe+qHapzx+ltfk+hcs/GkSwO91/IvpdAH4fgJ/BC16DF00EPsrtDzLztwD4DgDfS0TfHj9kwXMfKdPLR7HPAH4YwD8P4JsBfAbAD77Q3tyiEdEDAD8J4E8x8/vxsxexBi+aCHwawNeEv79ar935xsyf1n/fAfA/QKDmZw2u6b/vvLge3rpd6vNHYm2Y+bPMXFgiZP4yGuS/k/0nohFCAP4qM/8NvfxC1+BFE4H/G8A3ENHXEdEE4LsA/NQL7tNzGxHdJ6JX7HcA/waAX4L0/bv1tu8G8DdfTA+/qHapzz8F4I+rhvoPAHgUIOudaRsZ+Y9C1gGQ/n8XEe2I6OsAfAOAv/c73b/YSMIifwTArzDzD4WPXuwavEhtadCA/iOI9vbPvuj+3LLPXw/RPP8DAL9s/QbwFoC/A+DXAPxtAG++6L5u+v3jEMi8QOTLP3GpzxCN9H+r6/KLAH7/He3/f6f9+wU9NJ8I9/9Z7f+vAviOO9D/PwiB+r8A4Of15ztf9Bq89Bh82V62L/P2osWBl+1le9lecHtJBF62l+3LvL0kAi/by/Zl3l4SgZftZfsyby+JwMv2sn2Zt5dE4GV72b7M20si8LK9bF/m7SUReNleti/z9v8DEsPGXohBWREAAAAASUVORK5CYII=",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import cv2\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "# Get a single image from the dataset\n",
+    "image_path   = '/home/air/Spoof/Implementation-patchnet/images/LCC_FASD/LCC_FASD_development/spoof/FT720P_G780_REDMI4X_id0_s0_15.png'\n",
+    "\n",
+    "image = get_single_image_x(image_path)\n",
+    "\n",
+    "# Convert the image from BGR to RGB\n",
+    "image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
+    "\n",
+    "# Display the image\n",
+    "plt.imshow(image)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "ValueError",
+     "evalue": "setting an array element with a sequence. The requested array has an inhomogeneous shape after 1 dimensions. The detected shape was (2,) + inhomogeneous part.",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
+      "\u001b[0;32m/tmp/ipykernel_770267/852232072.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     11\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     12\u001b[0m \u001b[0;31m# Display the image\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 13\u001b[0;31m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mimshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mimage\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     14\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/.local/lib/python3.10/site-packages/matplotlib/pyplot.py\u001b[0m in \u001b[0;36mimshow\u001b[0;34m(X, cmap, norm, aspect, interpolation, alpha, vmin, vmax, origin, extent, interpolation_stage, filternorm, filterrad, resample, url, data, **kwargs)\u001b[0m\n\u001b[1;32m   2693\u001b[0m         \u001b[0minterpolation_stage\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfilternorm\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfilterrad\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m4.0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2694\u001b[0m         resample=None, url=None, data=None, **kwargs):\n\u001b[0;32m-> 2695\u001b[0;31m     __ret = gca().imshow(\n\u001b[0m\u001b[1;32m   2696\u001b[0m         \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcmap\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcmap\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnorm\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnorm\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maspect\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0maspect\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2697\u001b[0m         \u001b[0minterpolation\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0minterpolation\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0malpha\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0malpha\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvmin\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mvmin\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/.local/lib/python3.10/site-packages/matplotlib/__init__.py\u001b[0m in \u001b[0;36minner\u001b[0;34m(ax, data, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1444\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0minner\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0max\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1445\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mdata\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1446\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0max\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msanitize_sequence\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1447\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1448\u001b[0m         \u001b[0mbound\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnew_sig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0max\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/.local/lib/python3.10/site-packages/matplotlib/axes/_axes.py\u001b[0m in \u001b[0;36mimshow\u001b[0;34m(self, X, cmap, norm, aspect, interpolation, alpha, vmin, vmax, origin, extent, interpolation_stage, filternorm, filterrad, resample, url, **kwargs)\u001b[0m\n\u001b[1;32m   5661\u001b[0m                               **kwargs)\n\u001b[1;32m   5662\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 5663\u001b[0;31m         \u001b[0mim\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   5664\u001b[0m         \u001b[0mim\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_alpha\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0malpha\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   5665\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mim\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_clip_path\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/.local/lib/python3.10/site-packages/matplotlib/image.py\u001b[0m in \u001b[0;36mset_data\u001b[0;34m(self, A)\u001b[0m\n\u001b[1;32m    695\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mA\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mPIL\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mImage\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mImage\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    696\u001b[0m             \u001b[0mA\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpil_to_array\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mA\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# Needed e.g. to apply png palette.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 697\u001b[0;31m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_A\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcbook\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msafe_masked_invalid\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mA\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcopy\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    698\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    699\u001b[0m         if (self._A.dtype != np.uint8 and\n",
+      "\u001b[0;32m~/.local/lib/python3.10/site-packages/matplotlib/cbook/__init__.py\u001b[0m in \u001b[0;36msafe_masked_invalid\u001b[0;34m(x, copy)\u001b[0m\n\u001b[1;32m    712\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    713\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0msafe_masked_invalid\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcopy\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 714\u001b[0;31m     \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msubok\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcopy\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcopy\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    715\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdtype\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0misnative\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    716\u001b[0m         \u001b[0;31m# If we have already made a copy, do the byteswap in place, else make a\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;31mValueError\u001b[0m: setting an array element with a sequence. The requested array has an inhomogeneous shape after 1 dimensions. The detected shape was (2,) + inhomogeneous part."
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "ename": "",
+     "evalue": "",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31mThe Kernel crashed while executing code in the the current cell or a previous cell. Please review the code in the cell(s) to identify a possible cause of the failure. Click <a href='https://aka.ms/vscodeJupyterKernelCrash'>here</a> for more info. View Jupyter <a href='command:jupyter.viewOutput'>log</a> for further details."
+     ]
+    }
+   ],
+   "source": [
+    "import cv2\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "# Get a single image from the dataset\n",
+    "image_path   = '/home/air/Spoof/Implementation-patchnet/images/LCC_FASD/LCC_FASD_development/spoof/FT720P_G780_REDMI4X_id0_s0_15.png'\n",
+    "\n",
+    "image = get_single_image_x_RGB(image_path)\n",
+    "\n",
+    "# Convert the image from BGR to RGB\n",
+    "image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
+    "\n",
+    "# Display the image\n",
+    "plt.imshow(image)\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.12"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/dataset/transforms-train.jpg b/dataset/transforms-train.jpg
new file mode 100644
index 0000000..2ced72f
Binary files /dev/null and b/dataset/transforms-train.jpg differ
diff --git a/dataset/transforms-val.jpg b/dataset/transforms-val.jpg
new file mode 100644
index 0000000..f0a4435
Binary files /dev/null and b/dataset/transforms-val.jpg differ
diff --git a/transforms-train1.jpg b/transforms-train1.jpg
new file mode 100644
index 0000000..26e4f11
Binary files /dev/null and b/transforms-train1.jpg differ