diff --git a/Probing.png b/Probing.png
new file mode 100644
index 00000000..7203abdd
Binary files /dev/null and b/Probing.png differ
diff --git a/qtensor/contraction_backends/__init__.py b/qtensor/contraction_backends/__init__.py
index e07ac332..0ecea6d4 100644
--- a/qtensor/contraction_backends/__init__.py
+++ b/qtensor/contraction_backends/__init__.py
@@ -4,38 +4,134 @@
 from .torch import TorchBackend
 from .cupy import CuPyBackend
 from .mkl import CMKLExtendedBackend
+from .cupy import CuPyBackend
+# from .cutensor import CuTensorBackend
 from .transposed import TransposedBackend
 from .opt_einsum import OptEinusmBackend
-from .performance_measurement_decorator import PerfNumpyBackend, PerfBackend
+# from .transpose_backend import NumpyTranspoedBackend, TorchTransposedBackend, CupyTransposedBackend, CutensorTransposedBackend
+from .torch_mix import TorchMixBackend
+from .performance_measurement_decorator import PerfNumpyBackend, PerfBackend, GPUPerfBackend
+from .mix_decorator import MixBackend
+from .torch_profiled import TorchEmbeddedBackend
 
 def get_backend(name):
     backend_dict = {
+        'mkl': CMKLExtendedBackend,
         'einsum':NumpyBackend,
-        'torch': TorchBackend,
-        'mkl':CMKLExtendedBackend,
-        'tr_einsum': TransposedBackend,
         'opt_einsum': OptEinusmBackend,
-        'cupy': CuPyBackend
+        'torch_cpu': TorchBackend,
+        'torch_gpu': TorchBackend,
+        'cupy': CuPyBackend,
+        # 'cutensor': CuTensorBackend,
+        # 'tr_einsum': NumpyTranspoedBackend,
+        # 'tr_torch': TorchTransposedBackend,
+        # 'tr_cupy': CupyTransposedBackend,
+        # 'tr_cutensor': CutensorTransposedBackend,
+        'torch_mix': TorchMixBackend
+    }
+    if name == "torch_cpu":
+        return backend_dict['torch_cpu'](device = "cpu")
+    else:
+        return backend_dict[name]()
+
+
+def get_embedded_backend(name):
+    backend_dict = {
+        'torch_gpu': TorchEmbeddedBackend
     }
-    if name in ["torch_gpu", "torch_cpu"]:
-        return backend_dict['torch'](device = name[-3:])
+    if name == "torch_cpu":
+        return backend_dict['torch_cpu'](device = "cpu")
     else:
         return backend_dict[name]()
 
-def get_perf_backend(name):
+def get_cpu_perf_backend(name):
     class MyPerfBackend(PerfBackend):
         Backend = {
+            'mkl': CMKLExtendedBackend,
             'einsum':NumpyBackend,
-            'torch': TorchBackend,
-            'torch_cpu': TorchBackend,
-            'torch_gpu': TorchBackend,
-            'mkl':CMKLExtendedBackend,
-            'tr_einsum': TransposedBackend,
             'opt_einsum': OptEinusmBackend,
+            'torch_cpu': TorchBackend,     
+            # 'tr_einsum': NumpyTranspoedBackend,
+        }[name]
+
+    if name == "torch_cpu":
+        return MyPerfBackend(device="cpu")
+    else:
+        return MyPerfBackend()
+
+def get_gpu_perf_backend(name):
+    class MyPerfBackend(GPUPerfBackend):
+        Backend = {
+            'torch_gpu': TorchBackend,
             'cupy': CuPyBackend,
+            # 'cutensor': CuTensorBackend,
+            # 'tr_torch': TorchTransposedBackend,
+            # 'tr_cupy': CupyTransposedBackend,
+            # 'tr_cutensor': CutensorTransposedBackend
         }[name]
 
-    if name in ["torch_gpu", "torch_cpu"]:
-        return MyPerfBackend(device = name[-3:])
+    if name == "torch_gpu":
+        return MyPerfBackend(device="gpu")
     else:
         return MyPerfBackend()
+
+
+
+# def get_mixed_backend(cpu_name, gpu_name):
+#     class MyMixedBackend(MixBackend):
+#         CBE = {
+#             'einsum':NumpyBackend,
+#             'torch_cpu': TorchBackend,
+#             'mkl':CMKLExtendedBackend,
+#             'opt_einsum': OptEinusmBackend,
+#             'tr_einsum': NumpyTranspoedBackend,
+#             'opt_einsum': OptEinusmBackend,
+#         }[cpu_name]
+#         GBE = {
+#             'torch_gpu': TorchBackend,
+#             'cupy': CuPyBackend,
+#             'tr_torch': TorchTransposedBackend,
+#             'tr_cupy': CupyTransposedBackend,
+#             'tr_cutensor': CutensorTransposedBackend
+#         }[gpu_name]
+    
+#     if cpu_name == "torch_cpu":
+#         return MyMixedBackend(device = "cpu")
+#     else:
+#         return MyMixedBackend()
+
+def get_mixed_backend(cpu_name, gpu_name, threshold = 11):
+
+    cpu_be = get_backend(cpu_name)
+    gpu_be = get_backend(gpu_name)
+    # mix_name = cpu_name +"-"+ gpu_name
+    
+    # threshold_dict = {
+    #     "einsum-cupy":16,
+    #     "torch_cpu-torch_gpu":11,
+    #     "einsum-torch_gpu":13
+    # }
+
+    # if mix_name in threshold_dict:
+    #     threshold = threshold_dict[mix_name]
+
+    return MixBackend(cpu_be, gpu_be, threshold)
+
+
+def get_mixed_perf_backend(cpu_name, gpu_name,threshold = 11):
+    
+    cpu_be = get_cpu_perf_backend(cpu_name)
+    gpu_be = get_gpu_perf_backend(gpu_name)
+    mix_name = cpu_name +"-"+ gpu_name
+    
+    threshold_dict = {
+        "einsum-cupy":16,
+        "torch_cpu-torch_gpu":11,
+        "einsum-torch_gpu":13
+    }
+
+    if mix_name in threshold_dict:
+        threshold = threshold_dict[mix_name]
+
+    return MixBackend(cpu_be, gpu_be, threshold)
+
diff --git a/qtensor/contraction_backends/cupy.py b/qtensor/contraction_backends/cupy.py
index 8d1dfa3d..e66221c9 100644
--- a/qtensor/contraction_backends/cupy.py
+++ b/qtensor/contraction_backends/cupy.py
@@ -1,6 +1,8 @@
 import qtree
 from qtensor.tools.lazy_import import cupy as cp
+import numpy as np
 from qtensor.contraction_backends import ContractionBackend
+from qtensor.contraction_backends.numpy import get_einsum_expr
 
 mempool = mempool = cp.get_default_memory_pool()
 
@@ -20,8 +22,8 @@ def process_bucket(self, bucket, no_sum=False):
             '''
             Change 1: Using cp.einsum not torch.einsum
             ''' 
-            result_data = cp.einsum(expr, result_data, tensor.data)
-
+            result_data = cp.einsum(expr, cp.asarray(result_data), cp.asarray(tensor.data))
+            #print("result data: ",type(result_data))
             # Merge and sort indices and shapes
             result_indices = tuple(sorted(
                 set(result_indices + tensor.indices),
@@ -47,6 +49,36 @@ def process_bucket(self, bucket, no_sum=False):
                                 data=cp.sum(result_data, axis=0))
         return result
 
+    def process_bucket_merged(self, ixs, bucket, no_sum=False):
+        result_indices = bucket[0].indices
+        result_data = bucket[0].data
+        all_indices = set(sum((list(t.indices) for t in bucket), []))
+        result_indices = all_indices - set(ixs)
+        all_indices_list = list(all_indices)
+        to_small_int = lambda x: all_indices_list.index(x)
+        
+        expr = get_einsum_expr(bucket, all_indices_list, result_indices)
+
+        params = []
+        for tensor in bucket:
+            params.append(tensor.data)
+            params.append(list(map(to_small_int, tensor.indices)))
+        params.append(list(map(to_small_int, result_indices)))
+        
+        expect = len(result_indices)
+
+        result_data = cp.einsum(*params)
+
+        if len(result_indices) > 0:
+            first_index, *_ = result_indices
+            tag = str(first_index)
+        else:
+            tag = 'f'
+
+        result = qtree.optimizer.Tensor(f'E{tag}', result_indices,
+                            data=result_data)
+        return result
+
     def get_sliced_buckets(self, buckets, data_dict, slice_dict):
         mempool.free_all_blocks()
         sliced_buckets = []
@@ -105,4 +137,8 @@ def get_sliced_buckets(self, buckets, data_dict, slice_dict):
         return sliced_buckets
 
     def get_result_data(self, result):
-        return result.data
\ No newline at end of file
+        #print(type(result.data))
+        try:
+            return result.data.get()
+        except :
+            return result.data
\ No newline at end of file
diff --git a/qtensor/contraction_backends/cutensor.py b/qtensor/contraction_backends/cutensor.py
new file mode 100644
index 00000000..d5133e42
--- /dev/null
+++ b/qtensor/contraction_backends/cutensor.py
@@ -0,0 +1,85 @@
+import qtree
+from qtensor.tools.lazy_import import cupy as cp
+from qtensor.contraction_backends import ContractionBackend
+from qtensor.contraction_backends import CuPyBackend
+from cupy import cutensor as cupy_cutensor
+
+mempool = mempool = cp.get_default_memory_pool()
+
+class CuTensorBackend(CuPyBackend):
+    
+    # Replace all torch methods with cupy's analog
+    
+    def process_bucket(self, bucket, no_sum=False):
+        result_indices = bucket[0].indices
+        result_data = bucket[0].data
+        for tensor in bucket[1:]:
+
+            expr = qtree.utils.get_einsum_expr(
+                list(map(int, result_indices)), list(map(int, tensor.indices))
+            )
+
+            a, b, c, mode_a, mode_b, mode_c, desc_a, desc_b, desc_c = self.get_ready(expr, result_data, tensor.data)
+            result_data = cupy_cutensor.contraction(1.0, a, desc_a, mode_a, 
+                        b, desc_b, mode_b, 0, 
+                        c, desc_c, mode_c)
+
+            # Merge and sort indices and shapes
+            result_indices = tuple(sorted(
+                set(result_indices + tensor.indices),
+                key=int)
+            )
+
+        if len(result_indices) > 0:
+            if not no_sum:  # trim first index
+                first_index, *result_indices = result_indices
+            else:
+                first_index, *_ = result_indices
+            tag = first_index.identity
+        else:
+            tag = 'f'
+            result_indices = []
+
+        # reduce
+        if no_sum:
+            result = qtree.optimizer.Tensor(f'E{tag}', result_indices,
+                                data=result_data)
+        else:
+            result = qtree.optimizer.Tensor(f'E{tag}', result_indices,
+                                data=cp.sum(result_data, axis=0))
+        return result
+
+
+    @staticmethod
+    def get_ready(contraction, a, b):
+        # get ready
+        inp, out = contraction.split('->')
+        size = inp.split(',')
+        out_size =cp.full(len(out), 2).tolist() # fill_number = 2
+
+        # TO DO
+        mode_a = tuple(size[0])
+        mode_b = tuple(size[1])
+        mode_c = tuple(out)
+
+        # generate tensor c
+        shape_a, shape_b = a.shape, b.shape
+        shape_c = tuple(out_size)
+        
+        c = cp.random.rand(*shape_c).astype(a.dtype)
+
+        # manually cast b to a's type
+        b = b.astype(a.dtype)
+
+        # generate tensor descriptor
+        desc_a = cupy_cutensor.create_tensor_descriptor(a)
+        desc_b = cupy_cutensor.create_tensor_descriptor(b)
+        desc_c = cupy_cutensor.create_tensor_descriptor(c)
+
+        
+        if not a.flags['C_CONTIGUOUS']:
+            a = cp.ascontiguousarray(a)
+        if not b.flags['C_CONTIGUOUS']:
+            b = cp.ascontiguousarray(b)
+
+        return a, b, c, mode_a, mode_b, mode_c, desc_a, desc_b, desc_c
\ No newline at end of file
diff --git a/qtensor/contraction_backends/mix_decorator.py b/qtensor/contraction_backends/mix_decorator.py
new file mode 100644
index 00000000..c9c6d6c0
--- /dev/null
+++ b/qtensor/contraction_backends/mix_decorator.py
@@ -0,0 +1,92 @@
+from qtensor.contraction_backends import ContractionBackend
+"""
+class MixedBe(ConBE):
+    be1: cpu_be
+    be2: gpu_be
+
+    def get_sliced_bucket():
+        normal slicing
+            either use be1_get_sliuced or naive implementation
+            np.array for convinience
+    
+    def process_bucket():
+        - Check input bucket width
+        - If larger than 8, use gpu_be.process(bucket)
+        - Else, use less than 8, use cpu_be.process(bucket)
+
+    def get_result_data():
+        - always use gpu_be's get_result
+        - so that the gpu_be shall handle the gpu-cpu transfer all the time
+
+"""
+
+
+'''
+Input:  Array of either (indices) or a tensor
+        If a tensor, use t.indices for conversion
+'''
+def bucketWidth(bucket):
+    bucket_width = 0
+    for tensor in bucket:
+        tensor_len = 0
+        if type(tensor) is tuple:
+            tensor_len = len(tensor)
+            if tensor_len > bucket_width:
+                bucket_width = tensor_len
+        else:
+            tensor_len = len(tensor.indices)
+            if tensor_len > bucket_width:
+                bucket_width = tensor_len
+    return bucket_width
+
+
+def AccurateBucketWidth(bucket):
+    indices_set = set()
+    for tensor in bucket:
+        if type(tensor) is tuple:
+            for index in tensor:
+                indices_set.add(index)
+        else:
+            for index in tensor.indices:
+                indices_set.add(index)
+
+    return len(indices_set)
+    
+
+
+
+'''
+I/O: Actual BE Objects -> Wrapped Class
+TODO: process_bucket_merged() for its own, when when we test the merged simulators, we create the merged simulator
+'''
+
+class MixBackend(ContractionBackend):
+
+    def __init__(self, cpu_be, gpu_be, watershed):
+        self.cpu_be = cpu_be
+        self.gpu_be = gpu_be
+        self.watershed = watershed
+    
+    def process_bucket(self, bucket, no_sum = False):
+        # bucket_width = bucketWidth(bucket)
+        accc_width = AccurateBucketWidth(bucket)
+        # if accc_width != bucket_width:
+        #      print(accc_width, bucket_width)
+        if accc_width >= self.watershed:
+            #print(f"In GPU, width {accc_width}")
+            return self.gpu_be.process_bucket(bucket, no_sum)
+        else:
+            return self.cpu_be.process_bucket(bucket, no_sum)
+
+    def process_bucket_merged(self,ixs, bucket, no_sum=False):
+        accu_width = AccurateBucketWidth(bucket)
+        if accu_width >= self.watershed:
+            return self.gpu_be.process_bucket_merged(ixs, bucket, no_sum)
+        else:
+            return self.cpu_be.process_bucket_merged(ixs, bucket, no_sum)
+
+    def get_sliced_buckets(self, buckets, data_dict, slice_dict):
+        return self.cpu_be.get_sliced_buckets(buckets, data_dict, slice_dict)
+    
+    def get_result_data(self, result):
+        return self.gpu_be.get_result_data(result)
diff --git a/qtensor/contraction_backends/numpy.py b/qtensor/contraction_backends/numpy.py
index 26e9c56f..49ecd944 100644
--- a/qtensor/contraction_backends/numpy.py
+++ b/qtensor/contraction_backends/numpy.py
@@ -33,6 +33,16 @@ def __init__(self):
         #self.status_bar = tqdm(desc='Current status', position=3, bar_format='{desc}')
 
     def process_bucket(self, bucket, no_sum=False):
+        '''
+        TODO: Preprocess the bucket to make sure the all data are in numpy format
+        '''
+        for tensor in bucket:
+            if not isinstance(tensor._data, np.ndarray):
+                try:
+                    tensor._data = tensor._data.cpu().numpy()
+                except:
+                    pass
+
         res = np_framework.process_bucket_np(bucket, no_sum=no_sum)
         return res
 
@@ -43,12 +53,16 @@ def process_bucket_merged(self, ixs, bucket, no_sum=False):
         result_indices = all_indices - set(ixs)
         all_indices_list = list(all_indices)
         to_small_int = lambda x: all_indices_list.index(x)
+        
+        expr = get_einsum_expr(bucket, all_indices_list, result_indices)
+        # print(expr)
+
         params = []
         for tensor in bucket:
             params.append(tensor.data)
             params.append(list(map(to_small_int, tensor.indices)))
         params.append(list(map(to_small_int, result_indices)))
-        #print(expr)
+        
         expect = len(result_indices)
         # used to check how well optimizer performs
         #if 2**expect < 0:# info.largest_intermediate:
@@ -57,8 +71,8 @@ def process_bucket_merged(self, ixs, bucket, no_sum=False):
         #return opt_einsum.contract(contraction, *tensors, optimize=path)
 
 
-        #print('result_indices',len(result_indices),  result_indices)
-        #print('einsumparams', params)
+        # print('result_indices',len(result_indices),  result_indices)
+        # print('einsumparams', *params)
         #result_data = np.einsum(*params)
         if expect > 33:
             result_data = opt_einsum.contract(*params)
diff --git a/qtensor/contraction_backends/performance_measurement_decorator.py b/qtensor/contraction_backends/performance_measurement_decorator.py
index 7f505003..9d4e8d0f 100644
--- a/qtensor/contraction_backends/performance_measurement_decorator.py
+++ b/qtensor/contraction_backends/performance_measurement_decorator.py
@@ -1,10 +1,25 @@
+from numpy.core.numeric import indices
 from qtensor.contraction_backends import ContractionBackend, NumpyBackend
 from qtensor.utils import ReportTable
 from pyrofiler import timing
+import torch
+
+def _accurateBucketWidth(bucket):
+    indices_set = set()
+    for tensor in bucket:
+        if type(tensor) is tuple:
+            for index in tensor:
+                indices_set.add(index)
+        else:
+            for index in tensor.indices:
+                indices_set.add(index)
+
+    return len(indices_set)
+
 
 class PerfBackend(ContractionBackend):
     Backend = ContractionBackend
-
+        
     def __init__(self, *args, print=False, num_lines=20, **kwargs):
         self.backend = self.Backend(*args, **kwargs)
         self._print = print
@@ -31,6 +46,12 @@ def process_bucket(self, bucket, no_sum=False):
                          , callback=self._profile_callback):
             return self.backend.process_bucket(bucket, no_sum=no_sum)
 
+    def process_bucket_merged(self, ixs, bucket, no_sum=False):
+        indices = [tensor.indices for tensor in bucket]
+        with timing('process bucket time', indices
+                         , callback=self._profile_callback):
+            return self.backend.process_bucket_merged(ixs, bucket, no_sum=no_sum)
+
     def get_sliced_buckets(self, buckets, data_dict, slice_dict):
         return self.backend.get_sliced_buckets(buckets, data_dict, slice_dict)
 
@@ -94,13 +115,16 @@ def gen_report(self, show = True):
         # -- report on totals
         # max_line should not be inolved for recording
         for indices, time in  data:
+            max_size = len(set.union(*[set(i) for i in indices]))
             self.report_table.record(
                 bucket_len = len(indices)
                 , time = time
                 , flop = self._perfect_bucket_flop(indices)
                 , FLOPS = self._perfect_bucket_flop(indices)/time
-                , max_size = max([len(ixs) for ixs in indices])
+                # , max_size = max([len(ixs) for ixs in indices])
+                , max_size = max_size
                 , min_size = min([len(ixs) for ixs in indices])
+                , width = _accurateBucketWidth(indices)
                 , result_size = len(set.union(*[set(i) for i in indices])) - 1
             )
         
@@ -120,3 +144,24 @@ def gen_report(self, show = True):
 
 class PerfNumpyBackend(PerfBackend):
     Backend = NumpyBackend
+
+
+class GPUPerfBackend(PerfBackend):
+    def process_bucket(self, bucket, no_sum=False):
+        indices = [tensor.indices for tensor in bucket]
+
+        start = torch.cuda.Event(enable_timing=True)
+        end = torch.cuda.Event(enable_timing=True)
+        start.record()
+
+        out = self.backend.process_bucket(bucket, no_sum=no_sum)
+        
+        end.record()
+        torch.cuda.synchronize()
+        time= start.elapsed_time(end)/1000
+
+        # sorted(self.backend.exprs.items(), key=lambda x: x[1], reverse=True)
+        # print("summary:",sorted(self.backend.exprs.items(), key=lambda x: x[1], reverse=True))
+
+        self._profile_callback(time,'process bucket time',indices)
+        return out
\ No newline at end of file
diff --git a/qtensor/contraction_backends/torch.py b/qtensor/contraction_backends/torch.py
index 533954e5..c79e905a 100644
--- a/qtensor/contraction_backends/torch.py
+++ b/qtensor/contraction_backends/torch.py
@@ -1,10 +1,9 @@
 from qtensor.tools.lazy_import import torch
 import qtree
 import numpy as np
-
-
-
+from qtree import np_framework
 from qtensor.contraction_backends import ContractionBackend
+from qtensor.contraction_backends.numpy import get_einsum_expr
 def qtree2torch_tensor(tensor, data_dict):
     """ Converts qtree tensor to pytorch tensor using data dict"""
     if isinstance(tensor.data, torch.Tensor):
@@ -19,21 +18,59 @@ def qtree2torch_tensor(tensor, data_dict):
 
 
 class TorchBackend(ContractionBackend):
-
-    def __init__(self, device = "cpu"):
+    def __init__(self, device = "gpu"):
         self.device = device
-        self.cuda_available = torch.cuda.is_available()
+        self.dtype = ['float', 'double', 'complex64', 'complex128']
+        self.width_dict = [set() for i in range(30)]
+        self.width_bc = [[0,0] for i in range(30)] #(#distinct_bc, #bc)
+        self.exprs = {}
 
 
     def process_bucket(self, bucket, no_sum=False):
         result_indices = bucket[0].indices
         result_data = bucket[0].data
+        
+        if not isinstance(result_data, torch.Tensor):
+            #print("Encountering: ",type(result_data))           
+            if self.device == 'gpu' and torch.cuda.is_available():
+                cuda = torch.device('cuda')
+                result_data = torch.from_numpy(result_data).to(cuda)
+            else:
+                result_data = torch.from_numpy(result_data)
+
         for tensor in bucket[1:]:
 
             expr = qtree.utils.get_einsum_expr(
                 list(map(int, result_indices)), list(map(int, tensor.indices))
             )
 
+
+            '''
+            Objective: Change Numpy Array into Tensor on GPU
+            '''            
+            if not isinstance(tensor._data, torch.Tensor):             
+                if self.device == 'gpu' and torch.cuda.is_available():
+                    cuda = torch.device('cuda')
+                    tensor._data = torch.from_numpy(tensor._data).to(cuda)
+                else:
+                    tensor._data = torch.from_numpy(tensor._data)
+
+            '''
+            Change: input data type may not be the same as the device type, hence we must make device type consistent with the backend device type
+            '''
+
+
+            if self.device == 'gpu':
+                if result_data.device != "gpu":
+                    result_data = result_data.to(torch.device('cuda'))
+                if tensor.data.device != "gpu":
+                    tensor._data = tensor._data.to(torch.device("cuda"))
+            else:
+                if result_data.device != "cpu":
+                    result_data = result_data.cpu()
+                if tensor.data.device != "cpu":
+                    tensor._data = tensor._data.cpu()
+
             result_data = torch.einsum(expr, result_data, tensor.data)
 
             # Merge and sort indices and shapes
@@ -61,6 +98,82 @@ def process_bucket(self, bucket, no_sum=False):
                                 data=torch.sum(result_data, axis=0))
         return result
 
+    def process_bucket_merged(self, ixs, bucket, no_sum=False):
+        result_indices = bucket[0].indices
+        # print("result_indices", result_indices)
+        result_data = bucket[0].data
+
+        if not isinstance(result_data, torch.Tensor):
+            #print("Encountering: ",type(result_data))           
+            if self.device == 'gpu' and torch.cuda.is_available():
+                cuda = torch.device('cuda')
+                result_data = torch.from_numpy(result_data).to(cuda)
+            else:
+                result_data = torch.from_numpy(result_data)
+
+
+
+
+        all_indices = set(sum((list(t.indices) for t in bucket), []))
+        result_indices = all_indices - set(ixs)
+        all_indices_list = list(all_indices)
+        to_small_int = lambda x: all_indices_list.index(x)
+        tensors = []
+        is128 = False
+        for tensor in bucket:
+
+            if not isinstance(tensor._data, torch.Tensor):             
+                if self.device == 'gpu' and torch.cuda.is_available():
+                    cuda = torch.device('cuda')
+                    tensor._data = torch.from_numpy(tensor._data).to(cuda)
+                else:
+                    tensor._data = torch.from_numpy(tensor._data)
+            
+            if self.device == 'gpu':
+                if result_data.device != "gpu":
+                    result_data = result_data.to(torch.device('cuda'))
+                if tensor.data.device != "gpu":
+                    tensor._data = tensor._data.to(torch.device("cuda"))
+            else:
+                if result_data.device != "cpu":
+                    result_data = result_data.cpu()
+                if tensor.data.device != "cpu":
+                    tensor._data = tensor._data.cpu()
+
+            if tensor.data.dtype in [torch.float64]:
+                tensors.append(tensor.data.type(torch.complex64))
+            else:
+                tensors.append(tensor.data)
+            if tensor.data.dtype == torch.complex128:
+                is128 = True
+        
+        if is128:
+            for i in range(len(tensors)):
+                tensors[i] = tensors[i].type(torch.complex128)
+        
+        expr = get_einsum_expr(bucket, all_indices_list, result_indices)
+        # print("expr:", expr)
+        if expr not in self.exprs.keys():
+            self.exprs[expr] = 1
+        else:
+            self.exprs[expr] += 1
+
+        expect = len(result_indices)
+        result_data = torch.einsum(expr, *tensors)
+
+        if len(result_indices) > 0:
+            first_index, *_ = result_indices
+            tag = str(first_index)
+        else:
+            tag = 'f'
+
+        result = qtree.optimizer.Tensor(f'E{tag}', result_indices,
+                            data=result_data)
+        
+        # print("summary:",sorted(self.exprs.items(), key=lambda x: x[1], reverse=True))
+        # print("# distinct buckets:", len(self.exprs))
+        return result
+        
     def get_sliced_buckets(self, buckets, data_dict, slice_dict):
         sliced_buckets = []
         for bucket in buckets:
@@ -70,15 +183,13 @@ def get_sliced_buckets(self, buckets, data_dict, slice_dict):
                 # sort tensor dimensions
                 transpose_order = np.argsort(list(map(int, tensor.indices)))
                 data = data_dict[tensor.data_key]
-                if not isinstance(data, torch.Tensor):
-                    if self.device == "cpu":
-                        data = torch.from_numpy(data)
+                if not isinstance(data, torch.Tensor):             
+                    if self.device == 'gpu' and torch.cuda.is_available():
+                        cuda = torch.device('cuda')
+                        data = torch.from_numpy(data).to(cuda)
                     else:
-                        if self.cuda_available:
-                            cuda = torch.device('cuda')
-                            data = torch.from_numpy(data).to(cuda)
-                        else:
-                            raise Exception("cuda is not available on this machine")
+                        data = torch.from_numpy(data)
+
                 data = data.permute(tuple(transpose_order))
                 # transpose indices
                 indices_sorted = [tensor.indices[pp]
@@ -107,4 +218,7 @@ def get_sliced_buckets(self, buckets, data_dict, slice_dict):
         return sliced_buckets
 
     def get_result_data(self, result):
-        return result.data
+        try:
+            return result.data.cpu()
+        except:
+            return result.data
\ No newline at end of file
diff --git a/qtensor/contraction_backends/torch_mix.py b/qtensor/contraction_backends/torch_mix.py
new file mode 100644
index 00000000..85099740
--- /dev/null
+++ b/qtensor/contraction_backends/torch_mix.py
@@ -0,0 +1,114 @@
+from qtensor.tools.lazy_import import torch
+import qtree
+import numpy as np
+from qtensor.contraction_backends import ContractionBackend
+def qtree2torch_tensor(tensor, data_dict):
+    """ Converts qtree tensor to pytorch tensor using data dict"""
+    if isinstance(tensor.data, torch.Tensor):
+        return tensor
+    if tensor.data is not None:
+        data = tensor.data
+    else:
+        data = data_dict[tensor.data_key]
+    torch_t = torch.from_numpy(data)
+    data_dict[tensor.data_key] = torch_t
+    return tensor.copy(data=torch_t)
+
+
+
+'bucket = [t.indices for t in bucket] for converting a tensor' 
+
+def bucketWidth(bucket):
+    """ Returns the width of a bucket"""
+    return len(max(bucket, key = len))
+
+
+
+class TorchMixBackend(ContractionBackend):
+
+    def __init__(self):
+        self.cuda_available = torch.cuda.is_available()
+
+
+    def process_bucket(self, bucket, no_sum=False):
+        result_indices = bucket[0].indices
+        result_data = bucket[0].data
+        for tensor in bucket[1:]:
+
+            expr = qtree.utils.get_einsum_expr(
+                list(map(int, result_indices)), list(map(int, tensor.indices))
+            )
+
+            result_data = torch.einsum(expr, result_data, tensor.data)
+
+            # Merge and sort indices and shapes
+            result_indices = tuple(sorted(
+                set(result_indices + tensor.indices),
+                key=int)
+            )
+
+        if len(result_indices) > 0:
+            if not no_sum:  # trim first index
+                first_index, *result_indices = result_indices
+            else:
+                first_index, *_ = result_indices
+            tag = first_index.identity
+        else:
+            tag = 'f'
+            result_indices = []
+
+        # reduce
+        if no_sum:
+            result = qtree.optimizer.Tensor(f'E{tag}', result_indices,
+                                data=result_data)
+        else:
+            result = qtree.optimizer.Tensor(f'E{tag}', result_indices,
+                                data=torch.sum(result_data, axis=0))
+        return result
+
+    def get_sliced_buckets(self, buckets, data_dict, slice_dict):
+        sliced_buckets = []
+        for bucket in buckets:
+            sliced_bucket = []
+            bucket_width = bucketWidth(bucket)
+            for tensor in bucket:
+                transpose_order = np.argsort(list(map(int, tensor.indices)))
+                data = data_dict[tensor.data_key]
+                if not isinstance(data, torch.Tensor):
+                    if self.cuda_available:
+                        if bucket_width > 8:
+                            cuda = torch.device('cuda')
+                            data = torch.from_numpy(data).to(cuda)
+                        else:
+                            data = torch.from_numpy(data)
+                    else:
+                        raise Exception("cuda is not available on this machine")
+                data = data.permute(tuple(transpose_order))
+                # transpose indices
+                indices_sorted = [tensor.indices[pp]
+                                  for pp in transpose_order]
+
+                # slice data
+                slice_bounds = []
+                for idx in indices_sorted:
+                    try:
+                        slice_bounds.append(slice_dict[idx])
+                    except KeyError:
+                        slice_bounds.append(slice(None))
+
+                data = data[tuple(slice_bounds)]
+
+                # update indices
+                indices_sliced = [idx.copy(size=size) for idx, size in
+                                  zip(indices_sorted, data.shape)]
+                indices_sliced = [i for sl, i in zip(slice_bounds, indices_sliced) if not isinstance(sl, int)]
+                assert len(data.shape) == len(indices_sliced)
+
+                sliced_bucket.append(
+                    tensor.copy(indices=indices_sliced, data=data))
+            sliced_buckets.append(sliced_bucket)
+
+        return sliced_buckets
+
+    def get_result_data(self, result):
+        return result.data
diff --git a/qtensor/contraction_backends/torch_profiled.py b/qtensor/contraction_backends/torch_profiled.py
new file mode 100644
index 00000000..0218f6ba
--- /dev/null
+++ b/qtensor/contraction_backends/torch_profiled.py
@@ -0,0 +1,292 @@
+from qtensor.tools.lazy_import import torch
+import qtree
+import numpy as np
+from qtree import np_framework
+from qtensor.contraction_backends import ContractionBackend
+from qtensor.contraction_backends.numpy import get_einsum_expr
+import pyrofiler
+import time
+
+
+
+
+def qtree2torch_tensor(tensor, data_dict):
+    """ Converts qtree tensor to pytorch tensor using data dict"""
+    if isinstance(tensor.data, torch.Tensor):
+        return tensor
+    if tensor.data is not None:
+        data = tensor.data
+    else:
+        data = data_dict[tensor.data_key]
+    torch_t = torch.from_numpy(data)
+    data_dict[tensor.data_key] = torch_t
+    return tensor.copy(data=torch_t)
+
+
+class TorchEmbeddedBackend(ContractionBackend):
+    def __init__(self, device = "gpu"):
+        self.device = device
+        self.dtype = ['float', 'double', 'complex64', 'complex128']
+        self.width_dict = [set() for i in range(30)]
+        self.width_bc = [[0,0] for i in range(30)] #(#distinct_bc, #bc)
+        self.exprs = {}
+
+
+    def process_bucket(self, bucket, bucket_index = 0, no_sum=False):
+
+        result_indices = bucket[0].indices
+        result_data = bucket[0].data
+        
+        if not isinstance(result_data, torch.Tensor):
+            #print("Encountering: ",type(result_data))           
+            if self.device == 'gpu' and torch.cuda.is_available():
+                cuda = torch.device('cuda')
+                result_data = torch.from_numpy(result_data).to(cuda)
+            else:
+                result_data = torch.from_numpy(result_data)
+
+        for t,tensor in enumerate(bucket[1:]):
+
+            '''
+            Entry Point 1
+            '''
+            with pyrofiler.PROF.timing('Get Einsum Expr', reference=(bucket_index,t)):
+                expr = qtree.utils.get_einsum_expr(
+                    list(map(int, result_indices)), list(map(int, tensor.indices))
+                )
+
+            # @pyrofiler.PROF.cpu(desc='Get Einsum Expr', reference=(bucket_index,t))
+            # def get_expr(result_indices, tensor):
+            #     return qtree.utils.get_einsum_expr(
+            #         list(map(int, result_indices)), list(map(int, tensor.indices))
+            #     )
+            
+            # expr = get_expr(result_indices, tensor)
+
+            '''
+            Entry Point 2
+            '''
+
+            with pyrofiler.PROF.timing('Data Type Adjust', reference=(bucket_index,t)):
+                if not isinstance(tensor._data, torch.Tensor):             
+                    if self.device == 'gpu' and torch.cuda.is_available():
+                        cuda = torch.device('cuda')
+                        tensor._data = torch.from_numpy(tensor._data).to(cuda)
+                    else:
+                        tensor._data = torch.from_numpy(tensor._data)
+
+
+            # @pyrofiler.PROF.cpu(desc='Data Type Adjust', reference=(bucket_index,t))
+            # def adjustType(tensor):
+            #     if not isinstance(tensor._data, torch.Tensor):             
+            #         if self.device == 'gpu' and torch.cuda.is_available():
+            #             cuda = torch.device('cuda')
+            #             tensor._data = torch.from_numpy(tensor._data).to(cuda)
+            #         else:
+            #             tensor._data = torch.from_numpy(tensor._data)
+            # adjustType(tensor)
+
+            '''
+            Entry Point 3
+            '''
+            with pyrofiler.PROF.timing('Device Transport', reference=(bucket_index,t)):
+                if self.device == 'gpu':
+                    if result_data.device != "gpu":
+                        result_data = result_data.to(torch.device('cuda'))
+                    if tensor.data.device != "gpu":
+                        tensor._data = tensor._data.to(torch.device("cuda"))
+                else:
+                    if result_data.device != "cpu":
+                        result_data = result_data.cpu()
+                    if tensor.data.device != "cpu":
+                        tensor._data = tensor._data.cpu()
+            # @pyrofiler.PROF.cpu(desc="Device Transport", reference=(bucket_index,t))            
+            # def transportData(tensor, result_data):
+            #     if self.device == 'gpu':
+            #         if result_data.device != "gpu":
+            #             result_data = result_data.to(torch.device('cuda'))
+            #         if tensor.data.device != "gpu":
+            #             tensor._data = tensor._data.to(torch.device("cuda"))
+            #     else:
+            #         if result_data.device != "cpu":
+            #             result_data = result_data.cpu()
+            #         if tensor.data.device != "cpu":
+            #             tensor._data = tensor._data.cpu()
+            
+            # transportData(tensor, result_data)
+
+            '''
+            Entry Point 4
+            '''
+            with pyrofiler.PROF.timing('Einsum Compute', reference=(bucket_index,t)):
+                result_data = torch.einsum(expr, result_data, tensor.data)
+
+
+            # @pyrofiler.PROF.cpu('Einsum Compute', reference=(bucket_index,t))
+            # def computeEinsum(expr, result_data, tensor):
+            #     return torch.einsum(expr, result_data, tensor.data)
+
+            # result_data = computeEinsum(expr, result_data, tensor)
+
+            '''
+            Entry Point 5
+            '''
+
+            with pyrofiler.PROF.timing('Result Indices', reference=(bucket_index,t)):
+                result_indices = tuple(sorted(
+                    set(result_indices + tensor.indices),
+                    key=int)
+                )
+
+            # @pyrofiler.PROF.cpu('Result Indices', reference=(bucket_index,t))
+            # def getResultIndices(result_indices, tensor):
+            #     return tuple(sorted(
+            #         set(result_indices + tensor.indices),
+            #         key=int)
+            #     )
+            
+            # result_indices = getResultIndices(result_indices, tensor)
+
+        if len(result_indices) > 0:
+            if not no_sum:  # trim first index
+                first_index, *result_indices = result_indices
+            else:
+                first_index, *_ = result_indices
+            tag = first_index.identity
+        else:
+            tag = 'f'
+            result_indices = []
+
+        # reduce
+        if no_sum:
+            result = qtree.optimizer.Tensor(f'E{tag}', result_indices,
+                                data=result_data)
+        else:
+            result = qtree.optimizer.Tensor(f'E{tag}', result_indices,
+                                data=torch.sum(result_data, axis=0))
+        return result
+
+    def process_bucket_merged(self, ixs, bucket, no_sum=False):
+        result_indices = bucket[0].indices
+        # print("result_indices", result_indices)
+        result_data = bucket[0].data
+
+        if not isinstance(result_data, torch.Tensor):
+            #print("Encountering: ",type(result_data))           
+            if self.device == 'gpu' and torch.cuda.is_available():
+                cuda = torch.device('cuda')
+                result_data = torch.from_numpy(result_data).to(cuda)
+            else:
+                result_data = torch.from_numpy(result_data)
+
+
+
+
+        all_indices = set(sum((list(t.indices) for t in bucket), []))
+        result_indices = all_indices - set(ixs)
+        all_indices_list = list(all_indices)
+        to_small_int = lambda x: all_indices_list.index(x)
+        tensors = []
+        is128 = False
+        for tensor in bucket:
+
+            if not isinstance(tensor._data, torch.Tensor):             
+                if self.device == 'gpu' and torch.cuda.is_available():
+                    cuda = torch.device('cuda')
+                    tensor._data = torch.from_numpy(tensor._data).to(cuda)
+                else:
+                    tensor._data = torch.from_numpy(tensor._data)
+            
+            if self.device == 'gpu':
+                if result_data.device != "gpu":
+                    result_data = result_data.to(torch.device('cuda'))
+                if tensor.data.device != "gpu":
+                    tensor._data = tensor._data.to(torch.device("cuda"))
+            else:
+                if result_data.device != "cpu":
+                    result_data = result_data.cpu()
+                if tensor.data.device != "cpu":
+                    tensor._data = tensor._data.cpu()
+
+            if tensor.data.dtype in [torch.float64]:
+                tensors.append(tensor.data.type(torch.complex64))
+            else:
+                tensors.append(tensor.data)
+            if tensor.data.dtype == torch.complex128:
+                is128 = True
+        
+        if is128:
+            for i in range(len(tensors)):
+                tensors[i] = tensors[i].type(torch.complex128)
+        
+        expr = get_einsum_expr(bucket, all_indices_list, result_indices)
+        # print("expr:", expr)
+        if expr not in self.exprs.keys():
+            self.exprs[expr] = 1
+        else:
+            self.exprs[expr] += 1
+
+        expect = len(result_indices)
+        result_data = torch.einsum(expr, *tensors)
+
+        if len(result_indices) > 0:
+            first_index, *_ = result_indices
+            tag = str(first_index)
+        else:
+            tag = 'f'
+
+        result = qtree.optimizer.Tensor(f'E{tag}', result_indices,
+                            data=result_data)
+        
+        # print("summary:",sorted(self.exprs.items(), key=lambda x: x[1], reverse=True))
+        # print("# distinct buckets:", len(self.exprs))
+        return result
+        
+    def get_sliced_buckets(self, buckets, data_dict, slice_dict):
+        sliced_buckets = []
+        for bucket in buckets:
+            sliced_bucket = []
+            for tensor in bucket:
+                # get data
+                # sort tensor dimensions
+                transpose_order = np.argsort(list(map(int, tensor.indices)))
+                data = data_dict[tensor.data_key]
+                if not isinstance(data, torch.Tensor):             
+                    if self.device == 'gpu' and torch.cuda.is_available():
+                        cuda = torch.device('cuda')
+                        data = torch.from_numpy(data).to(cuda)
+                    else:
+                        data = torch.from_numpy(data)
+
+                data = data.permute(tuple(transpose_order))
+                # transpose indices
+                indices_sorted = [tensor.indices[pp]
+                                  for pp in transpose_order]
+
+                # slice data
+                slice_bounds = []
+                for idx in indices_sorted:
+                    try:
+                        slice_bounds.append(slice_dict[idx])
+                    except KeyError:
+                        slice_bounds.append(slice(None))
+
+                data = data[tuple(slice_bounds)]
+
+                # update indices
+                indices_sliced = [idx.copy(size=size) for idx, size in
+                                  zip(indices_sorted, data.shape)]
+                indices_sliced = [i for sl, i in zip(slice_bounds, indices_sliced) if not isinstance(sl, int)]
+                assert len(data.shape) == len(indices_sliced)
+
+                sliced_bucket.append(
+                    tensor.copy(indices=indices_sliced, data=data))
+            sliced_buckets.append(sliced_bucket)
+
+        return sliced_buckets
+
+    def get_result_data(self, result):
+        try:
+            return result.data.cpu()
+        except:
+            return result.data
\ No newline at end of file
diff --git a/qtensor/contraction_backends/transpose_backend.py b/qtensor/contraction_backends/transpose_backend.py
new file mode 100644
index 00000000..0a5803ea
--- /dev/null
+++ b/qtensor/contraction_backends/transpose_backend.py
@@ -0,0 +1,176 @@
+from qtensor.contraction_backends import TransposedBackend
+from qtree import np_framework
+import numpy as np
+import torch as torch
+import cupy as cp
+from cupy import cutensor as cupy_cutensor
+
+class NumpyTranspoedBackend(TransposedBackend):
+    def __init__(self):
+        super().__init__()
+        self.backend = 'numpy'
+        self.device = 'cpu'
+    
+    def get_sliced_buckets(self, buckets, data_dict, slice_dict):
+        return np_framework.get_sliced_np_buckets(buckets, data_dict, slice_dict)
+
+    @staticmethod
+    def get_tncontract():
+        return np.einsum
+    
+    @staticmethod
+    def get_sum(data, axis):
+        return np.sum(data,axis=axis)
+    
+    @staticmethod
+    def get_transpose(data, *axis):
+        return data.transpose(*axis)
+    
+    @staticmethod
+    def get_argsort(*args):
+        return np.argsort(*args)
+    
+    def get_dtype(self, dtype:str):
+        return {
+            'float32': 'float'
+            , 'float64': 'double'
+            , 'complex64': 'complex64'
+            , 'complex128': 'complex128'
+        }[dtype]
+
+
+class TorchTransposedBackend(TransposedBackend):
+    def __init__(self, device='gpu'):
+        super().__init__()
+        self.backend_module = torch
+        self.backend = 'pytorch'
+    
+    @staticmethod
+    def get_tncontract():
+        return torch.einsum
+    
+    @staticmethod
+    def get_sum(data, axis):
+        return torch.sum(data,dim=axis)
+    
+    @staticmethod
+    def get_transpose(data, *axis):
+        if len(axis) == 0:
+            axis = (0,) # Hardcode
+        return data.permute(*axis)
+    
+    @staticmethod
+    def get_argsort(*args):
+        return torch.argsort(torch.Tensor(*args))
+
+    def prepare(self, data):
+        if not isinstance(data, torch.Tensor):
+            if self.device == 'gpu' and torch.cuda.is_available():
+                cuda = torch.device('cuda')
+                data = torch.from_numpy(data).to(cuda)
+            else:
+                data = torch.from_numpy(data)
+        return data
+    
+    def get_dtype(self, dtype:str):
+        return {
+            'torch.float32': 'float'
+            , 'torch.float64': 'double'
+            , 'torch.complex64': 'complex64'
+            , 'torch.complex128': 'complex128'
+        }[dtype]
+    
+    def convert_type(self, a, b):
+        a_type = self.get_dtype(str(a.dtype))
+        b_type = self.get_dtype(str(b.dtype))
+        if a_type != b_type:
+            if self.dtype.index(a_type) > self.dtype.index(b_type):
+                b = b.type(a.dtype)
+            else:
+                a = a.type(b.dtype)
+        return a, b
+
+
+class CupyTransposedBackend(TransposedBackend):
+    def __init__(self, device='gpu'):
+        super().__init__()
+        self.mempool = cp.get_default_memory_pool()
+        self.backend_module = cp
+        self.backend = 'cupy'
+    
+    @staticmethod
+    def get_tncontract():
+        return cp.einsum
+    
+    @staticmethod
+    def get_sum(data, axis):
+        return cp.sum(data,axis=axis)
+    
+    @staticmethod
+    def get_transpose(data, *axis):
+        data = cp.asarray(data)
+        return data.transpose(*axis)
+    
+    @staticmethod
+    def get_argsort(*args):
+        return cp.argsort(cp.asarray(*args)).tolist()
+    
+    def prepare(self, data):
+        if self.device == 'gpu':
+            data = cp.asarray(data)
+        return data
+    
+    def get_dtype(self, dtype:str):
+        return {
+            'float32': 'float'
+            , 'float64': 'double'
+            , 'complex64': 'complex64'
+            , 'complex128': 'complex128'
+        }[dtype]
+
+
+class CutensorTransposedBackend(CupyTransposedBackend):
+    def __init__(self, device='gpu'):
+        super().__init__()
+        self.backend = 'cutensor'
+    
+    @staticmethod
+    def get_tncontract():
+        return cupy_cutensor.contraction
+    
+    @staticmethod
+    def get_sum(data, axis):
+        return cp.sum(data,axis=axis)
+    
+    @staticmethod
+    def get_transpose(data, *axis):
+        return data.transpose(*axis)
+    
+    def get_ready(self, contraction, a, b):
+        # get ready
+        inp, out = contraction.split('->')
+        size = inp.split(',')
+        mode_a = tuple(size[0])
+        mode_b = tuple(size[1])
+        mode_c = tuple(out)
+        
+        # generate tensor c
+        shape_a, shape_b = a.shape, b.shape
+        shape_c = tuple((shape_a[1], shape_a[2], shape_b[2]))
+
+        # manually cast type
+        a, b = self.convert_type(a, b)
+        c = cp.random.rand(*shape_c).astype(a.dtype)
+
+        # generate tensor descriptor
+        desc_a = cupy_cutensor.create_tensor_descriptor(a)
+        desc_b = cupy_cutensor.create_tensor_descriptor(b)
+        desc_c = cupy_cutensor.create_tensor_descriptor(c)
+
+        
+        if not a.flags['C_CONTIGUOUS']:
+            a = cp.ascontiguousarray(a)
+        if not b.flags['C_CONTIGUOUS']:
+            b = cp.ascontiguousarray(b)
+
+        return a, b, c, mode_a, mode_b, mode_c, desc_a, desc_b, desc_c
diff --git a/qtensor/contraction_backends/transposed.py b/qtensor/contraction_backends/transposed.py
index 2d1737de..ed94e4ef 100644
--- a/qtensor/contraction_backends/transposed.py
+++ b/qtensor/contraction_backends/transposed.py
@@ -30,8 +30,12 @@ def get_einsum_expr(bucket, all_indices_list, result_indices):
     return expr
 
 class TransposedBackend(ContractionBackend):
-    def __init__(self):
+    
+
+    def __init__(self, device='gpu'):
         super().__init__()
+        self.device = device
+        self.dtype = ['float', 'double', 'complex64', 'complex128']
         #self.pbar = tqdm(desc='Buckets', position=2)
         #self.status_bar = tqdm(desc='Current status', position=3, bar_format='{desc}')
 
@@ -40,10 +44,14 @@ def process_bucket(self, bucket, no_sum=False):
         all_indices = sorted(all_indices, key=int)
         result_indices = all_indices[1:]
         contract_index = all_indices[0]
-        #print('contract_index', contract_index, no_sum)
+        # print('contract_index', contract_index, no_sum)
         res = self.process_bucket_merged([contract_index], bucket, no_sum=no_sum)
         # Convert indices to growing, bucket elimination expects this
-        tdata = res.data.transpose(*[res.indices.index(x) for x in result_indices])
+        # print("all_indices:", all_indices)
+        # print("bucket:", bucket)
+        # print("res.indices:", res.indices)
+        # print("result_indices", result_indices)
+        tdata = self.get_transpose(res.data,*[res.indices.index(x) for x in result_indices])
         res = qtree.optimizer.Tensor(name=res.name, indices=tuple(result_indices), data=tdata)
         return res
 
@@ -72,6 +80,9 @@ def _to_letters(self, *ixs):
         convert = lambda x: [mapping[i] for i in x]
         return list(map(convert, ixs))
 
+    def get_tncontract():
+        raise NotImplementedError
+
     def pairwise_sum_contract(self, ixa, a, ixb, b, ixout):
         #ixa, ixb, out = self._to_letters(ixa, ixb, ixout)
         out = ixout
@@ -110,25 +121,41 @@ def pairwise_sum_contract(self, ixa, a, ixb, b, ixout):
                       for ix in (kix, fix, mix, nix)
                      ]
         #print('kfmn', k, f, m, n)
-        a = tensors[0].transpose(*[
+        a = self.get_transpose(tensors[0], *[
             list(ixs[0]).index(x) for x in common + list(mix)
         ])
 
-        b = tensors[1].transpose(*[
+        b = self.get_transpose(tensors[1], *[
             list(ixs[1]).index(x) for x in common + list(nix)
         ])
+
         #print('ixa', ixa, 'ixb', ixb)
         a = a.reshape(k, f, m)
         b = b.reshape(k, f, n)
-        G = np.einsum('ijk,ijl->jkl', a, b)
+
+        # manual cast
+        a, b = self.convert_type(a, b)
+
+        
+        tncontract = self.get_tncontract()
+
+        contraction = 'ijk,ijl->jkl'
+        if self.backend == 'cutensor':
+            a, b, c, mode_a, mode_b, mode_c, desc_a, desc_b, desc_c = self.get_ready(contraction, a, b)
+            G = tncontract(1.0, a, desc_a, mode_a, 
+                        b, desc_b, mode_b, 0, 
+                        c, desc_c, mode_c)
+        else:    
+            G = tncontract(contraction, a, b)
+
         # if len(out)>17:
-        #     print('lg', G.nbytes)
+            # print('lg', G.nbytes)
             #print('ax/bx', ixa, ixb, 'out ix', out, 'kfmnix', kix, fix, mix, nix, 'summed', sum_ix)
         if len(out):
             #print('out ix', out, 'kfmnix', kix, fix, mix, nix)
             G = G.reshape(*self._get_index_sizes(*out))
         current_ord_ = list(fix) + list(mix) + list(nix)
-        G = G.transpose(*[current_ord_.index(i) for i in out])
+        G = self.get_transpose(G, *[current_ord_.index(i) for i in out])
 
         return G
 
@@ -189,7 +216,7 @@ def process_bucket_merged(self, ixs, bucket, no_sum=False):
             if len(tensors)==1:
                 tensor = bucket[ia]
                 contr_axes = tuple(tensor.indices.index(x) for x in sum_ix)
-                cum_data = np.sum(tensor.data, axis=contr_axes)
+                cum_data = self.get_sum(tensor.data, axis=contr_axes)
                 cum_indices = tuple(x for x in tensor.indices if x not in sum_ix)
             else:
                 ib = vtup.index(tensors[1])
@@ -261,8 +288,67 @@ def process_bucket_merged(self, ixs, bucket, no_sum=False):
         return result
 
     def get_sliced_buckets(self, buckets, data_dict, slice_dict):
-        return np_framework.get_sliced_np_buckets(buckets, data_dict, slice_dict)
-
+        backend = self.backend_module
+        sliced_buckets = []
+        for bucket in buckets:
+            sliced_bucket = []
+            for tensor in bucket:
+                # get data
+                # sort tensor dimensions
+                transpose_order = self.get_argsort(list(map(int, tensor.indices)))
+                data = data_dict[tensor.data_key]
+                data = self.prepare(data)
+                data = self.get_transpose(data, tuple(transpose_order))
+                # transpose indices
+                indices_sorted = [tensor.indices[pp]
+                                  for pp in transpose_order]
+
+                # slice data
+                slice_bounds = []
+                for idx in indices_sorted:
+                    try:
+                        slice_bounds.append(slice_dict[idx])
+                    except KeyError:
+                        slice_bounds.append(slice(None))
+
+                data = data[tuple(slice_bounds)]
+
+                # update indices
+                indices_sliced = [idx.copy(size=size) for idx, size in
+                                  zip(indices_sorted, data.shape)]
+                indices_sliced = [i for sl, i in zip(slice_bounds, indices_sliced) if not isinstance(sl, int)]
+                assert len(data.shape) == len(indices_sliced)
+
+                sliced_bucket.append(
+                    tensor.copy(indices=indices_sliced, data=data))
+            sliced_buckets.append(sliced_bucket)
+
+        return sliced_buckets
+    
+    def get_sum(data, axis):
+        raise NotImplementedError
+    
+    def get_transpose(data, *axis):
+        raise NotImplementedError
+    
+    def prepare(data):
+        return data
+
+    def get_argsort(*args):
+        raise NotImplementedError
+    
+    def convert_type(self, a, b):
+        a_type = self.get_dtype(str(a.dtype))
+        b_type = self.get_dtype(str(b.dtype))
+        # print("a/b before:", a_type, b_type)
+        if a_type != b_type:
+            if self.dtype.index(a_type) > self.dtype.index(b_type):
+                b = b.astype(a.dtype)
+            else:
+                a = a.astype(b.dtype)
+        # print("a/b after:", str(a.dtype), str(b.dtype))
+        return a, b
+    
     def get_result_data(self, result):
         return result.data
 
diff --git a/qtensor/tools/lazy_import/__init__.py b/qtensor/tools/lazy_import/__init__.py
index b26fafe6..cab1ccc8 100644
--- a/qtensor/tools/lazy_import/__init__.py
+++ b/qtensor/tools/lazy_import/__init__.py
@@ -43,7 +43,7 @@ def __getattr__(self, attr):
 
 tcontract = LasyModule('tcontract')
 torch = LasyModule('torch')
-cupy = LasyModule("cupy")
+cupy = LasyModule('cupy')
 qiskit = LasyModule('qiskit')
 qiskit_lib = FallbackLasyModule(['qiskit.circuit.library','qiskit.extensions.standard'])
 mpi4py = LasyModule('mpi4py')
diff --git a/scratchpad/bench/base.py b/scratchpad/bench/base.py
new file mode 100644
index 00000000..bb67d82e
--- /dev/null
+++ b/scratchpad/bench/base.py
@@ -0,0 +1,301 @@
+from numpy.core.fromnumeric import size
+import pyrofiler
+from typing import List
+from contextlib import contextmanager
+from dataclasses import dataclass
+from functools import lru_cache
+import itertools
+import platform
+import importlib
+
+class LasyModule:
+    def __init__(self, modulename):
+        self.modulename = modulename
+        self.module = None
+    def __getattr__(self, attr):
+        if self.module is None:
+            self.module = importlib.import_module(self.modulename)
+        return self.module.__getattribute__(attr)
+
+np = LasyModule('numpy')
+torch = LasyModule('torch')
+cupy = LasyModule('cupy')
+cupy_cutensor = LasyModule('cutensor')
+import sys
+import os
+sys.path.append(os.environ['HOME']+"/.local")
+exatn = LasyModule('exatn')
+from cupy import cutensor as cupy_cutensor
+
+@dataclass
+class BenchResult:
+    gen_time: float
+    transfer_time: float
+    operation_time: float
+
+
+class Backend:
+    timing=pyrofiler.timing
+
+    @classmethod
+    def gen_tensor(cls, *sizes, dtype='float'):
+        raise NotImplementedError
+    
+    @classmethod
+    def get_ready(cls, num_tensors, *sizes, **args):
+        return num_tensors, *sizes
+
+    @staticmethod
+    def prepare(x):
+        return x
+
+    @staticmethod
+    def get_result(x):
+        return x
+    
+    @classmethod
+    def gen_tensors(cls, num_tensors, *sizes, dtype='float'):
+        tensors = []
+        for i in range(num_tensors):
+            tensor = cls.gen_tensor(*sizes[i], dtype=dtype)
+            tensors.append(tensor)
+        return tensors
+    
+
+
+class Benchmark:
+    @staticmethod
+    def get_task_type():
+        raise NotImplementedError
+        
+    @staticmethod
+    def benchmark(cls, **args):
+        raise NotImplementedError
+
+    def format_flops(flops):
+        ord = 3*int(np.log10(flops)/3)
+        suffix = {
+            0: ''
+            ,3: 'k'
+            ,6: 'M'
+            ,9: 'G'
+            , 12: 'T'
+        }[ord]
+        return f'{(flops/10**ord).round(2)}{suffix}'
+
+    def get_dtype_size(dtype):
+        dtype_t = {
+            'float':np.float32
+            ,'double': np.float64
+            ,'complex64': np.complex64
+            ,'complex128': np.complex128
+        }[dtype]
+        x = np.ones(10, dtype=dtype_t)
+        return x.itemsize
+
+    def mean_mmax(x: list):
+        mx, mn = max(x), min(x)
+        x.remove(mx)
+        x.remove(mn)
+        return np.mean(x)
+
+
+    @classmethod
+    def get_params(cls, **args):
+        raise NotImplementedError
+
+
+    @classmethod
+    def print_results_json(cls, **args):
+        raise NotImplementedError
+
+
+class Numpy(Backend):
+    @staticmethod
+    def get_dtype(dtype):
+        return {
+            'float':np.float32
+            ,'double': np.float64
+            ,'complex64': np.complex64
+            ,'complex128': np.complex128
+        }[dtype]
+
+    @classmethod
+    def gen_tensor(cls, *sizes, dtype='float'):
+        dtype_t = cls.get_dtype(dtype)
+        return np.random.rand(*sizes).astype(dtype_t)
+
+    @staticmethod
+    def get_matmul():
+        return np.matmul
+    
+    @staticmethod
+    def get_tncontract():
+        return np.einsum
+
+
+class Torch(Backend):
+    torch.backends.cuda.matmul.allow_tf32 = False
+    gpu_tensor = ['float', 'double']
+
+    @staticmethod
+    def get_dtype(dtype):
+        return {
+            'float':torch.cuda.FloatTensor
+            ,'double': torch.cuda.DoubleTensor
+            ,'complex64': torch.complex64
+            ,'complex128': torch.complex128
+        }[dtype]
+
+    @classmethod
+    def gen_tensor(cls, *sizes, dtype='float'):
+        if dtype in cls.gpu_tensor:
+            dtype = cls.get_dtype(dtype)
+            return dtype(*sizes).normal_()
+        else:
+            dtype = cls.get_dtype(dtype)
+            return torch.rand(*sizes, dtype=dtype, device='cuda')
+
+    @staticmethod
+    def get_matmul():
+        return torch.matmul
+    
+    @staticmethod
+    def get_tncontract():
+        return torch.einsum
+
+
+class TorchCuda(Torch):
+    @classmethod
+    @contextmanager
+    def timing(cls, **kwargs):
+        class Foo:
+            pass
+        res = Foo()
+        start = torch.cuda.Event(enable_timing=True)
+        end = torch.cuda.Event(enable_timing=True)
+        start.record()
+        yield res
+        end.record()
+        torch.cuda.synchronize()
+        res.result = start.elapsed_time(end)/1000
+
+
+class Cupy(Backend):
+    @classmethod
+    @contextmanager
+    def timing(cls, **kwargs):
+        class Foo:
+            pass
+        res = Foo()
+        start = cupy.cuda.Event(disable_timing=False)
+        end = cupy.cuda.Event(disable_timing=False)
+        start.record()
+        yield res
+        end.record()
+        end.synchronize()
+        res.result = cupy.cuda.get_elapsed_time(start, end)/1000
+
+    @staticmethod
+    def get_dtype(dtype):
+        return {
+            'float':cupy.float32
+            ,'double': cupy.float64
+            ,'complex64': cupy.complex64
+            ,'complex128': cupy.complex128
+        }[dtype]
+
+    @classmethod
+    def gen_tensor(cls, *sizes, dtype='float'):
+        dtype_t = cls.get_dtype(dtype)
+        return cupy.random.rand(*sizes).astype(dtype_t)
+
+    @staticmethod
+    def get_matmul():
+        with pyrofiler.timing('cblas handler'):
+            cupy.cuda.device.get_cublas_handle()
+        return cupy.matmul
+
+    @staticmethod
+    def get_tncontract():
+        with pyrofiler.timing('cblas handler'):
+            cupy.cuda.device.get_cublas_handle()
+        return cupy.einsum
+
+
+class CuTensor(Cupy):
+    @classmethod
+    def get_ready(self, num_tensors, *sizes, contraction=None):
+        if contraction is None:
+            # matrix mk,kn->mn
+            self.mode_A = ('m', 'k')
+            self.mode_B = ('k', 'n')
+            self.mode_C = ('m', 'n')
+            sizes = list(sizes)
+            sizes.append([sizes[0][0], sizes[1][1]])
+        else:
+            # tncontract
+            contraction_str = contraction.contraction
+            inp, out = contraction_str.split('->')
+            size = inp.split(',')
+            self.mode_A = tuple(size[0])
+            self.mode_B = tuple(size[1])
+            self.mode_C = tuple(out)
+        num_tensors += 1
+        return num_tensors, *sizes
+
+    @classmethod
+    def gen_tensor(cls, *sizes, dtype='float'):
+        dtype_t = cls.get_dtype(dtype)
+        return cupy.random.rand(*sizes).astype(dtype_t)
+
+    @classmethod
+    def cutensor_matmul(cls, x, y, z):
+        [x, desc_x] = x
+        [y, desc_y] = y
+        [z, desc_z] = z
+        from cupy import cutensor
+        return cutensor.contraction(1, x, desc_x,  cls.mode_A, 
+                                y, desc_y, cls.mode_B, 0, 
+                                z, desc_z, cls.mode_C)
+    
+    @classmethod
+    def get_matmul(cls):
+        with pyrofiler.timing('cblas handler'):
+            cupy.cuda.device.get_cublas_handle()
+        return cls.cutensor_matmul
+    
+    @classmethod
+    def prepare(cls, x):
+        desc_x = cupy_cutensor.create_tensor_descriptor(x)
+        return [x, desc_x]
+    
+    @classmethod
+    def tncontract(cls, contraction, *tensors):
+        [x, desc_x] = tensors[0]
+        [y, desc_y] = tensors[1]
+        [z, desc_z] = tensors[2]
+        return cupy_cutensor.contraction(1.0, x, desc_x, cls.mode_A, 
+                        y, desc_y, cls.mode_B, 0, 
+                        z, desc_z, cls.mode_C)
+
+    @classmethod
+    def get_tncontract(cls):
+        with pyrofiler.timing('cblas handler'):
+            cupy.cuda.device.get_cublas_handle()
+        return cls.tncontract
+
+
+
+def obj2dict(obj):
+        keys = [x for x in dir(obj) if x[0]!='_']
+        return dict((key, obj.__getattribute__(key)) for key in keys)
+
+@lru_cache
+def get_gpu_props_json():
+    try:
+        import torch
+        devprops = torch.cuda.get_device_properties(torch.cuda.current_device())
+        return obj2dict(devprops)
+    except:
+        return None
\ No newline at end of file
diff --git a/scratchpad/bench/circontraction/bris_vs_be.py b/scratchpad/bench/circontraction/bris_vs_be.py
new file mode 100644
index 00000000..0f3411bb
--- /dev/null
+++ b/scratchpad/bench/circontraction/bris_vs_be.py
@@ -0,0 +1,256 @@
+import json
+from functools import lru_cache
+import numpy as np
+import networkx as nx
+import platform
+import pyrofiler
+import qtensor
+from qtensor import QtreeQAOAComposer
+from qtensor import QAOAQtreeSimulator
+from qtensor.contraction_backends import get_mixed_backend, get_mixed_perf_backend, get_gpu_perf_backend, get_cpu_perf_backend
+from qtensor.tools.benchmarking import qc
+
+'''
+Helper Functions
+
+'''
+gpu_backends = ['torch_gpu', 'cupy', 'tr_torch', 'tr_cupy', 'tr_cutensor']
+cpu_backends = ['einsum', 'torch_cpu', 'mkl', 'opt_einsum', 'tr_einsum', 'opt_einsum']
+timing = pyrofiler.timing
+
+def obj2dict(obj):
+    keys = [x for x in dir(obj) if x[0]!='_']
+    return dict((key, obj.__getattribute__(key)) for key in keys)
+
+@lru_cache
+def get_gpu_props_json():
+    try:
+        import torch
+        devprops = torch.cuda.get_device_properties(torch.cuda.current_device())
+        return obj2dict(devprops)
+    except:
+        return None
+
+paramtest = [
+    [6,40,0]
+]
+
+def mean_mmax(x: list):
+    mx, mn = max(x), min(x)
+    x.remove(mx)
+    x.remove(mn)
+    return np.mean(x)
+
+def format_flops(flops):
+    ord = 3*int(np.log10(flops)/3)
+    suffix = {
+        3: 'k'
+        ,6: 'M'
+        ,9: 'G'
+        , 12: 'T'
+    }[ord]
+    return f'{(flops/10**ord).round(2)}{suffix}'
+
+
+'''
+TODO:
+Objective 1:
+I/O: problem description -> circ collection
+'''
+def gen_bris_circ(d,l,s):
+    _, circ = qc.get_bris_circuit(d,l,s)
+    circ = sum(circ, [])
+    return circ
+
+'''
+TODO:
+I/O: a circuit -> gets peos
+'''
+def gen_circ_peo(circuit, algo):
+    tn = qtensor.optimisation.TensorNet.QtreeTensorNet.from_qtree_gates(circuit)
+    opt = qtensor.toolbox.get_ordering_algo(algo)
+    peo, _ = opt.optimize(tn)
+    return peo
+
+'''
+TODO:
+I/O: Running the actual simulaton for pure backend
+'''
+def gen_circ_peo_report(circuit, peo, backend_name, gen_base):
+    with timing(callback = lambda x: None) as gen:
+        if backend_name in gpu_backends:
+            curr_backend = get_gpu_perf_backend(backend_name)
+        else:
+            curr_backend = get_cpu_perf_backend(backend_name)
+    curr_sim = QAOAQtreeSimulator(QtreeQAOAComposer,backend=curr_backend)
+    curr_sim.simulate_batch(circuit, peo = peo)
+    curr_sim.backend.gen_report(show = False)
+    report_record = np.asarray(curr_backend.report_table.records)
+    #print(report_record.shape)
+
+    '''
+    Generate report table data
+    '''
+    tensor_dims = []
+    for i, x in enumerate(curr_sim.backend._profile_results):
+        bucket_signature, _ = curr_sim.backend._profile_results[x]
+        bucket_size = []
+        #print(len(max(bucket_signature, key=len)))
+        for tensor in bucket_signature:
+            tensor_2_size = [qtreeVar.size for qtreeVar in tensor]
+            tensor_dim = np.prod(tensor_2_size)
+            bucket_size.append(tensor_dim)
+        tensor_dims.append(sum(bucket_size))
+
+    tensor_dims = np.asarray(tensor_dims).reshape(-1,1)
+    gen_time = gen_base
+    gen_times = np.full((tensor_dims.shape), gen_time)
+
+    title_record = curr_sim.backend.report_table._title_row()[1:]
+    title_record.append("byte")
+    title_record.append("gen_time")
+
+    report_record = np.hstack((report_record,tensor_dims))
+    report_record = np.hstack((report_record,gen_times))
+
+    return title_record, report_record
+
+
+def gen_circ_peo_report_mix(circuit, peo, backend_name, gen_base):
+
+    curr_backend = get_mixed_perf_backend(backend_name[0], backend_name[1])   
+    curr_sim = QAOAQtreeSimulator(QtreeQAOAComposer,backend=curr_backend)
+    curr_sim.simulate_batch(circuit, peo = peo)
+    
+    curr_backend.cpu_be.gen_report(show = False)
+    curr_backend.gpu_be.gen_report(show = False)
+
+    '''
+    Merging two report table together
+    CPU table on top, gpu second
+    '''
+    cpu_table = np.asarray(curr_backend.cpu_be.report_table.records)
+    gpu_table = np.asarray(curr_backend.gpu_be.report_table.records)
+    report_record = np.vstack((cpu_table, gpu_table))
+    #print("CPU Table Shape: ",cpu_table.shape)
+    #print(gpu_table.shape)
+    #print(all_table.shape)
+
+    '''
+    Checking Tensor Dims/bytes
+    1st Loop for cpu, 2nd loop for gpu
+    '''
+    tensor_dims = []
+    for i,x in enumerate(curr_backend.cpu_be._profile_results):
+        bc_signature, _ = curr_backend.cpu_be._profile_results[x]
+        bucket_size = []
+        for tensor in bc_signature:
+            tensor_2_size = [qtreeVar.size for qtreeVar in tensor]
+            tensor_dim = np.prod(tensor_2_size)
+            bucket_size.append(tensor_dim)
+        tensor_dims.append(sum(bucket_size))
+    
+    for i,x in enumerate(curr_backend.gpu_be._profile_results):
+        bc_signature, _ = curr_backend.gpu_be._profile_results[x]
+        bucket_size = []
+        for tensor in bc_signature:
+            tensor_2_size = [qtreeVar.size for qtreeVar in tensor]
+            tensor_dim = np.prod(tensor_2_size)
+            bucket_size.append(tensor_dim)
+        tensor_dims.append(sum(bucket_size))
+    
+    '''
+    Processing tensor_dims and gen_times as new columns
+    '''
+    tensor_dims = np.asarray(tensor_dims).reshape(-1,1)
+    gen_time = gen_base
+    gen_times = np.full((tensor_dims.shape), gen_time)
+
+
+    '''
+    Generate titles
+    '''
+    title_record = curr_backend.cpu_be.report_table._title_row()[1:]
+    title_record.append("byte")
+    title_record.append("gen_time")
+
+    '''
+    Modify new report table
+    '''
+    report_record = np.hstack((report_record,tensor_dims))
+    report_record = np.hstack((report_record,gen_times))
+
+    return title_record, report_record
+
+def collect_reports(circuit, peo, backend_name, repeat, gen_base):
+    bucketindex_2_reports = {}
+    for _ in range(repeat):
+        if type(backend_name) == list:
+            titles, report_table = gen_circ_peo_report_mix(circuit, peo, backend_name, gen_base)
+        else:
+            titles, report_table = gen_circ_peo_report(circuit, peo, backend_name, gen_base)
+        for i, report in enumerate(report_table):
+            if i not in bucketindex_2_reports:
+                bucketindex_2_reports[i] = [report]
+            else:
+                bucketindex_2_reports[i].append(report)
+    
+    return titles, bucketindex_2_reports
+
+def reduce_reports(circuit, peo, backend_name, repeat, gen_base):
+    bi_2_reduced = {}
+    titles, bi_2_reports = collect_reports(circuit, peo, backend_name, repeat, gen_base)
+
+    for bi, report in bi_2_reports.items():
+        bi_redux = list()
+        t_report = np.transpose(report)
+        for attr in t_report:
+            bi_redux.append(mean_mmax(attr.tolist()))
+        bi_2_reduced[bi] = bi_redux
+    
+    return titles, bi_2_reduced
+
+def process_reduced_data(circuit, peo, backend_name, problem, repeat, gen_base,  opt_algo):
+    if type(backend_name) == list:
+        final_backend_name = backend_name[0]+"-"+backend_name[1]
+    else:
+        final_backend_name = backend_name
+    titles, bi_2_reduced = reduce_reports(circuit, peo, backend_name, repeat, gen_base)
+    GPU_PROPS = get_gpu_props_json()
+    lc_collection = []
+    for bi, report in bi_2_reduced.items():
+        bi_json_usable = {}
+        bi_json_usable["backend"] = final_backend_name
+        bi_json_usable["device_props"] = dict(name=platform.node(), gpu=GPU_PROPS)
+        bi_json_usable["bucket_index"] = bi
+        bi_json_usable["opt_algo"] = opt_algo
+        for i, attr in enumerate(titles):
+            if attr == "flop":
+                bi_json_usable["ops"] = report[i]
+            else:
+                bi_json_usable[attr] = report[i]
+        bi_json_usable["problem"] = {
+                    "d" :problem[0] , 
+                    "l" :problem[1] ,
+                    "s" :problem[2]
+                    }
+        bi_json_usable["experiment_group"] = "Chen_Bris_Test"
+        lc_collection.append(bi_json_usable)
+    #print(json.dumps(lc_collection, indent = 4))
+
+    return lc_collection
+
+if __name__ == '__main__':
+    backends = ['einsum', 'torch_cpu', 'torch_gpu', 'cupy',["einsum","cupy",16]] #'tr_torch'
+    my_algo = 'greedy'
+    my_reap = 3
+    for pb in [paramtest[0]]:
+        d,l,s = pb
+        with timing(callback=lambda x: None) as gen_pb:
+            curr_circ = gen_bris_circ(d,l,s)
+            curr_peo = gen_circ_peo(curr_circ, my_algo)
+        gen_base = gen_pb.result
+        for be in [backends[4]]:
+            lc_collection = process_reduced_data(curr_circ, curr_peo, be, pb, my_reap, gen_base, my_algo)
+            for c in lc_collection:
+                print(json.dumps(c))
\ No newline at end of file
diff --git a/scratchpad/bench/circontraction/bucket_iso.py b/scratchpad/bench/circontraction/bucket_iso.py
new file mode 100644
index 00000000..b1f94b44
--- /dev/null
+++ b/scratchpad/bench/circontraction/bucket_iso.py
@@ -0,0 +1,86 @@
+from qtensor.contraction_backends import get_backend
+from functools import lru_cache, reduce
+from qtree.optimizer import Var, Tensor
+import numpy as np
+import pyrofiler
+import json
+import platform
+
+bucket_signatures = [
+    "[E369(v_385,v_386,v_387,v_388,v_389,v_390,v_391,v_392,v_395,v_402,v_404,v_405), E384(v_385,v_386,v_387,v_388,v_389,v_390,v_392,v_393,v_394,v_396,v_397,v_398,v_399,v_400,v_401,v_403,v_404)]",
+    "[E406(v_411,v_412,v_413,v_414,v_415,v_416,v_420,v_421,v_424,v_425,v_426,v_427,v_429,v_431), E410(v_411,v_412,v_413,v_414,v_415,v_416,v_417,v_418,v_419,v_420,v_421,v_422,v_423,v_428,v_430,v_431)]",
+    "[E49(v_348), E343(v_348,v_349,v_350,v_351,v_352,v_353,v_357,v_358,v_362,v_363,v_364,v_365,v_366,v_368), E344(v_348,v_349,v_350,v_351,v_352,v_354,v_355,v_356,v_357,v_359,v_360,v_361,v_366,v_367,v_368)]"
+]
+
+def mean_mmax(x: list):
+    mx, mn = max(x), min(x)
+    x.remove(mx)
+    x.remove(mn)
+    return np.mean(x)
+
+def obj2dict(obj):
+    keys = [x for x in dir(obj) if x[0]!='_']
+    return dict((key, obj.__getattribute__(key)) for key in keys)
+
+@lru_cache
+def get_gpu_props_json():
+    try:
+        import torch
+        devprops = torch.cuda.get_device_properties(torch.cuda.current_device())
+        return obj2dict(devprops)
+    except:
+        return None
+
+def signParser(bucSign:str):
+    sign = bucSign[1:-1]
+    splitedSign = sign.split(", ")
+    tensors = []
+    for tenSign in splitedSign:
+        tenSign = tenSign[:-1]
+        tenName, varSigns = tenSign.split("(")
+        varSigns = varSigns.split(',')
+        vars = ()
+        for varSign in varSigns:
+            number = varSign[2:]
+            currVar = Var(number)
+            vars += (currVar,)
+
+        # [] * len(vars)
+        varLength = [2] * len(vars)
+        a = np.random.rand(*varLength)
+        b = np.random.rand(*varLength)
+        c = a + 1j*b
+        tensor = Tensor(name = tenName, indices = vars, data = c)
+        tensors.append(tensor)
+    return tensors
+
+
+
+
+if __name__ == '__main__':
+    timing = pyrofiler.timing
+    backends = ["cupy", "torch_gpu"]
+    rep = 10
+
+    for backend in backends:
+        be = get_backend(backend)
+        for i, sign in enumerate(bucket_signatures):
+            times = []
+            for _ in range(rep):
+                with timing(callback=lambda x: None) as gen_pb:
+                    bucket = signParser(sign)
+                    be.process_bucket(bucket)
+                times.append(gen_pb.result)
+            
+            GPU_PROPS = get_gpu_props_json()
+
+            report = {}
+            report["backend"] = backend
+            report["mean_time"] = mean_mmax(times)
+            report["platform"] = dict(name=platform.node(), gpu=GPU_PROPS)
+            report["bucket_idx"] = i
+            print(json.dumps(report))
+
+            
+ 
+            
diff --git a/scratchpad/bench/circontraction/merged_mixed_QAOA.py b/scratchpad/bench/circontraction/merged_mixed_QAOA.py
new file mode 100644
index 00000000..2b25e86d
--- /dev/null
+++ b/scratchpad/bench/circontraction/merged_mixed_QAOA.py
@@ -0,0 +1,296 @@
+import json
+from functools import lru_cache, reduce
+from scratchpad.bench.circontraction.qaoa_eng_vs_be_adv_sl_bc import get_test_problem
+import numpy as np
+import networkx as nx
+import platform
+import pyrofiler
+import qtensor
+from qtensor import QtreeQAOAComposer
+from qtensor import QAOAQtreeSimulator
+from qtensor.contraction_backends import get_mixed_backend, get_mixed_perf_backend, get_gpu_perf_backend, get_cpu_perf_backend
+from qtensor.tools.benchmarking import qc
+
+from qtensor.MergedSimulator import MergedQAOASimulator
+
+'''
+Helper Functions
+
+'''
+gpu_backends = ['torch_gpu', 'cupy', 'tr_torch', 'tr_cupy', 'tr_cutensor']
+cpu_backends = ['einsum', 'torch_cpu', 'mkl', 'opt_einsum', 'tr_einsum', 'opt_einsum']
+timing = pyrofiler.timing
+
+def obj2dict(obj):
+    keys = [x for x in dir(obj) if x[0]!='_']
+    return dict((key, obj.__getattribute__(key)) for key in keys)
+
+@lru_cache
+def get_gpu_props_json():
+    try:
+        import torch
+        devprops = torch.cuda.get_device_properties(torch.cuda.current_device())
+        return obj2dict(devprops)
+    except:
+        return None
+
+paramtest = [
+    [12,4,3,"random"]
+]
+
+def mean_mmax(x: list):
+    mx, mn = max(x), min(x)
+    x.remove(mx)
+    x.remove(mn)
+    return np.mean(x)
+
+def format_flops(flops):
+    ord = 3*int(np.log10(flops)/3)
+    suffix = {
+        3: 'k'
+        ,6: 'M'
+        ,9: 'G'
+        , 12: 'T'
+    }[ord]
+    return f'{(flops/10**ord).round(2)}{suffix}'
+
+
+'''
+TODO:
+Objective 1:
+I/O: problem description -> circuits for the entire graph
+'''
+def gen_QAOA_circs(G, gamma, beta):
+    gen_sim = QAOAQtreeSimulator(QtreeQAOAComposer)
+    circs = []
+    for edge in G.edges:
+        circ = gen_sim._edge_energy_circuit(G, gamma, beta, edge)
+        circs.append(circ)
+    return circs
+
+
+'''
+TODO:
+I/O: circuits -> gets peos
+'''
+def gen_circs_peos(circuits, algo):
+    peos = []
+    for circ  in circuits:
+        tn = qtensor.optimisation.TensorNet.QtreeTensorNet.from_qtree_gates(circ)
+        opt = qtensor.toolbox.get_ordering_algo(algo)
+        peo, _ = opt.optimize(tn)
+        peos.append(peo)
+    return peos
+
+'''
+TODO:
+I/O: Running the actual simulaton for pure backend
+'''
+def gen_circ_peo_report(circuit, peo, backend_name, gen_base, merged):
+    with timing(callback = lambda x: None) as gen:
+        if backend_name in gpu_backends:
+            curr_backend = get_gpu_perf_backend(backend_name)
+        else:
+            curr_backend = get_cpu_perf_backend(backend_name)
+    if merged:
+        curr_sim = MergedQAOASimulator(QtreeQAOAComposer,backend=curr_backend)
+    else:
+        curr_sim = QAOAQtreeSimulator(QtreeQAOAComposer,backend=curr_backend)
+    curr_sim.simulate_batch(circuit, peo = peo)
+    curr_sim.backend.gen_report(show = False)
+    report_record = np.asarray(curr_backend.report_table.records)
+    #print(report_record.shape)
+
+    '''
+    Generate report table data
+    '''
+    tensor_dims = []
+    for i, x in enumerate(curr_sim.backend._profile_results):
+        bucket_signature, _ = curr_sim.backend._profile_results[x]
+        bucket_size = []
+        #print(len(max(bucket_signature, key=len)))
+        for tensor in bucket_signature:
+            tensor_2_size = [qtreeVar.size for qtreeVar in tensor]
+            tensor_dim = np.prod(tensor_2_size)
+            bucket_size.append(tensor_dim)
+        tensor_dims.append(sum(bucket_size))
+
+    tensor_dims = np.asarray(tensor_dims).reshape(-1,1)
+    gen_time = gen_base
+    gen_times = np.full((tensor_dims.shape), gen_time)
+
+    title_record = curr_sim.backend.report_table._title_row()[1:]
+    title_record.append("byte")
+    title_record.append("gen_time")
+
+    report_record = np.hstack((report_record,tensor_dims))
+    report_record = np.hstack((report_record,gen_times))
+
+    return title_record, report_record
+
+
+def gen_circ_peo_report_mix(circuit, peo, backend_name, gen_base, merged):
+
+    curr_backend = get_mixed_perf_backend(backend_name[0], backend_name[1])
+    if merged:
+        curr_sim = MergedQAOASimulator(QtreeQAOAComposer, backend = curr_backend)
+    else:
+        curr_sim = QAOAQtreeSimulator(QtreeQAOAComposer,backend=curr_backend)
+    
+    curr_sim.simulate_batch(circuit, peo = peo)
+    
+    curr_backend.cpu_be.gen_report(show = False)
+    curr_backend.gpu_be.gen_report(show = False)
+
+    '''
+    Merging two report table together
+    CPU table on top, gpu second
+    '''
+    cpu_table = np.asarray(curr_backend.cpu_be.report_table.records)
+    gpu_table = np.asarray(curr_backend.gpu_be.report_table.records)
+    report_record = np.vstack((cpu_table, gpu_table))
+    #print("CPU Table Shape: ",cpu_table.shape)
+    #print(gpu_table.shape)
+    #print(all_table.shape)
+
+    '''
+    Checking Tensor Dims/bytes
+    1st Loop for cpu, 2nd loop for gpu
+    '''
+    tensor_dims = []
+    for i,x in enumerate(curr_backend.cpu_be._profile_results):
+        bc_signature, _ = curr_backend.cpu_be._profile_results[x]
+        bucket_size = []
+        for tensor in bc_signature:
+            tensor_2_size = [qtreeVar.size for qtreeVar in tensor]
+            tensor_dim = np.prod(tensor_2_size)
+            bucket_size.append(tensor_dim)
+        tensor_dims.append(sum(bucket_size))
+    
+    for i,x in enumerate(curr_backend.gpu_be._profile_results):
+        bc_signature, _ = curr_backend.gpu_be._profile_results[x]
+        bucket_size = []
+        for tensor in bc_signature:
+            tensor_2_size = [qtreeVar.size for qtreeVar in tensor]
+            tensor_dim = np.prod(tensor_2_size)
+            bucket_size.append(tensor_dim)
+        tensor_dims.append(sum(bucket_size))
+    
+    '''
+    Processing tensor_dims and gen_times as new columns
+    '''
+    tensor_dims = np.asarray(tensor_dims).reshape(-1,1)
+    gen_time = gen_base
+    gen_times = np.full((tensor_dims.shape), gen_time)
+
+
+    '''
+    Generate titles
+    '''
+    title_record = curr_backend.cpu_be.report_table._title_row()[1:]
+    title_record.append("byte")
+    title_record.append("gen_time")
+
+    '''
+    Modify new report table
+    '''
+    report_record = np.hstack((report_record,tensor_dims))
+    report_record = np.hstack((report_record,gen_times))
+
+    return title_record, report_record
+
+def collect_reports(circuit, peo, backend_name, repeat, gen_base):
+    bucketindex_2_reports = {}
+    for _ in range(repeat):
+        if type(backend_name) == list:
+            if backend_name[-1] == "merged":
+                if len(backend_name) == 2:
+                    titles, report_table = gen_circ_peo_report(circuit, peo, backend_name[0], gen_base, True)
+                else:
+                    titles, report_table = gen_circ_peo_report_mix(circuit, peo, backend_name, gen_base, True)
+            else:
+                titles, report_table = gen_circ_peo_report_mix(circuit, peo, backend_name, gen_base, False)
+        else:
+            titles, report_table = gen_circ_peo_report(circuit, peo, backend_name, gen_base, False)
+        
+        for i, report in enumerate(report_table):
+            if i not in bucketindex_2_reports:
+                bucketindex_2_reports[i] = [report]
+            else:
+                bucketindex_2_reports[i].append(report)
+    
+    return titles, bucketindex_2_reports
+
+def reduce_reports(circuit, peo, backend_name, repeat, gen_base):
+    bi_2_reduced = {}
+    titles, bi_2_reports = collect_reports(circuit, peo, backend_name, repeat, gen_base)
+
+    for bi, report in bi_2_reports.items():
+        bi_redux = list()
+        t_report = np.transpose(report)
+        for attr in t_report:
+            bi_redux.append(mean_mmax(attr.tolist()))
+        bi_2_reduced[bi] = bi_redux
+    
+    return titles, bi_2_reduced
+
+def process_reduced_data(circuit, peo, backend_name, problem, repeat, gen_base,  opt_algo):
+    if type(backend_name) == list:
+        if backend_name[-1] == "merged":
+            if len(backend_name) == 2:
+                final_backend_name = backend_name[0] +"-merged"
+            else:
+                final_backend_name = backend_name[0]+"-"+backend_name[1] + "-merged"
+        else:
+            final_backend_name = backend_name[0]+"-"+backend_name[1]
+    else:
+        final_backend_name = backend_name
+    titles, bi_2_reduced = reduce_reports(circuit, peo, backend_name, repeat, gen_base)
+    GPU_PROPS = get_gpu_props_json()
+    lc_collection = []
+    for bi, report in bi_2_reduced.items():
+        bi_json_usable = {}
+        bi_json_usable["backend"] = final_backend_name
+        bi_json_usable["device_props"] = dict(name=platform.node(), gpu=GPU_PROPS)
+        bi_json_usable["bucket_index"] = bi
+        bi_json_usable["opt_algo"] = opt_algo
+        for i, attr in enumerate(titles):
+            if attr == "flop":
+                bi_json_usable["ops"] = report[i]
+            else:
+                bi_json_usable[attr] = report[i]
+        bi_json_usable["problem"] = {
+                    "n" :problem[0] , 
+                    "p" :problem[1] ,
+                    "d" :problem[2] ,
+                    "type": problem[3]
+                    }
+        bi_json_usable["experiment_group"] = "Chen_QAOA_Mix_Merge_Test"
+        lc_collection.append(bi_json_usable)
+    #print(json.dumps(lc_collection, indent = 4))
+
+    return lc_collection
+
+    
+
+
+
+
+if __name__ == '__main__':
+    backends = [["einsum","merged"]] #'tr_torch'
+    my_algo = 'greedy'
+    my_reap = 3
+    for pb in [paramtest[0]]:
+        n, p, d, ttype = pb
+        with timing(callback=lambda x: None) as gen_pb:
+            G, gamma, beta = get_test_problem(n = n, p = p, d = d, type = ttype)
+            circs = gen_QAOA_circs(G, gamma, beta)
+            peos = gen_circs_peos(circs,my_algo)
+
+        gen_base = gen_pb.result
+        for be in backends:
+            for i, pack in enumerate(zip(circs, peos)):
+                circ, peo = pack
+                curr_report = process_reduced_data(circ,peo, be, pb, my_reap, gen_base, my_algo)
+                for c in curr_report:
+                    print(json.dumps(c))
\ No newline at end of file
diff --git a/scratchpad/bench/circontraction/merged_mixed_bris.py b/scratchpad/bench/circontraction/merged_mixed_bris.py
new file mode 100644
index 00000000..90056e47
--- /dev/null
+++ b/scratchpad/bench/circontraction/merged_mixed_bris.py
@@ -0,0 +1,283 @@
+import json
+from functools import lru_cache
+import numpy as np
+import networkx as nx
+import platform
+import pyrofiler
+import qtensor
+from qtensor import QtreeQAOAComposer
+from qtensor import QAOAQtreeSimulator
+from qtensor.contraction_backends import get_mixed_backend, get_mixed_perf_backend, get_gpu_perf_backend, get_cpu_perf_backend
+from qtensor.tools.benchmarking import qc
+
+from qtensor.MergedSimulator import MergedQAOASimulator
+
+'''
+Helper Functions
+
+'''
+gpu_backends = ['torch_gpu', 'cupy', 'tr_torch', 'tr_cupy', 'tr_cutensor']
+cpu_backends = ['einsum', 'torch_cpu', 'mkl', 'opt_einsum', 'tr_einsum', 'opt_einsum']
+timing = pyrofiler.timing
+
+def obj2dict(obj):
+    keys = [x for x in dir(obj) if x[0]!='_']
+    return dict((key, obj.__getattribute__(key)) for key in keys)
+
+@lru_cache
+def get_gpu_props_json():
+    try:
+        import torch
+        devprops = torch.cuda.get_device_properties(torch.cuda.current_device())
+        return obj2dict(devprops)
+    except:
+        return None
+
+paramtest = [
+    [6,40,0]
+]
+
+def mean_mmax(x: list):
+    mx, mn = max(x), min(x)
+    x.remove(mx)
+    x.remove(mn)
+    return np.mean(x)
+
+def format_flops(flops):
+    ord = 3*int(np.log10(flops)/3)
+    suffix = {
+        3: 'k'
+        ,6: 'M'
+        ,9: 'G'
+        , 12: 'T'
+    }[ord]
+    return f'{(flops/10**ord).round(2)}{suffix}'
+
+
+'''
+TODO:
+Objective 1:
+I/O: problem description -> circ collection
+'''
+def gen_bris_circ(d,l,s):
+    _, circ = qc.get_bris_circuit(d,l,s)
+    circ = sum(circ, [])
+    return circ
+
+'''
+TODO:
+I/O: a circuit -> gets peos
+'''
+def gen_circ_peo(circuit, algo):
+    tn = qtensor.optimisation.TensorNet.QtreeTensorNet.from_qtree_gates(circuit)
+    opt = qtensor.toolbox.get_ordering_algo(algo)
+    peo, _ = opt.optimize(tn)
+    return peo
+
+'''
+TODO:
+I/O: Running the actual simulaton for pure backend
+'''
+def gen_circ_peo_report(circuit, peo, backend_name, gen_base, merged):
+    with timing(callback = lambda x: None) as gen:
+        if backend_name in gpu_backends:
+            curr_backend = get_gpu_perf_backend(backend_name)
+        else:
+            curr_backend = get_cpu_perf_backend(backend_name)
+    if merged:
+        curr_sim = MergedQAOASimulator(QtreeQAOAComposer,backend=curr_backend)
+    else:
+        curr_sim = QAOAQtreeSimulator(QtreeQAOAComposer,backend=curr_backend)
+    curr_sim.simulate_batch(circuit, peo = peo)
+    curr_sim.backend.gen_report(show = False)
+    report_record = np.asarray(curr_backend.report_table.records)
+    #print(report_record.shape)
+
+    '''
+    Generate report table data
+    '''
+    tensor_dims = []
+    for i, x in enumerate(curr_sim.backend._profile_results):
+        bucket_signature, _ = curr_sim.backend._profile_results[x]
+        bucket_size = []
+        #print(len(max(bucket_signature, key=len)))
+        for tensor in bucket_signature:
+            tensor_2_size = [qtreeVar.size for qtreeVar in tensor]
+            tensor_dim = np.prod(tensor_2_size)
+            bucket_size.append(tensor_dim)
+        tensor_dims.append(sum(bucket_size))
+
+    tensor_dims = np.asarray(tensor_dims).reshape(-1,1)
+    gen_time = gen_base
+    gen_times = np.full((tensor_dims.shape), gen_time)
+
+    title_record = curr_sim.backend.report_table._title_row()[1:]
+    title_record.append("byte")
+    title_record.append("gen_time")
+
+    report_record = np.hstack((report_record,tensor_dims))
+    report_record = np.hstack((report_record,gen_times))
+
+    return title_record, report_record
+
+
+def gen_circ_peo_report_mix(circuit, peo, backend_name, gen_base, merged):
+
+    curr_backend = get_mixed_perf_backend(backend_name[0], backend_name[1])
+    if merged:
+        curr_sim = MergedQAOASimulator(QtreeQAOAComposer, backend = curr_backend)
+    else:
+        curr_sim = QAOAQtreeSimulator(QtreeQAOAComposer,backend=curr_backend)
+    
+    curr_sim.simulate_batch(circuit, peo = peo)
+    
+    curr_backend.cpu_be.gen_report(show = False)
+    curr_backend.gpu_be.gen_report(show = False)
+
+    '''
+    Merging two report table together
+    CPU table on top, gpu second
+    '''
+    cpu_table = np.asarray(curr_backend.cpu_be.report_table.records)
+    gpu_table = np.asarray(curr_backend.gpu_be.report_table.records)
+    report_record = np.vstack((cpu_table, gpu_table))
+    #print("CPU Table Shape: ",cpu_table.shape)
+    #print(gpu_table.shape)
+    #print(all_table.shape)
+
+    '''
+    Checking Tensor Dims/bytes
+    1st Loop for cpu, 2nd loop for gpu
+    '''
+    tensor_dims = []
+    for i,x in enumerate(curr_backend.cpu_be._profile_results):
+        bc_signature, _ = curr_backend.cpu_be._profile_results[x]
+        bucket_size = []
+        for tensor in bc_signature:
+            tensor_2_size = [qtreeVar.size for qtreeVar in tensor]
+            tensor_dim = np.prod(tensor_2_size)
+            bucket_size.append(tensor_dim)
+        tensor_dims.append(sum(bucket_size))
+    
+    for i,x in enumerate(curr_backend.gpu_be._profile_results):
+        bc_signature, _ = curr_backend.gpu_be._profile_results[x]
+        bucket_size = []
+        for tensor in bc_signature:
+            tensor_2_size = [qtreeVar.size for qtreeVar in tensor]
+            tensor_dim = np.prod(tensor_2_size)
+            bucket_size.append(tensor_dim)
+        tensor_dims.append(sum(bucket_size))
+    
+    '''
+    Processing tensor_dims and gen_times as new columns
+    '''
+    tensor_dims = np.asarray(tensor_dims).reshape(-1,1)
+    gen_time = gen_base
+    gen_times = np.full((tensor_dims.shape), gen_time)
+
+
+    '''
+    Generate titles
+    '''
+    title_record = curr_backend.cpu_be.report_table._title_row()[1:]
+    title_record.append("byte")
+    title_record.append("gen_time")
+
+    '''
+    Modify new report table
+    '''
+    report_record = np.hstack((report_record,tensor_dims))
+    report_record = np.hstack((report_record,gen_times))
+
+    return title_record, report_record
+
+def collect_reports(circuit, peo, backend_name, repeat, gen_base):
+    bucketindex_2_reports = {}
+    for _ in range(repeat):
+        if type(backend_name) == list:
+            if backend_name[-1] == "merged":
+                if len(backend_name) == 2:
+                    titles, report_table = gen_circ_peo_report(circuit, peo, backend_name, gen_base, True)
+                else:
+                    titles, report_table = gen_circ_peo_report_mix(circuit, peo, backend_name, gen_base, True)
+            else:
+                titles, report_table = gen_circ_peo_report_mix(circuit, peo, backend_name, gen_base, False)
+        else:
+            titles, report_table = gen_circ_peo_report(circuit, peo, backend_name, gen_base, False)
+        
+        for i, report in enumerate(report_table):
+            if i not in bucketindex_2_reports:
+                bucketindex_2_reports[i] = [report]
+            else:
+                bucketindex_2_reports[i].append(report)
+    
+    return titles, bucketindex_2_reports
+
+def reduce_reports(circuit, peo, backend_name, repeat, gen_base):
+    bi_2_reduced = {}
+    titles, bi_2_reports = collect_reports(circuit, peo, backend_name, repeat, gen_base)
+
+    for bi, report in bi_2_reports.items():
+        bi_redux = list()
+        t_report = np.transpose(report)
+        for attr in t_report:
+            bi_redux.append(mean_mmax(attr.tolist()))
+        bi_2_reduced[bi] = bi_redux
+    
+    return titles, bi_2_reduced
+
+def process_reduced_data(circuit, peo, backend_name, problem, repeat, gen_base,  opt_algo):
+    if type(backend_name) == list:
+        if backend_name[-1] == "merged":
+            if len(backend_name) == 2:
+                final_backend_name = backend_name[0] +"-merged"
+            else:
+                final_backend_name = backend_name[0]+"-"+backend_name[1] + "-merged"
+        else:
+            final_backend_name = backend_name[0]+"-"+backend_name[1]
+    else:
+        final_backend_name = backend_name
+    titles, bi_2_reduced = reduce_reports(circuit, peo, backend_name, repeat, gen_base)
+    GPU_PROPS = get_gpu_props_json()
+    lc_collection = []
+    for bi, report in bi_2_reduced.items():
+        bi_json_usable = {}
+        bi_json_usable["backend"] = final_backend_name
+        bi_json_usable["device_props"] = dict(name=platform.node(), gpu=GPU_PROPS)
+        bi_json_usable["bucket_index"] = bi
+        bi_json_usable["opt_algo"] = opt_algo
+        for i, attr in enumerate(titles):
+            if attr == "flop":
+                bi_json_usable["ops"] = report[i]
+            else:
+                bi_json_usable[attr] = report[i]
+        bi_json_usable["problem"] = {
+                    "d" :problem[0] , 
+                    "l" :problem[1] ,
+                    "s" :problem[2]
+                    }
+        bi_json_usable["experiment_group"] = "Chen_Bris_Test"
+        lc_collection.append(bi_json_usable)
+    #print(json.dumps(lc_collection, indent = 4))
+
+    return lc_collection
+
+    
+
+
+
+
+if __name__ == '__main__':
+    backends = [["torch_cpu","torch_gpu",12,"merged"]] #'tr_torch'
+    my_algo = 'greedy'
+    my_reap = 3
+    for pb in [paramtest[0]]:
+        d,l,s = pb
+        with timing(callback=lambda x: None) as gen_pb:
+            curr_circ = gen_bris_circ(d,l,s)
+            curr_peo = gen_circ_peo(curr_circ, my_algo)
+        gen_base = gen_pb.result
+        for be in [backends[0]]:
+            lc_collection = process_reduced_data(curr_circ, curr_peo, be, pb, my_reap, gen_base, my_algo)
+            for c in lc_collection:
+                print(json.dumps(c))
\ No newline at end of file
diff --git a/scratchpad/qaoa_energy_only_qiskit.py b/scratchpad/bench/circontraction/qaoa_energy_only_qiskit.py
similarity index 100%
rename from scratchpad/qaoa_energy_only_qiskit.py
rename to scratchpad/bench/circontraction/qaoa_energy_only_qiskit.py
diff --git a/scratchpad/bench/circontraction/qaoa_eng_load_detect.py b/scratchpad/bench/circontraction/qaoa_eng_load_detect.py
new file mode 100644
index 00000000..a32564c5
--- /dev/null
+++ b/scratchpad/bench/circontraction/qaoa_eng_load_detect.py
@@ -0,0 +1,131 @@
+from functools import lru_cache
+import numpy as np
+import networkx as nx
+import qtensor
+from qtensor import QtreeQAOAComposer
+from qtensor import QAOAQtreeSimulator
+from qtensor.contraction_backends import get_mixed_backend
+import pyrofiler.c as c
+import pandas as pd
+from functools import reduce
+import random
+
+random.seed(42)
+np.random.seed(42)
+
+@lru_cache
+def get_test_problem(n=10, p=2, d=3, type='random'):
+    print('Test problem: n, p, d', n, p, d)
+    if type == 'random':
+        G = nx.random_regular_graph(d, n, seed = 250)
+    elif type == 'grid2d':
+        G = nx.grid_2d_graph(n,n)
+    elif type == 'line':
+        G = nx.Graph()
+        G.add_edges_from(zip(range(n-1), range(1, n)))
+    gamma, beta = [np.pi/5]*p, [np.pi/2]*p
+    return G, gamma, beta
+
+def gen_QAOA_circs(G, gamma, beta):
+    gen_sim = QAOAQtreeSimulator(QtreeQAOAComposer)
+    circs = []
+    for edge in G.edges:
+        circ = gen_sim._edge_energy_circuit(G, gamma, beta, edge)
+        circs.append(circ)
+    return circs
+
+
+def gen_circs_peos(circuits, algo):
+    peos = []
+    widths = []
+    for circ  in circuits:
+        tn = qtensor.optimisation.TensorNet.QtreeTensorNet.from_qtree_gates(circ)
+        opt = qtensor.toolbox.get_ordering_algo(algo)
+        peo, _ = opt.optimize(tn)
+        treeWidth = opt.treewidth
+        peos.append(peo)
+        widths.append(treeWidth)
+    return peos, widths
+
+'''
+TODO: a function to find the max peos and circ
+'''
+def get_max_peo_n_circ(circuits, peos, widths):
+    max_width = max(widths)
+    print("Max Tree Width: {}".format(max_width))
+    max_index = widths.index(max_width)
+    return circuits[max_index], peos[max_index]
+
+
+def gen_circ_peo_report_mix(circuit, peo, backend_name, threshold):
+
+    curr_backend = get_mixed_backend(backend_name[0], backend_name[1], threshold)
+    curr_sim = QAOAQtreeSimulator(QtreeQAOAComposer,backend=curr_backend)
+    curr_sim.simulate_batch(circuit, peo = peo)
+
+
+paramtest = [
+    [24,4,3,"random"]
+]
+
+def process_one_series(result):
+    first = result[0][0]
+    processed = []
+    for stamp in result:
+        processed.append([stamp[0] - first, stamp[1]])
+    return processed
+
+def raw2df(rawTS, samplePeriod):
+    df = pd.DataFrame(rawTS, columns = ["second", "cpu_util"])
+    df['second'] = pd.to_datetime(df['second'], unit='s')
+    df = df.set_index('second')
+    df.index.name = None
+
+    # Resampling and Interpo
+    df1 = df.resample(samplePeriod).mean()
+    df1.index = df1.index.strftime('%M:%S.%f')
+    return df1
+
+def df2reduced(collections):
+    return reduce(lambda x,y: pd.concat((x,y), axis = 1).mean(axis = 1), collections)
+
+
+
+
+
+if __name__ == '__main__':
+    backends = [['einsum','torch_gpu']]
+    threshold = [16]
+    my_reap = 5
+    my_algo = 'greedy'
+    
+    for thr in threshold:
+
+        for pb in paramtest:
+            n, p, d, ttype = pb
+            G, gamma, beta = get_test_problem(n,p,d,ttype)
+            circs = gen_QAOA_circs(G, gamma, beta)
+            peos, widths = gen_circs_peos(circs,my_algo)
+
+            maxCirc, maxPeo = get_max_peo_n_circ(circs, peos, widths)
+            for be in backends:
+                cpus = []
+                gpus = []
+                for _ in range(my_reap):
+                    with c.cpu_util_hist() as c_hist:
+                        with c.gpu_util_hist() as g_hist:
+                            gen_circ_peo_report_mix(maxCirc, maxPeo, be, thr)
+
+
+                    raw_cpu = process_one_series(c_hist.result)
+                    cooked_cpu = raw2df(raw_cpu, '500ms')
+                    cpus.append(cooked_cpu)
+
+                    raw_gpu = process_one_series(g_hist.result)
+                    cooked_gpu = raw2df(raw_gpu, '10ms')
+                    gpus.append(cooked_gpu)
+                reduced_cpu = df2reduced(cpus)
+                reduced_gpu = df2reduced(gpus)
+                print(reduced_cpu)
+                print()
+                print(reduced_gpu)
\ No newline at end of file
diff --git a/scratchpad/bench/circontraction/qaoa_eng_mixbe_test.py b/scratchpad/bench/circontraction/qaoa_eng_mixbe_test.py
new file mode 100644
index 00000000..f4216b2e
--- /dev/null
+++ b/scratchpad/bench/circontraction/qaoa_eng_mixbe_test.py
@@ -0,0 +1,322 @@
+import json
+from functools import lru_cache
+import numpy as np
+import cupy as cp
+import torch
+import random
+import networkx as nx
+import platform
+import pyrofiler
+import qtensor
+import time
+from qtensor import QtreeQAOAComposer
+from qtensor import QAOAQtreeSimulator
+from qtensor.contraction_backends import get_mixed_backend, get_mixed_perf_backend, get_gpu_perf_backend, get_cpu_perf_backend
+
+gpu_backends = ['torch_gpu', 'cupy', 'tr_torch', 'tr_cupy', 'tr_cutensor']
+cpu_backends = ['einsum', 'torch_cpu', 'mkl', 'opt_einsum', 'tr_einsum', 'opt_einsum']
+
+mempool = cp.get_default_memory_pool()
+pinned_mempool = cp.get_default_pinned_memory_pool()
+
+timing = pyrofiler.timing
+
+random.seed(42)
+np.random.seed(42)
+
+@lru_cache
+def get_test_problem(n=10, p=2, d=3, type='random'):
+    #print('Test problem: n, p, d', n, p, d)
+    if type == 'random':
+        seed = 250
+        G = nx.random_regular_graph(d, n, seed = 250)
+    elif type == 'grid2d':
+        G = nx.grid_2d_graph(n,n)
+    elif type == 'line':
+        G = nx.Graph()
+        G.add_edges_from(zip(range(n-1), range(1, n)))
+    gamma, beta = [np.pi/5]*p, [np.pi/2]*p
+    return G, gamma, beta
+
+paramtest = [
+    # n, p, degree, type
+     [12, 4, 3, 'random']
+    ,[10, 5, 2, 'random']
+    ,[14, 1, 3, 'random']
+    ,[3, 3, 0, 'grid2d']
+    ,[8, 4, 0, 'line']
+]
+
+def obj2dict(obj):
+    keys = [x for x in dir(obj) if x[0]!='_']
+    return dict((key, obj.__getattribute__(key)) for key in keys)
+
+@lru_cache
+def get_gpu_props_json():
+    try:
+        import torch
+        devprops = torch.cuda.get_device_properties(torch.cuda.current_device())
+        return obj2dict(devprops)
+    except:
+        return None
+
+def format_flops(flops):
+    ord = 3*int(np.log10(flops)/3)
+    suffix = {
+        3: 'k'
+        ,6: 'M'
+        ,9: 'G'
+        , 12: 'T'
+    }[ord]
+    return f'{(flops/10**ord).round(2)}{suffix}'
+
+def get_fixed_peos_for_a_pb(G, gamma, beta, algo:str, sim):
+    peos, widths = [], []
+    for edge in G.edges:
+        cir = sim._edge_energy_circuit(G, gamma, beta, edge)
+        tn = qtensor.optimisation.TensorNet.QtreeTensorNet.from_qtree_gates(cir)
+        opt = qtensor.toolbox.get_ordering_algo(algo)
+        peo, _ = opt.optimize(tn)
+        width = opt.treewidth
+        peos.append(peo)
+        widths.append(width)
+    return peos, widths
+
+def mean_mmax(x: list):
+    mx, mn = max(x), min(x)
+    x.remove(mx)
+    x.remove(mn)
+    return np.mean(x)
+
+
+
+'''
+Function:   Simulate one lightcone for one time, only for mixed be
+Attempt:    Only for Mixed Be
+I/O: -> list, np.ndarray
+'''
+def gen_mixed_lc_report(G, gamma, beta, edge, peo, backend_name, gen_base = 0):
+
+    curr_backend = get_mixed_perf_backend(backend_name[0], backend_name[1])   
+    curr_sim = QAOAQtreeSimulator(QtreeQAOAComposer,backend=curr_backend)
+    circuit = curr_sim._edge_energy_circuit(G, gamma, beta, edge)
+    curr_sim.simulate_batch(circuit, peo = peo)
+    
+    curr_backend.cpu_be.gen_report(show = False)
+    curr_backend.gpu_be.gen_report(show = False)
+
+    '''
+    Merging two report table together
+    CPU table on top, gpu second
+    '''
+    cpu_table = np.asarray(curr_backend.cpu_be.report_table.records)
+    gpu_table = np.asarray(curr_backend.gpu_be.report_table.records)
+    report_record = np.vstack((cpu_table, gpu_table))
+    #print("CPU Table Shape: ",cpu_table.shape)
+    #print(gpu_table.shape)
+    #print(all_table.shape)
+
+    '''
+    Checking Tensor Dims/bytes
+    1st Loop for cpu, 2nd loop for gpu
+    '''
+    tensor_dims = []
+    for i,x in enumerate(curr_backend.cpu_be._profile_results):
+        bc_signature, _ = curr_backend.cpu_be._profile_results[x]
+        bucket_size = []
+        for tensor in bc_signature:
+            tensor_2_size = [qtreeVar.size for qtreeVar in tensor]
+            tensor_dim = np.prod(tensor_2_size)
+            bucket_size.append(tensor_dim)
+        tensor_dims.append(sum(bucket_size))
+    
+    for i,x in enumerate(curr_backend.gpu_be._profile_results):
+        bc_signature, _ = curr_backend.gpu_be._profile_results[x]
+        bucket_size = []
+        for tensor in bc_signature:
+            tensor_2_size = [qtreeVar.size for qtreeVar in tensor]
+            tensor_dim = np.prod(tensor_2_size)
+            bucket_size.append(tensor_dim)
+        tensor_dims.append(sum(bucket_size))
+    
+    '''
+    Processing tensor_dims and gen_times as new columns
+    '''
+    tensor_dims = np.asarray(tensor_dims).reshape(-1,1)
+    gen_time = gen_base
+    gen_times = np.full((tensor_dims.shape), gen_time)
+
+
+    '''
+    Generate titles
+    '''
+    title_record = curr_backend.cpu_be.report_table._title_row()[1:]
+    title_record.append("byte")
+    title_record.append("gen_time")
+
+    '''
+    Modify new report table
+    '''
+    report_record = np.hstack((report_record,tensor_dims))
+    report_record = np.hstack((report_record,gen_times))
+
+    return title_record, report_record
+
+
+
+'''
+Function: Simulate one lightcone for one time, only for pure be
+TODO: make sure the I/O are the same
+'''
+def gen_be_lc_report(G, gamma, beta, edge, peo, backend_name, gen_base = 0):
+
+    if backend_name in gpu_backends:
+        curr_backend = get_gpu_perf_backend(backend_name)
+    else:
+        curr_backend = get_cpu_perf_backend(backend_name)
+    curr_sim = QAOAQtreeSimulator(QtreeQAOAComposer,backend=curr_backend)
+    circuit = curr_sim._edge_energy_circuit(G, gamma, beta, edge)
+    curr_sim.simulate_batch(circuit, peo = peo)
+    curr_sim.backend.gen_report(show = False)
+    report_record = np.asarray(curr_backend.report_table.records)
+    #print(report_record.shape)
+
+    '''
+    Generate report table data
+    '''
+    tensor_dims = []
+    for i, x in enumerate(curr_sim.backend._profile_results):
+        bucket_signature, _ = curr_sim.backend._profile_results[x]
+        bucket_size = []
+        #print(len(max(bucket_signature, key=len)))
+        for tensor in bucket_signature:
+            tensor_2_size = [qtreeVar.size for qtreeVar in tensor]
+            tensor_dim = np.prod(tensor_2_size)
+            bucket_size.append(tensor_dim)
+        tensor_dims.append(sum(bucket_size))
+
+    tensor_dims = np.asarray(tensor_dims).reshape(-1,1)
+    gen_time = gen_base
+    gen_times = np.full((tensor_dims.shape), gen_time)
+
+    title_record = curr_sim.backend.report_table._title_row()[1:]
+    title_record.append("byte")
+    title_record.append("gen_time")
+
+    report_record = np.hstack((report_record,tensor_dims))
+    report_record = np.hstack((report_record,gen_times))
+
+    return title_record, report_record
+
+
+def collect_reports_for_a_lc(G, gamma, beta, edge, peo, backend_name, repeat, gen_base):
+    bucketindex_2_reports = {}
+    '''
+    Collect each lc's report for [repeat] times
+    '''
+    for _ in range(repeat):
+        if type(backend_name) == list:
+            titles, report_table = gen_mixed_lc_report(G, gamma, beta, edge, peo, backend_name, gen_base)
+        else:
+            titles, report_table = gen_be_lc_report(G, gamma, beta, edge, peo, backend_name, gen_base)
+        for i, report in enumerate(report_table):
+            if i not in bucketindex_2_reports:
+                bucketindex_2_reports[i] = [report]
+            else:
+                bucketindex_2_reports[i].append(report)
+    
+    #print(bucketindex_2_reports)
+    #
+    return titles, bucketindex_2_reports
+
+
+def reduce_bucket_reports(G, gamma, beta, edge, peo, backend_name, repeat, gen_base):
+    bi_2_reduced = {}
+    titles, bi_2_reports = collect_reports_for_a_lc(G, gamma, beta, edge, peo, backend_name, repeat, gen_base)
+    
+    for bi, report in bi_2_reports.items():
+        bi_redux = []
+        t_report = np.transpose(report)
+        for attr in t_report:
+            bi_redux.append(mean_mmax(attr.tolist()))
+        bi_2_reduced[bi] = bi_redux
+    return titles, bi_2_reduced
+
+def process_reduced_data(G, gamma, beta, edge, peo, backend_name, problem, repeat, gen_base, lc_index, opt_algo):
+    if type(backend_name) == list:
+        final_backend_name = backend_name[0]+"-"+backend_name[1]
+    else:
+        final_backend_name = backend_name
+    titles, bi_2_reduced = reduce_bucket_reports(G, gamma, beta, edge, peo, backend_name, repeat, gen_base)
+    GPU_PROPS = get_gpu_props_json()
+    lc_collection = []
+    for bi, report in bi_2_reduced.items():
+        bi_json_usable = {}
+        bi_json_usable["backend"] = final_backend_name
+        bi_json_usable["device_props"] = dict(name=platform.node(), gpu=GPU_PROPS)
+        bi_json_usable["lightcone_index"] = lc_index
+        bi_json_usable["bucket_index"] = bi
+        bi_json_usable["opt_algo"] = opt_algo
+        for i, attr in enumerate(titles):
+            if attr == "flop":
+                bi_json_usable["ops"] = report[i]
+            else:
+                bi_json_usable[attr] = report[i]
+        bi_json_usable["problem"] = {
+                    "n" :problem[0] , 
+                    "p" :problem[1] ,
+                    "d" :problem[2] ,
+                    'type': problem[3]
+                    }
+        bi_json_usable["experiment_group"] = "Chen_Updated_Width_Mix"
+        lc_collection.append(bi_json_usable)
+    #print(json.dumps(lc_collection, indent = 4))
+
+    return lc_collection
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+'''
+testing 
+
+'''
+
+if __name__ == "__main__":
+    # mixed_be = get_mixed_perf_backend("einsum", "cupy")
+    # G, gamma, beta = get_test_problem(8,4,3,"random")
+    # sim = QAOAQtreeSimulator(QtreeQAOAComposer, backend = mixed_be)
+    # sim.energy_expectation(G, gamma = gamma, beta = beta)
+    # mixed_be.cpu_be.gen_report(show = True)
+    # mixed_be.gpu_be.gen_report(show = True)
+    gen_sim = QAOAQtreeSimulator(QtreeQAOAComposer)
+    my_algo = "greedy"
+    backends = ["einsum","torch_gpu",["torch_cpu", "torch_gpu"]]
+    
+    for pb in [paramtest[0]]:
+        with timing(callback=lambda x: None) as gen_pb:
+            n, p, d, ttype = pb
+            G, gamma, beta = get_test_problem(n=n, p=p,d=d,type = ttype)
+            peos, widths = get_fixed_peos_for_a_pb(G, gamma, beta, algo = my_algo, sim = gen_sim)
+        gen_base = gen_pb.result
+
+        for be in [backends[2]]:
+            
+            for i, pack in enumerate(zip(G.edges, peos)):
+                edge, peo = pack
+
+                curr_report =process_reduced_data(G, gamma, beta, edge, peo, be, pb, 3, gen_base, i, my_algo)
+                # for c in curr_report:
+                #      print(json.dumps(c))
+
+        
\ No newline at end of file
diff --git a/scratchpad/bench/circontraction/qaoa_eng_probing.py b/scratchpad/bench/circontraction/qaoa_eng_probing.py
new file mode 100644
index 00000000..59fd975d
--- /dev/null
+++ b/scratchpad/bench/circontraction/qaoa_eng_probing.py
@@ -0,0 +1,373 @@
+import json
+from functools import lru_cache
+import numpy as np
+import networkx as nx
+import platform
+import pyrofiler
+import qtensor
+from qtensor import QtreeQAOAComposer
+from qtensor import QAOAQtreeSimulator
+from qtensor.contraction_backends import get_cpu_perf_backend, get_gpu_perf_backend
+from scipy.optimize import curve_fit
+import matplotlib.pyplot as plt
+from scipy.optimize import fsolve
+from sklearn.metrics import r2_score
+from scipy.stats import chisquare, pearsonr
+
+gpu_backends = ['torch_gpu', 'cupy', 'tr_torch', 'tr_cupy', 'tr_cutensor']
+cpu_backends = ['einsum', 'torch_cpu', 'mkl', 'opt_einsum', 'tr_einsum', 'opt_einsum']
+timing = pyrofiler.timing
+
+def func(x,a,b,c,d):
+    # return (a*np.power(x1,-n))
+    return a*np.power(b, c*x) + d
+
+def diff(x, OPT1, OPT2):
+    return func(x, *OPT1) - func(x, *OPT2)
+
+@lru_cache
+def get_test_problem(n=10, p=2, d=3, type='random'):
+    #print('Test problem: n, p, d', n, p, d)
+    if type == 'random':
+        seed = 250
+        G = nx.random_regular_graph(d, n, seed = 250)
+    elif type == 'grid2d':
+        G = nx.grid_2d_graph(n,n)
+    elif type == 'line':
+        G = nx.Graph()
+        G.add_edges_from(zip(range(n-1), range(1, n)))
+    gamma, beta = [np.pi/5]*p, [np.pi/2]*p
+    return G, gamma, beta
+
+def obj2dict(obj):
+    keys = [x for x in dir(obj) if x[0]!='_']
+    return dict((key, obj.__getattribute__(key)) for key in keys)
+
+
+@lru_cache
+def get_gpu_props_json():
+    try:
+        import torch
+        devprops = torch.cuda.get_device_properties(torch.cuda.current_device())
+        return obj2dict(devprops)
+    except:
+        return None
+
+paramtest = [
+    [12,4,3,"random"]
+    ,[10, 5, 2, 'random']
+    ,[14, 1, 3, 'random']
+    # ,[3, 3, 0, 'grid2d']
+    # ,[8, 4, 0, 'line']
+]
+
+def mean_mmax(x: list):
+    mx, mn = max(x), min(x)
+    x.remove(mx)
+    x.remove(mn)
+    return np.mean(x)
+
+def format_flops(flops):
+    ord = 3*int(np.log10(flops)/3)
+    suffix = {
+        3: 'k'
+        ,6: 'M'
+        ,9: 'G'
+        , 12: 'T'
+    }[ord]
+    return f'{(flops/10**ord).round(2)}{suffix}'
+
+
+'''
+Purpose: For every test problem, generate one fixed contraction peos
+'''
+def get_fixed_peos_for_a_pb(G, gamma, beta, algo:str, sim):
+    peos, widths = [], []
+    for edge in G.edges:
+        cir = sim._edge_energy_circuit(G, gamma, beta, edge)
+        tn = qtensor.optimisation.TensorNet.QtreeTensorNet.from_qtree_gates(cir)
+        opt = qtensor.toolbox.get_ordering_algo(algo)
+        peo, _ = opt.optimize(tn)
+        width = opt.treewidth
+        peos.append(peo)
+        widths.append(width)
+    return peos, widths
+
+
+
+'''
+Function: Simulate one lightcone/edge for one time, we dont look for a lightcone aggregation
+CHANGE: Rid aggregation methods
+'''
+def gen_be_lc_report(G, gamma, beta, edge, peo, backend_name, gen_base = 0):
+
+    if backend_name in gpu_backends:
+        curr_backend = get_gpu_perf_backend(backend_name)
+    else:
+        curr_backend = get_cpu_perf_backend(backend_name)
+    curr_sim = QAOAQtreeSimulator(QtreeQAOAComposer,backend=curr_backend)
+    circuit = curr_sim._edge_energy_circuit(G, gamma, beta, edge)
+    curr_sim.simulate_batch(circuit, peo = peo)
+    curr_sim.backend.gen_report(show = False)
+
+    '''
+    Generate report table data
+    '''
+    tensor_dims = []
+    for i, x in enumerate(curr_sim.backend._profile_results):
+        bucket_signature, _ = curr_sim.backend._profile_results[x]
+        bucket_size = []
+        #print(len(max(bucket_signature, key=len)))
+        for tensor in bucket_signature:
+            tensor_2_size = [qtreeVar.size for qtreeVar in tensor]
+            tensor_dim = np.prod(tensor_2_size)
+            bucket_size.append(tensor_dim)
+        tensor_dims.append(sum(bucket_size))
+    
+    report_record = curr_sim.backend.report_table.records
+    gen_time = gen_base
+    title_record = curr_sim.backend.report_table._title_row()[1:]
+
+    '''
+    Modify and concatenate new report table
+    '''
+    title_record.append("byte")
+    title_record.append("gen_time")
+    for i, row in enumerate(report_record):
+        row.append(tensor_dims[i])
+        row.append(gen_time)
+
+    return title_record, report_record
+
+
+'''
+Function: bucket_index -> [repeat] amount of reports for this particular bucket
+'''
+def collect_reports_for_a_lc(G, gamma, beta, edge, peo, backend_name, repeat, gen_base):
+    bucketindex_2_reports = {}
+    '''
+    Collect each lc's report for [repeat] times
+    '''
+    for _ in range(repeat):
+        titles, report_table = gen_be_lc_report(G, gamma, beta, edge, peo, backend_name, gen_base)
+        for i, report in enumerate(report_table):
+            if i not in bucketindex_2_reports:
+                bucketindex_2_reports[i] = [report]
+            else:
+                bucketindex_2_reports[i].append(report)
+    
+    #print(bucketindex_2_reports)
+    return titles, bucketindex_2_reports
+
+'''
+Function: run above functions, collect reports, and reduce the data
+'''
+def reduce_bucket_reports(G, gamma, beta, edge, peo, backend_name, repeat, gen_base):
+    bi_2_reduced = {}
+    titles, bi_2_reports = collect_reports_for_a_lc(G, gamma, beta, edge, peo, backend_name, repeat, gen_base)
+    
+    for bi, report in bi_2_reports.items():
+        bi_redux = []
+        t_report = np.transpose(report)
+        for attr in t_report:
+            bi_redux.append(mean_mmax(attr.tolist()))
+        bi_2_reduced[bi] = bi_redux
+
+    return titles, bi_2_reduced
+
+'''
+Function: Takes in reduced data form, and process them into json format, with knowledge regarding lightcone index and bucket index
+'''
+def process_reduced_data(G, gamma, beta, edge, peo, backend_name, problem, repeat, gen_base, lc_index, opt_algo):
+    titles, bi_2_reduced = reduce_bucket_reports(G, gamma, beta, edge, peo, backend_name, repeat, gen_base)
+    GPU_PROPS = get_gpu_props_json()
+    lc_collection = []
+    for bi, report in bi_2_reduced.items():
+        bi_json_usable = {}
+        bi_json_usable["backend"] = backend_name
+        bi_json_usable["device_props"] = dict(name=platform.node(), gpu=GPU_PROPS)
+        bi_json_usable["lightcone_index"] = lc_index
+        bi_json_usable["bucket_index"] = bi
+        bi_json_usable["opt_algo"] = opt_algo
+        for i, attr in enumerate(titles):
+            if attr == "flop":
+                bi_json_usable["ops"] = report[i]
+            else:
+                bi_json_usable[attr] = report[i]
+        bi_json_usable["problem"] = {
+                    "n" :problem[0] , 
+                    "p" :problem[1] ,
+                    "d" :problem[2] ,
+                    'type': problem[3]
+                    }
+        bi_json_usable["experiment_group"] = "Angela_nslb_circuit"
+        lc_collection.append(bi_json_usable)
+    #print(json.dumps(lc_collection, indent = 4))
+
+    return lc_collection
+    
+
+'''
+Function: Takes in the total report for a backend, and generate the array_index -> sum time
+Update1: Change sum time to mean time
+'''
+def process_all_lc_reports(be_lc_reports:list):
+
+    width2times = {}
+
+    for lc in be_lc_reports:
+        for bucket in lc:
+            width = bucket["width"]
+            time = bucket["time"]
+            if width not in width2times:
+                width2times[width] = [time]
+            else:
+                width2times[width].append(time)
+    
+    width2meanTime = [0] * len(width2times)
+    for width, times in width2times.items():
+        width2meanTime[int(width-1)] = sum(times)/len(times)
+
+    return width2meanTime
+
+'''
+Fundtion: Takes in a dict of be->time distro, find the best threshold between cpu and gpu, single log transforming y
+'''
+def threshold_finding(dict_of_distro:dict):
+    
+    '''
+    1. Obtain Original Array
+    '''
+    npDistro = dict_of_distro["einsum"]
+    cpDistro = dict_of_distro["cupy"]
+    tcpuDistro = dict_of_distro["torch_cpu"]
+    tgpuDistro = dict_of_distro["torch_gpu"]
+
+
+    '''
+    2. Transform into natural log scale
+    '''
+    npLog = np.log(npDistro)
+    cpLog = np.log(cpDistro)
+    tcpuLog =np.log(tcpuDistro)
+    tgpuLog = np.log(tgpuDistro)
+
+    '''
+    3. Apply Shifting to avoid negative value
+    '''
+    shift = min(min(npLog), min(cpLog), min(tcpuLog), min(tgpuLog))
+
+    npFinal = npLog - shift
+    cpFinal = cpLog - shift
+    tcpuFinal = tcpuLog - shift
+    tgpuFinal = tgpuLog - shift
+
+    '''
+    4. Curve Fitting to original X
+    '''
+    X = np.arange(1,len(npDistro)+1)
+    npOPT, npCOV = curve_fit(func, X, npFinal, maxfev=1000000)
+    cpOPT, cpCOV = curve_fit(func, X, cpFinal, maxfev=1000000)
+    tcpuOPT, tcpuCOV = curve_fit(func, X, tcpuFinal, maxfev=1000000)
+    tgpuOPT, tgpuCOV = curve_fit(func, X, tgpuFinal, maxfev=1000000)
+    
+
+    '''
+    3. Plotting X vs. Final Log Transformation
+    '''
+    plt.scatter(X, npFinal, color = 'blue', s = 2)
+    plt.scatter(X, cpFinal, color = 'green', s=2)
+    plt.scatter(X, tcpuFinal, color = 'black', s=2)
+    plt.scatter(X, tgpuFinal, color = 'red',s=2)
+
+    '''
+    4. Plotting Line
+    '''
+    plt.plot(X, func(X, *npOPT), color="blue", linewidth=0.5, label = "Numpy: {:0.3e}*{:0.3f}^({:0.3f}*x) + {:0.3f}".format(*npOPT))
+    plt.plot(X, func(X, *cpOPT), color="green", linewidth=0.5, label = "CuPy: {:0.3e}*{:0.3f}^({:0.3f}*x) + {:0.3f}".format(*cpOPT))
+    plt.plot(X, func(X, *tcpuOPT), color="black", linewidth=0.5, label = "TCPU: {:0.3e}*{:0.3f}^({:0.3f}*x) + {:0.3f}".format(*tcpuOPT))
+    plt.plot(X, func(X, *tgpuOPT), color="red", linewidth=0.5, label = "TGPU: {:0.3e}*{:0.3f}^({:0.3f}*x) + {:0.3f}".format(*tgpuOPT))
+
+    plt.xticks(X)
+    plt.yticks()
+    plt.xlabel('Width')
+    plt.legend(loc = "upper left", prop={'size': 6})
+    plt.title("Mean Time vs Width")
+    plt.savefig("Probing.png")
+
+    print("Numpy: {:0.3e}*{:0.3f}^({:0.3f}*x) + {:0.3f}".format(*npOPT))
+    print("CuPy: {:0.3e}*{:0.3f}^({:0.3f}*x) + {:0.3f}".format(*cpOPT))
+    print("TCPU: {:0.3e}*{:0.3f}^({:0.3f}*x) + {:0.3f}".format(*tcpuOPT))
+    print("TGPU: {:0.3e}*{:0.3f}^({:0.3f}*x) + {:0.3f}".format(*tgpuOPT))
+
+    '''
+    5. Output threshold information
+    TODO: SOLVE THE EQUATIO
+    '''
+    np_cpT = fsolve(diff,10, args=(npOPT, cpOPT))
+    np_tgpuT = fsolve(diff,10, args=(npOPT, tgpuOPT))
+    tcpu_cpT = fsolve(diff,10, args=(tcpuOPT, cpOPT))
+    tcpu_tgpuT = fsolve(diff,10, args=(tcpuOPT, tgpuOPT))
+
+    print("Numpy-Cupy Threshold is {}.".format(np_cpT))
+    print("Numpy-TGPU Threshold is {}.".format(np_tgpuT))
+    print("TCPU-Cupy Threshold is {}.".format(tcpu_cpT))
+    print("TCPU-TGPU Threshold is {}.".format(tcpu_tgpuT))
+
+    '''
+    6. Output Strength Information
+    '''
+    npPred = np.array([func(i, *npOPT) for i in X])
+    cpPred = np.array([func(i, *cpOPT) for i in X])
+    tcpuPred = np.array([func(i, *tcpuOPT) for i in X])
+    tgpuPred = np.array([func(i, *tgpuOPT) for i in X])
+
+    npR2 = r2_score(npFinal, npPred)
+    cpR2 = r2_score(cpFinal, cpPred)
+    tcpuR2 = r2_score(tcpuFinal, tcpuPred)
+    tgpuR2 = r2_score(tgpuFinal, tgpuPred)
+
+    npChi2, npChiP = chisquare(npFinal, npPred)
+    cpChi2, cpChiP = chisquare(cpFinal, cpPred)
+    tcpuChi2, tcpuChiP = chisquare(tcpuFinal, tcpuPred)
+    tgpuChi2, tgpuChiP = chisquare(tgpuFinal, tgpuPred)
+
+    npPear, npPear_p = pearsonr(X, npPred)
+    cpPear, cpPear_p = pearsonr(X, cpPred)
+    tcpuPear, tcpuPear_p = pearsonr(X, tcpuPred)
+    tgpuPear, tgpuPear_p = pearsonr(X, tgpuPred)
+
+    print("Numpy Test: R2={:0.3f} Chi2={:0.3f} Pearson={:0.3f}".format(npR2, npChi2, npPear))
+    print("CuPy Test: R2={:0.3f} Chi2={:0.3f} Pearson={:0.3f}".format(cpR2, cpChi2, cpPear))
+    print("TCPU Test: R2={:0.3f} Chi2={:0.3f} Pearson={:0.3f}".format(tcpuR2, tcpuChi2, tcpuPear))
+    print("TGPU Test: R2={:0.3f} Chi2={:0.3f} Pearson={:0.3f}".format(tgpuR2, tgpuChi2, tgpuPear))
+    
+
+
+if __name__ == '__main__':
+    gen_sim = QAOAQtreeSimulator(QtreeQAOAComposer)
+    backends = ['einsum', 'torch_cpu', 'torch_gpu', 'cupy'] #'tr_torch'
+
+    my_algo = 'greedy'
+
+    for pb in [paramtest[0]]:
+
+        '''
+        Generate fixed peos for a given problem, thus be used for various backends
+        '''
+        with timing(callback=lambda x: None) as gen_pb:
+            n, p, d, ttype = pb
+            G, gamma, beta = get_test_problem(n=n,p=p,d=d, type = ttype)
+            peos, widths = get_fixed_peos_for_a_pb(G, gamma, beta, algo = my_algo, sim = gen_sim)
+
+        gen_base = gen_pb.result
+        be2timeDistro = {}
+        for be in backends:
+            all_lightcones_report = []
+            for i, pack in enumerate(zip(G.edges, peos)):
+                edge, peo = pack
+                curr_report = process_reduced_data(G, gamma, beta, edge, peo, be, pb, 5, gen_base, i, my_algo)
+                all_lightcones_report.append(curr_report)
+            distro = process_all_lc_reports(all_lightcones_report)
+            be2timeDistro[be] = distro
+        threshold_finding(be2timeDistro)
\ No newline at end of file
diff --git a/scratchpad/qaoa_eng_vs_backends.py b/scratchpad/bench/circontraction/qaoa_eng_vs_backends.py
similarity index 100%
rename from scratchpad/qaoa_eng_vs_backends.py
rename to scratchpad/bench/circontraction/qaoa_eng_vs_backends.py
diff --git a/scratchpad/qaoa_eng_vs_be_adv.py b/scratchpad/bench/circontraction/qaoa_eng_vs_be_adv.py
similarity index 100%
rename from scratchpad/qaoa_eng_vs_be_adv.py
rename to scratchpad/bench/circontraction/qaoa_eng_vs_be_adv.py
diff --git a/scratchpad/qaoa_eng_vs_be_adv_nsys.py b/scratchpad/bench/circontraction/qaoa_eng_vs_be_adv_nsys.py
similarity index 100%
rename from scratchpad/qaoa_eng_vs_be_adv_nsys.py
rename to scratchpad/bench/circontraction/qaoa_eng_vs_be_adv_nsys.py
diff --git a/scratchpad/qaoa_eng_vs_be_adv_sl.py b/scratchpad/bench/circontraction/qaoa_eng_vs_be_adv_sl.py
similarity index 88%
rename from scratchpad/qaoa_eng_vs_be_adv_sl.py
rename to scratchpad/bench/circontraction/qaoa_eng_vs_be_adv_sl.py
index 0e9638bb..2f6c009a 100644
--- a/scratchpad/qaoa_eng_vs_be_adv_sl.py
+++ b/scratchpad/bench/circontraction/qaoa_eng_vs_be_adv_sl.py
@@ -7,9 +7,11 @@
 import qtensor
 from qtensor import QtreeQAOAComposer
 from qtensor import QAOAQtreeSimulator
-from qtensor.contraction_backends import get_backend, get_perf_backend
+from qtensor.contraction_backends import get_backend, get_cpu_perf_backend, get_gpu_perf_backend
 from qtree.optimizer import Var
 
+gpu_backends = ['torch_gpu', 'cupy', 'tr_torch', 'tr_cupy', 'tr_cutensor']
+cpu_backends = ['einsum', 'torch_cpu', 'mkl', 'opt_einsum', 'tr_einsum', 'opt_einsum']
 
 timing = pyrofiler.timing
 
@@ -92,7 +94,10 @@ def get_fixed_peos_for_a_pb(G, gamma, beta, algo:str, sim):
 '''
 def gen_be_lc_report(G, gamma, beta, edge, peo, backend_name, gen_base = 0):
     with timing(callback = lambda x: None) as gen:
-        curr_backend = get_perf_backend(backend_name)
+        if backend_name in gpu_backends:
+            curr_backend = get_gpu_perf_backend(backend_name)
+        else:
+            curr_backend = get_cpu_perf_backend(backend_name)
         curr_sim = QAOAQtreeSimulator(QtreeQAOAComposer,backend=curr_backend)
         circuit = curr_sim._edge_energy_circuit(G, gamma, beta, edge)
     curr_sim.simulate_batch(circuit, peo = peo)
@@ -238,7 +243,7 @@ def gen_json_for_be_pt(backend_name: str, problem:list, redux_report: dict, opt_
                     "d" :problem[2] ,
                     'type': problem[3]
                     },
-        experiment_group = "Chen_A100_Test"
+        experiment_group = "Angela_nslb_circuit_sl"
         # add a field for lightcone_index
     )
     return res
@@ -248,7 +253,7 @@ def gen_json_for_be_pt(backend_name: str, problem:list, redux_report: dict, opt_
 
 if __name__ == '__main__':
     gen_sim = QAOAQtreeSimulator(QtreeQAOAComposer)
-    backends = ["cupy","torch_gpu","einsum","torch","tr_einsum","opt_einsum"]
+    backends = ['einsum', 'torch_cpu', 'opt_einsum', 'tr_einsum', 'opt_einsum', 'torch_gpu', 'cupy', 'tr_cupy', 'tr_cutensor'] #'tr_torch'
     my_algo = 'rgreedy_0.05_30'
 
     for pb in [paramtest[0]]:
@@ -262,42 +267,19 @@ def gen_json_for_be_pt(backend_name: str, problem:list, redux_report: dict, opt_
             peos, widths = get_fixed_peos_for_a_pb(G, gamma, beta, algo = my_algo, sim = gen_sim)
 
         gen_base = gen_pb.result
-        for be in [backends[2]]:
+        for be in [backends[5]]:
             '''
             Collecting all lightcones' reduced report
             '''
             all_lightcones_report = []
             for i, pack in enumerate(zip(G.edges, peos)):
                 edge, peo = pack
+                
                 curr_lightcone_report = collect_reports_for_a_lc(G, gamma, beta, edge, peo, be, 3,i, gen_base)
                 reduced_lightcone_report = reduce_reports_for_a_lc(curr_lightcone_report)
-                ''''
-                DESIGN CHOICE:
-                convert reduced_lightcone_report into a json-usable formart here
-                then append to all_lightcone_report
-                '''
                 js_usable = gen_json_for_be_pt(be, pb, reduced_lightcone_report, my_algo)
-                #print(js_usable)
                 all_lightcones_report.append(js_usable)
-                #print("{}th lc finished REEEEEEEEEEEEEE".format(i))
 
             
             print(json.dumps(all_lightcones_report, indent=4))
-
-            ''''
-            UNCOMMENT THE BELOW FOR FINAL USEAGE
-            '''
-            #merged_report = merge_all_lightcones_report(all_lightcones_report)
-
-            '''
-            Reduced Merged Report, good for writing the final json
-            '''
-            #merged_report_reduced = reduce_merged_report(merged_report)
-
-
-            '''
-            generate report for current backend and problem
-            '''
-            #final = json.dumps(gen_json_for_be_pt(be, pb, merged_report, opt_algo= my_algo), indent = 4)
-            #print(final)
             
\ No newline at end of file
diff --git a/scratchpad/qaoa_eng_vs_be_adv_sl_bc.py b/scratchpad/bench/circontraction/qaoa_eng_vs_be_adv_sl_bc.py
similarity index 82%
rename from scratchpad/qaoa_eng_vs_be_adv_sl_bc.py
rename to scratchpad/bench/circontraction/qaoa_eng_vs_be_adv_sl_bc.py
index c0b3ce55..df0c7916 100644
--- a/scratchpad/qaoa_eng_vs_be_adv_sl_bc.py
+++ b/scratchpad/bench/circontraction/qaoa_eng_vs_be_adv_sl_bc.py
@@ -7,8 +7,10 @@
 import qtensor
 from qtensor import QtreeQAOAComposer
 from qtensor import QAOAQtreeSimulator
-from qtensor.contraction_backends import get_backend, get_perf_backend
+from qtensor.contraction_backends import get_backend, get_cpu_perf_backend, get_gpu_perf_backend
 
+gpu_backends = ['torch_gpu', 'cupy', 'cutensor', 'tr_torch', 'tr_cupy', 'tr_cutensor']
+cpu_backends = ['einsum', 'torch_cpu', 'mkl', 'opt_einsum', 'tr_einsum', 'opt_einsum']
 
 timing = pyrofiler.timing
 
@@ -42,12 +44,12 @@ def get_gpu_props_json():
         return None
 
 paramtest = [
-    [4,4,3,"random"]
-    ,[4, 4, 3, 'random']
-    ,[10, 5, 2, 'random']
-    ,[14, 1, 3, 'random']
-    ,[3, 3, 0, 'grid2d']
-    ,[8, 4, 0, 'line']
+     [24, 4, 3, 'random']
+    # [4,4,3,"random"]
+    # ,[10, 5, 2, 'random']
+    # ,[14, 1, 3, 'random']
+    # ,[3, 3, 0, 'grid2d']
+    # ,[8, 4, 0, 'line']
 ]
 
 def mean_mmax(x: list):
@@ -90,7 +92,10 @@ def get_fixed_peos_for_a_pb(G, gamma, beta, algo:str, sim):
 '''
 def gen_be_lc_report(G, gamma, beta, edge, peo, backend_name, gen_base = 0):
 
-    curr_backend = get_perf_backend(backend_name)
+    if backend_name in gpu_backends:
+        curr_backend = get_gpu_perf_backend(backend_name)
+    else:
+        curr_backend = get_cpu_perf_backend(backend_name)
     curr_sim = QAOAQtreeSimulator(QtreeQAOAComposer,backend=curr_backend)
     circuit = curr_sim._edge_energy_circuit(G, gamma, beta, edge)
     curr_sim.simulate_batch(circuit, peo = peo)
@@ -103,6 +108,7 @@ def gen_be_lc_report(G, gamma, beta, edge, peo, backend_name, gen_base = 0):
     for i, x in enumerate(curr_sim.backend._profile_results):
         bucket_signature, _ = curr_sim.backend._profile_results[x]
         bucket_size = []
+        #print(len(max(bucket_signature, key=len)))
         for tensor in bucket_signature:
             tensor_2_size = [qtreeVar.size for qtreeVar in tensor]
             tensor_dim = np.prod(tensor_2_size)
@@ -185,7 +191,7 @@ def process_reduced_data(G, gamma, beta, edge, peo, backend_name, problem, repea
                     "d" :problem[2] ,
                     'type': problem[3]
                     }
-        bi_json_usable["experiment_group"] = "Chen_AV100_Test"
+        bi_json_usable["experiment_group"] = "Angela_nslb_circuit_all"
         lc_collection.append(bi_json_usable)
     #print(json.dumps(lc_collection, indent = 4))
 
@@ -196,7 +202,12 @@ def process_reduced_data(G, gamma, beta, edge, peo, backend_name, problem, repea
 
 if __name__ == '__main__':
     gen_sim = QAOAQtreeSimulator(QtreeQAOAComposer)
-    backends = ["cupy","torch_gpu","einsum","torch","tr_einsum","opt_einsum"]
+    backends = ['tr_cutensor', 'tr_cupy', 'tr_torch', 'tr_einsum'
+                , 'cupy', 'torch_gpu' 
+                , 'torch_cpu', 'einsum',  'opt_einsum'
+                , 'cutensor']
+
+
     my_algo = 'rgreedy_0.05_30'
 
     for pb in [paramtest[0]]:
@@ -211,12 +222,14 @@ def process_reduced_data(G, gamma, beta, edge, peo, backend_name, problem, repea
 
         gen_base = gen_pb.result
         agg_reports = []
-        for be in backends:
+        for be in [backends[0]]:
             all_lightcones_report = []
             for i, pack in enumerate(zip(G.edges, peos)):
                 edge, peo = pack
-                curr_report = process_reduced_data(G, gamma, beta, edge, peo, be, pb, 3, 114514, i, my_algo)
-                for c in curr_report:
-                    print(json.dumps(c))
-                #all_lightcones_report.append(curr_report)
-            agg_reports.append(all_lightcones_report)
\ No newline at end of file
+                #curr_report = process_reduced_data(G, gamma, beta, edge, peo, be, pb, 3, 114514, i, my_algo)
+                curr_report = gen_be_lc_report(G, gamma, beta, edge, peo, be, 114514)
+                print("{}th LC complete!".format(i+1))
+                # for c in curr_report:
+                #     print(json.dumps(c))
+            #     #all_lightcones_report.append(curr_report)
+            # agg_reports.append(all_lightcones_report)
diff --git a/scratchpad/bench/circontraction_new/child.py b/scratchpad/bench/circontraction_new/child.py
new file mode 100644
index 00000000..d0b57849
--- /dev/null
+++ b/scratchpad/bench/circontraction_new/child.py
@@ -0,0 +1,48 @@
+import pyrofiler
+import time
+
+def func1(x,y):
+    # use PROF defined in profile_with_context_advanced.py
+    @pyrofiler.PROF.cpu(desc='Func 1', reference=(x,y))
+    def sleep1():
+        time.sleep(.1)
+    
+    sleep1()
+    return 1
+
+def func2(x,y):
+    with pyrofiler.PROF.timing(desc='Func 2', reference=(x,y)):
+        time.sleep(.2)
+    return 1
+
+
+def original():
+    time.sleep(0.3)
+
+def func3(x,y):
+    with pyrofiler.PROF.timing(desc='Func 3', reference=(x,y)):
+        original()
+    return 1
+
+def func45(x,y):
+
+    with pyrofiler.PROF.timing(desc='Func 4', reference = (x,y)):
+        time.sleep(0.4)
+    
+    with pyrofiler.PROF.timing(desc='Func 5', reference = (x,y)):
+        time.sleep(0.5)
+
+
+
+
+
+def total():
+    for i in range(2):
+        for x in range(3):
+            for y in range(3):
+                func1(x,y)
+                # func2(x,y)
+                # func3(x,y)
+
+                # with pyrofiler.PROF.timing("Func 4", reference = (x,y)):
+                #     time.sleep(0.4)
diff --git a/scratchpad/bench/circontraction_new/load_basic.py b/scratchpad/bench/circontraction_new/load_basic.py
new file mode 100644
index 00000000..75c28930
--- /dev/null
+++ b/scratchpad/bench/circontraction_new/load_basic.py
@@ -0,0 +1,198 @@
+from functools import lru_cache
+import json
+import numpy as np
+import networkx as nx
+import qtensor
+from qtensor import QtreeQAOAComposer
+from qtensor import QAOAQtreeSimulator
+from qtensor.contraction_backends import get_backend, get_mixed_backend, get_embedded_backend
+import pyrofiler
+from pyrofiler import Profiler
+from pyrofiler import callbacks
+import random
+from collections import defaultdict
+
+random.seed(42)
+np.random.seed(42)
+
+@lru_cache
+def get_test_problem(n=10, p=2, d=3, type='random'):
+    print('Test problem: n, p, d', n, p, d)
+    if type == 'random':
+        G = nx.random_regular_graph(d, n, seed = 250)
+    elif type == 'grid2d':
+        G = nx.grid_2d_graph(n,n)
+    elif type == 'line':
+        G = nx.Graph()
+        G.add_edges_from(zip(range(n-1), range(1, n)))
+    gamma, beta = [np.pi/5]*p, [np.pi/2]*p
+    return G, gamma, beta
+
+def gen_QAOA_circs(G, gamma, beta):
+    gen_sim = QAOAQtreeSimulator(QtreeQAOAComposer)
+    circs = []
+    for edge in G.edges:
+        circ = gen_sim._edge_energy_circuit(G, gamma, beta, edge)
+        circs.append(circ)
+    return circs
+
+
+def gen_circs_peos(circuits, algo):
+    peos = []
+    widths = []
+    for circ  in circuits:
+        tn = qtensor.optimisation.TensorNet.QtreeTensorNet.from_qtree_gates(circ)
+        opt = qtensor.toolbox.get_ordering_algo(algo)
+        peo, _ = opt.optimize(tn)
+        treeWidth = opt.treewidth
+        peos.append(peo)
+        widths.append(treeWidth)
+    return peos, widths
+
+'''
+TODO: a function to find the max peos and circ
+'''
+def get_max_peo_n_circ(circuits, peos, widths):
+    max_width = max(widths)
+    print("Max Tree Width: {}".format(max_width))
+    max_index = widths.index(max_width)
+    return circuits[max_index], peos[max_index]
+
+
+def gen_circ_peo_report_mix(circuit, peo, backend_name, threshold):
+
+    curr_backend = get_mixed_backend(backend_name[0], backend_name[1], threshold)
+    curr_sim = QAOAQtreeSimulator(QtreeQAOAComposer,backend=curr_backend)
+    curr_sim.simulate_batch(circuit, peo = peo)
+
+def gen_circ_peo_report(circuit, peo, backend):
+    curr_backend = get_backend(backend)
+    curr_sim = QAOAQtreeSimulator(QtreeQAOAComposer,backend=curr_backend)
+    curr_sim.simulate_batch(circuit, peo = peo)
+
+def gen_circ_peo_report_embedded(circuit, peo, backend):
+    curr_backend = get_embedded_backend(backend)
+    curr_sim = QAOAQtreeSimulator(QtreeQAOAComposer,backend=curr_backend)
+    curr_sim.simulate_batch(circuit, peo = peo)
+
+    #Bucket Elimination is the loop
+    #Create wrapper functions so that identifiers can be seen inside the profiling
+
+
+
+
+paramtest = [
+    [12,4,3,"random"]
+]
+
+
+class MyProfiler(Profiler):
+    def __init__(self, callback=None):
+        super().__init__(callback=callback)
+        self.use_append()
+
+    def get_stats(self, label):
+        data = [x['value'] for x in self.data[label]]
+        return dict(
+            mean=np.mean(data),
+            max = np.max(data),
+            std = np.std(data),
+            min = np.min(data)
+        )
+    
+    # Transform the table to be
+    # ref fun1 fun2
+    def get_refs(self):
+        pass
+
+prof = MyProfiler()
+
+'''
+1. Pass the profiler globally
+'''
+pyrofiler.PROF = prof
+
+'''
+2. Wrapping the calback function so that the data is stored in this format:
+    data[desc] = dict
+'''
+default_cb = prof.get_callback() #returns self._callbeck, the default callback in this case
+def my_callback(value, desc, reference=0):
+    default_cb(dict(reference=reference, value=value), desc) #wrapping, data[desc] = dict()
+prof.set_callback(my_callback)
+
+def main():
+    backends = ['torch_gpu']
+    my_reap = 5
+    my_algo = 'greedy'
+    callbacks.disable_printing()
+    
+
+    for pb in paramtest:
+        n, p, d, ttype = pb
+        G, gamma, beta = get_test_problem(n,p,d,ttype)
+        circs = gen_QAOA_circs(G, gamma, beta)
+        peos, widths = gen_circs_peos(circs,my_algo)
+
+        maxCirc, maxPeo = get_max_peo_n_circ(circs, peos, widths)
+        for be in backends:
+            for _ in range(my_reap):
+                gen_circ_peo_report_embedded(maxCirc, maxPeo, be)
+
+main()
+
+def reorderData(data):
+    
+    result = defaultdict(dict)
+    
+    for function in data:
+        func_dict = defaultdict(list)
+        
+        # func_dict = ref -> list(value)
+        for ref_val in data[function]:
+            reference = ref_val['reference']
+            value = ref_val['value']
+            func_dict[reference].append(value)
+        
+        # result => ref -> {func1:[] func2:[]}
+        for ref in func_dict:
+            times = func_dict[ref]
+            result[ref][function] = times
+    
+    return result
+
+
+def describeData(data):
+    result = defaultdict(dict)
+    for ref in data:
+        funcs = data[ref]
+        for func in funcs:
+            times = funcs[func]
+            func_desc = dict(
+                mean=np.mean(times),
+                max = np.max(times),
+                std = np.std(times),
+                min = np.min(times)
+            )
+            result[ref][func] = func_desc
+    return result
+
+described = describeData(reorderData(prof.data))
+
+
+
+
+def totalReport(data):
+    report = []
+    for entry, functions in data.items():
+        item = {}
+        item["bucket"] = entry[0]
+        item["tensor"] = entry[1]
+        for func in functions:
+            item[func] = functions[func]['mean']
+        report.append(item)
+
+    return report
+
+for rep in totalReport(described):
+    print(json.dumps(rep))
diff --git a/scratchpad/bench/circontraction_new/mother.py b/scratchpad/bench/circontraction_new/mother.py
new file mode 100644
index 00000000..29c13ce0
--- /dev/null
+++ b/scratchpad/bench/circontraction_new/mother.py
@@ -0,0 +1,106 @@
+from pyrofiler import Profiler
+import pyrofiler
+import child
+import numpy as np
+from pyrofiler import callbacks
+from collections import defaultdict
+import time
+
+class MyProfiler(Profiler):
+    def __init__(self, callback=None):
+        super().__init__(callback=callback)
+        self.use_append()
+
+    def get_stats(self, label):
+        data = [x['value'] for x in self.data[label]]
+        return dict(
+            mean=np.mean(data),
+            max = np.max(data),
+            std = np.std(data),
+            min = np.min(data)
+        )
+    
+    # Transform the table to be
+    # ref fun1 fun2
+    def get_refs(self):
+        pass
+
+prof = MyProfiler()
+
+'''
+1. Pass the profiler globally
+'''
+pyrofiler.PROF = prof
+
+'''
+2. Wrapping the calback function so that the data is stored in this format:
+    data[desc] = dict
+'''
+default_cb = prof.get_callback() #returns self._callbeck, the default callback in this case
+def my_callback(value, desc, reference=0):
+    default_cb(dict(reference=reference, value=value), desc) #wrapping, data[desc] = dict()
+prof.set_callback(my_callback)
+
+
+
+
+
+# def my_function(i):
+#     with prof.timing('My_func_time', reference=i):
+#         time.sleep(i)
+
+def main():
+
+    '''
+    Directly calls the function that is wrapped
+    '''
+    # callbacks.disable_printing()
+    child.total()
+
+main()
+# print('Pyrofiler data', prof.data)
+# print('Pyrofiler main', prof.data['from another file'])
+
+
+def reorderData(data):
+    
+    result = defaultdict(dict)
+    
+    for function in data:
+        func_dict = defaultdict(list)
+        
+        # func_dict = ref -> list(value)
+        for ref_val in data[function]:
+            reference = ref_val['reference']
+            value = ref_val['value']
+            func_dict[reference].append(value)
+        
+        # result => ref -> {func1:[] func2:[]}
+        for ref in func_dict:
+            times = func_dict[ref]
+            result[ref][function] = times
+    
+    return result
+
+
+def describeData(data):
+    result = defaultdict(dict)
+    for ref in data:
+        funcs = data[ref]
+        for func in funcs:
+            times = funcs[func]
+            func_desc = dict(
+                mean=np.mean(times),
+                max = np.max(times),
+                std = np.std(times),
+                min = np.min(times)
+            )
+            result[ref][func] = func_desc
+    return result
+
+
+# reordered = reorderData(prof.data)
+# described = describeData(reordered)
+
+
+print(prof.data)
\ No newline at end of file
diff --git a/scratchpad/bench/circuit.py b/scratchpad/bench/circuit.py
index 06ebc571..9dd0da48 100644
--- a/scratchpad/bench/circuit.py
+++ b/scratchpad/bench/circuit.py
@@ -9,20 +9,26 @@
 
 import qtree
 import qtensor
-try:
-    import ctf
-except ImportError:
-    print('Can\'t import ctf')
+# try:
+#     import ctf
+# except ImportError:
+#     print('Can\'t import ctf')
 
 ELEMENT_SIZE = np.zeros((1,), dtype=np.complex128).itemsize
 
+
 def get_backend(backend):
     return {
         'mkl': qtensor.contraction_backends.CMKLExtendedBackend
         , 'einsum': qtensor.contraction_backends.NumpyBackend
-        , 'tr_einsum': qtensor.contraction_backends.TransposedBackend
+        , 'tr_einsum': qtensor.contraction_backends.NumpyTranspoedBackend
         , 'torch': qtensor.contraction_backends.TorchBackend
         , 'opt_einsum': qtensor.contraction_backends.OptEinusmBackend
+        , 'tr_torch': qtensor.contraction_backends.TorchTransposedBackend
+        , 'cupy': qtensor.contraction_backends.CuPyBackend
+        , 'tr_cupy': qtensor.contraction_backends.CupyTransposedBackend
+        , 'tr_cutensor': qtensor.contraction_backends.CutensorTransposedBackend
+
     }[backend]
 
 def callback(x, desc):
@@ -98,7 +104,7 @@ def subst(*args, **kwargs):
             sim.simulate_batch(comp.circuit, peo=peo)
 
         print('max shape', max(map(len, shapes)))
-        print(f'max size {max(mem)*ELEMENT_SIZE:,} ')
+        # print(f'max size {max(mem)*ELEMENT_SIZE:,} ')
         try:
             print('sum times', sum(backend.times))
             print('all times', sum(backend.times_all))
@@ -109,5 +115,5 @@ def subst(*args, **kwargs):
             pass
 
 if __name__=="__main__":
-    fire.Fire(test_mem)
-
+    # fire.Fire(test_mem)
+    test_mem(N=10, backend='tr_cutensor')
diff --git a/scratchpad/bench/matmul.py b/scratchpad/bench/matmul.py
new file mode 100644
index 00000000..f2aa934f
--- /dev/null
+++ b/scratchpad/bench/matmul.py
@@ -0,0 +1,213 @@
+from numpy.core.fromnumeric import size
+import pyrofiler
+from typing import List
+from contextlib import contextmanager
+from dataclasses import dataclass
+from functools import lru_cache
+import itertools
+import platform
+import importlib
+
+from base import LasyModule, BenchResult, Backend, get_gpu_props_json, Benchmark, Numpy, TorchCuda, Cupy, CuTensor
+
+np = LasyModule('numpy')
+torch = LasyModule('torch')
+cupy = LasyModule('cupy')
+cupy_cutensor = LasyModule('cutensor')
+import sys
+import os
+sys.path.append(os.environ['HOME']+"/.local")
+exatn = LasyModule('exatn')
+
+
+class MatmulBench(Benchmark):
+    @staticmethod
+    def get_task_type():
+        return "matmul"
+    
+    @classmethod
+    def get_params(cls, *sizes):
+        ops = np.prod(sizes[0]) * sizes[1][1]
+        param_in = np.prod(sizes[0]) + np.prod(sizes[1])
+        param_out = sizes[0][0]*sizes[1][1]
+        return ops.item(), param_in.item(), param_out
+
+    @staticmethod
+    def benchmark(backend:Backend, num_tensors, *sizes, dtype='float', **args):
+        num_tensors, *sizes = backend.get_ready(num_tensors, *sizes)
+        operation = backend.get_matmul()
+        with backend.timing(callback=lambda x: None) as gen:
+            tensors = backend.gen_tensors(num_tensors, *sizes, dtype=dtype)
+        with backend.timing(callback=lambda x: None) as prep:
+            for i in range(len(tensors)):
+                tensors[i] = backend.prepare(tensors[i])
+        with backend.timing(callback=lambda x: None) as op:
+            out_tensor = operation(*tensors)
+        with backend.timing(callback=lambda x: None) as get:
+            zr = backend.get_result(out_tensor)
+        return zr, BenchResult(gen_time=gen.result, transfer_time=prep.result+get.result, operation_time=op.result)
+
+    @classmethod
+    def print_results_json(cls, use_strip, backend, *sizes, dtype, results: List[BenchResult], experiment_group="default group"):
+        prefix = {
+            'float': 2
+            ,'double': 2
+            ,'complex64': 8
+            ,'complex128': 8
+        }[dtype]
+        import json
+        GPU_PROPS = get_gpu_props_json()
+        tt1 = [r.gen_time for r in results]
+        tt2 = [r.operation_time for r in results]
+        tt3 = [r.transfer_time for r in results]
+        m1, m3 = np.mean(tt1), np.mean(tt3)
+        if use_strip:
+            m1 = cls.mean_mmax(tt1)
+            m2 = cls.mean_mmax(tt2)
+            m3 = cls.mean_mmax(tt3)
+        else:
+            m1, m2, m3 = np.mean(tt1), np.mean(tt2), np.mean(tt3)
+        s1, s2, s3 = np.std(tt1), np.std(tt2), np.std(tt3)
+        ops, param_in, param_out = cls.get_params(*sizes)
+        flops = prefix*ops/m2
+        task_type = cls.get_task_type()
+        avg_size = int(np.mean(sizes))
+        res = dict(
+            task_type=task_type
+            , backend=backend
+            , size=avg_size
+            , sizes=sizes
+            , itemsize=cls.get_dtype_size(dtype)
+            , input_bytes=cls.get_dtype_size(dtype)*param_in
+            , output_bytes=cls.get_dtype_size(dtype)*param_out
+            , dtype=dtype
+            , device_props=dict(name=platform.node(), gpu=GPU_PROPS)
+            , transfer_time=m3
+            , transfer_relstd=s3
+            , gen_time=m1
+            , gen_relstd=s1
+            , operation_time=m2
+            , operation_relstd=s2
+            , ops=ops
+            , flops=flops
+            , flops_str=cls.format_flops(flops)
+            , fbratio=ops/(cls.get_dtype_size(dtype)*param_in)
+            , experiment_group=experiment_group
+        )
+        print(json.dumps(res), flush=True)
+        return res
+
+
+# @dataclass
+# class ExatnTensor:
+#     name: str
+#     shape: tuple
+#     dtype: str
+
+# class Exatn(Backend):
+#     # infinite name generator
+#     name_generator = (hex(x)[1:] for x, _
+#                       in enumerate(itertools.repeat(0)))
+#     allocated_tensor_names = []
+#     @classmethod
+#     def cleanup_tensors(cls):
+#         for name in cls.allocated_tensor_names:
+#             # will produce a warning on non-existent tensor
+#             exatn.destroyTensor(name)
+#         cls.allocated_tensor_names = []
+
+#     @staticmethod
+#     def get_dtype(dtype):
+#         return Numpy.get_dtype(dtype)
+
+#     @classmethod
+#     def gen_tensor(cls, *sizes, dtype='float'):
+#         tname = next(cls.name_generator)
+#         rand = Numpy.gen_tensor(*sizes, dtype=dtype)
+#         #print('create ten', tname)
+#         success = exatn.createTensor(tname, rand.copy(order='F'))
+#         #print('done', tname)
+#         if success:
+#             cls.allocated_tensor_names.append(tname)
+#             return ExatnTensor(name=tname, shape=sizes, dtype=dtype)
+
+#     @classmethod
+#     def exatn_matmul(cls, x, y):
+#         """
+#         Takes two names of tensors, should be already allocated,
+#         returns name of resulting tensor
+
+#         Args:
+#             x: ExatnTensor
+#             y: ExatnTensor
+#         """
+#         #exatn.evaluateTensorNetwork('sum', 'SR1() = R1(a)*R2(a)')
+#         res = next(cls.name_generator)
+#         res_shape = x.shape[0], y.shape[1]
+#         #print('create res', res, res_shape)
+#         dtype = Numpy.get_dtype(x.dtype)
+#         res_body = np.zeros(res_shape, dtype=dtype)
+#         exatn.createTensor(res, res_body)
+#         cls.allocated_tensor_names.append(res)
+#         st = f'{res}(a,c)={x.name}(a,b)*{y.name}(b,c)'
+#         #print('st', st)
+#         _ = exatn.contractTensors(st, 1.0)
+#         #print('contr')
+#         return res
+
+#     @classmethod
+#     def get_operation(cls):
+#         return cls.exatn_matmul
+
+#     @classmethod
+#     def get_result(cls, x):
+#         t = exatn.getLocalTensor(x)
+#         cls.cleanup_tensors()
+#         return t
+
+
+
+
+
+def main():
+
+    experiment_group = "Angela_nslb_matmul_v100"
+
+
+    num_tensors = 2
+    sizes_m = [10, 100, 1000, 1024, 1025, 2000, 4090, 4096, 8192]
+    sizes_n = [10, 100, 1000, 1024, 1025, 2000, 4090, 4096, 8192]
+    sizes_l = [10, 100, 1000, 1024, 1025, 2000, 4090, 4096, 8192]   
+
+    backends = {
+        'numpy':Numpy
+        # ,'exatn': Exatn
+    }
+    if get_gpu_props_json():
+        backends.update({
+            'torch':TorchCuda
+            , 'cupy':Cupy
+            , 'cutensor': CuTensor
+        })
+
+    use_strip = True
+    repeats = 5
+    if use_strip:
+        repeats += 2
+    dtypes = ['float', 'double', 'complex64', 'complex128']
+
+    for backend in backends:
+        for size_m, size_n, size_l in zip(sizes_m, sizes_n, sizes_l):
+            sizes = [size_m,size_n], [size_n, size_l]
+            results = []
+            for dtype in dtypes:
+                for _ in range(repeats):
+                    b = backends[backend]
+                    matmulbench = MatmulBench()
+                    _, bench_result = matmulbench.benchmark(b, num_tensors, *sizes, dtype=dtype)
+                    results.append(bench_result)
+                json_result = matmulbench.print_results_json(use_strip, backend, *sizes, dtype=dtype, results=results, experiment_group=experiment_group)
+
+if __name__ == "__main__":
+    main()
+
diff --git a/scratchpad/bench/matmul/bench.py b/scratchpad/bench/matmul/bench.py
index 6d77a2ac..b1e98dc4 100644
--- a/scratchpad/bench/matmul/bench.py
+++ b/scratchpad/bench/matmul/bench.py
@@ -323,7 +323,7 @@ def main():
     #sizes = [2000, 3000]
     backends = {
         'numpy':Numpy
-        ,'exatn': Exatn
+        # ,'exatn': Exatn
     }
     if get_gpu_props_json():
         backends.update({
diff --git a/scratchpad/bench/matmul/benchmark.py b/scratchpad/bench/matmul/benchmark.py
new file mode 100644
index 00000000..d58986e0
--- /dev/null
+++ b/scratchpad/bench/matmul/benchmark.py
@@ -0,0 +1,416 @@
+from numpy.core.fromnumeric import size
+import pyrofiler
+from typing import List
+from contextlib import contextmanager
+from dataclasses import dataclass
+from functools import lru_cache
+import itertools
+import platform
+import importlib
+
+class LasyModule:
+    def __init__(self, modulename):
+        self.modulename = modulename
+        self.module = None
+    def __getattr__(self, attr):
+        if self.module is None:
+            self.module = importlib.import_module(self.modulename)
+        return self.module.__getattribute__(attr)
+
+np = LasyModule('numpy')
+torch = LasyModule('torch')
+cupy = LasyModule('cupy')
+cupy_cutensor = LasyModule('cutensor')
+import sys
+import os
+sys.path.append(os.environ['HOME']+"/.local")
+exatn = LasyModule('exatn')
+
+@dataclass
+class BenchResult:
+    gen_time: float
+    transfer_time: float
+    mult_time: float
+
+
+class Backend:
+    @staticmethod
+    def prepare(x):
+        return x
+
+
+    @staticmethod
+    def get_result(x):
+        return x
+
+    timing=pyrofiler.timing
+
+    @classmethod
+    def gen_tensor(cls, *sizes, dtype='float'):
+        raise NotImplementedError
+
+    @staticmethod
+    def get_matmul():
+        raise NotImplementedError
+
+    @classmethod
+    def benchmark_matmul(cls, size_m, size_n, size_l, dtype):
+        # this line will also trigger lazy import
+        matmul = cls.get_matmul()
+        with cls.timing(callback=lambda x: None) as gen:
+            x = cls.gen_tensor(size_m, size_n, dtype=dtype)
+            y = cls.gen_tensor(size_n, size_l, dtype=dtype)
+            if cls == CuTensor:
+                z = cls.gen_tensor(size_m, size_l, dtype=dtype)
+        with cls.timing(callback=lambda x: None) as prep:
+            x = cls.prepare(x)
+            y = cls.prepare(y)
+            if cls == CuTensor:
+                z = cls.prepare(z)
+        with cls.timing(callback=lambda x: None) as mm:
+            if cls == CuTensor:
+                z = matmul(x,y,z)
+            else:
+                z = matmul(x,y)
+        with cls.timing(callback=lambda x: None) as get:
+            zr = cls.get_result(z)
+        return zr, BenchResult(gen_time=gen.result, transfer_time=prep.result+get.result, mult_time=mm.result)
+
+class Numpy(Backend):
+    @staticmethod
+    def get_dtype(dtype):
+        return {
+            'float':np.float32
+            ,'double': np.float64
+            ,'complex64': np.complex64
+            ,'complex128': np.complex128
+        }[dtype]
+
+    @classmethod
+    def gen_tensor(cls, *sizes, dtype='float'):
+        dtype_t = cls.get_dtype(dtype)
+        return np.random.rand(*sizes).astype(dtype_t)
+
+    @staticmethod
+    def get_matmul():
+        return np.matmul
+
+
+class Torch(Backend):
+    @staticmethod
+    def get_dtype(dtype):
+        return {
+            'float':torch.float32
+            ,'double': torch.float64
+            ,'complex64': torch.complex64
+            ,'complex128': torch.complex128
+        }[dtype]
+
+    @classmethod
+    def gen_tensor(cls, *sizes, dtype='float'):
+        dtype = cls.get_dtype(dtype)
+        return torch.rand(*sizes, dtype=dtype)
+
+    @staticmethod
+    def get_matmul():
+        return torch.matmul
+
+
+class TorchCuda(Torch):
+    @classmethod
+    @contextmanager
+    def timing(cls, **kwargs):
+        class Foo:
+            pass
+        res = Foo()
+        start = torch.cuda.Event(enable_timing=True)
+        end = torch.cuda.Event(enable_timing=True)
+        start.record()
+        yield res
+        end.record()
+        torch.cuda.synchronize()
+        res.result = start.elapsed_time(end)/1000
+
+    @staticmethod
+    def prepare(x):
+        return x.to('cuda')
+
+
+class Cupy(Backend):
+    @classmethod
+    @contextmanager
+    def timing(cls, **kwargs):
+        class Foo:
+            pass
+        res = Foo()
+        start = cupy.cuda.Event(disable_timing=False)
+        end = cupy.cuda.Event(disable_timing=False)
+        start.record()
+        yield res
+        end.record()
+
+        #I'm not sure about this line, just guessed by analogy from torch
+        # Without it raises DeviceNotReady erorr
+        end.synchronize()
+
+        res.result = cupy.cuda.get_elapsed_time(start, end)/1000
+
+    @staticmethod
+    def get_dtype(dtype):
+        return {
+            'float':cupy.float32
+            ,'double': cupy.float64
+            ,'complex64': cupy.complex64
+            ,'complex128': cupy.complex128
+        }[dtype]
+
+    @classmethod
+    def gen_tensor(cls, *sizes, dtype='float'):
+        dtype_t = cls.get_dtype(dtype)
+        return cupy.random.rand(*sizes).astype(dtype_t)
+
+    @staticmethod
+    def get_matmul():
+        with pyrofiler.timing('cblas handler'):
+            cupy.cuda.device.get_cublas_handle()
+        return cupy.matmul
+
+
+class CuTensor(Cupy):
+
+    @classmethod
+    def gen_tensor(cls, *sizes, dtype='float'):
+        dtype_t = cls.get_dtype(dtype)
+        return cupy.random.rand(*sizes).astype(dtype_t)
+
+    @classmethod
+    def cutensor_matmul(cls, x, y, z):
+        [x, desc_x] = x
+        [y, desc_y] = y
+        [z, desc_z] = z
+        from cupy import cutensor
+        return cutensor.contraction(1, x, desc_x, cls.mode_x, 
+                                y, desc_y, cls.mode_y, 0, 
+                                z, desc_z, cls.mode_z)
+    
+    @classmethod
+    def get_matmul(cls):
+        with pyrofiler.timing('cblas handler'):
+            cupy.cuda.device.get_cublas_handle()
+        return cls.cutensor_matmul
+    
+    @classmethod
+    def prepare(cls, x):
+        from cupy import cutensor
+        if not hasattr(cls, 'extent'):
+            cls.mode_x = ('m', 'k')
+            cls.mode_y = ('k', 'n')
+            cls.mode_z = ('m', 'n')
+            cls.mode_x = cutensor.create_mode(*cls.mode_x)
+            cls.mode_y = cutensor.create_mode(*cls.mode_y)
+            cls.mode_z = cutensor.create_mode(*cls.mode_z)
+        desc_x = cutensor.create_tensor_descriptor(x)
+        return [x, desc_x]
+    
+
+@dataclass
+class ExatnTensor:
+    name: str
+    shape: tuple
+    dtype: str
+
+class Exatn(Backend):
+    # infinite name generator
+    name_generator = (hex(x)[1:] for x, _
+                      in enumerate(itertools.repeat(0)))
+    allocated_tensor_names = []
+    @classmethod
+    def cleanup_tensors(cls):
+        for name in cls.allocated_tensor_names:
+            # will produce a warning on non-existent tensor
+            exatn.destroyTensor(name)
+        cls.allocated_tensor_names = []
+
+    @staticmethod
+    def get_dtype(dtype):
+        return Numpy.get_dtype(dtype)
+
+    @classmethod
+    def gen_tensor(cls, *sizes, dtype='float'):
+        tname = next(cls.name_generator)
+        rand = Numpy.gen_tensor(*sizes, dtype=dtype)
+        #print('create ten', tname)
+        success = exatn.createTensor(tname, rand.copy(order='F'))
+        #print('done', tname)
+        if success:
+            cls.allocated_tensor_names.append(tname)
+            return ExatnTensor(name=tname, shape=sizes, dtype=dtype)
+
+    @classmethod
+    def exatn_matmul(cls, x, y):
+        """
+        Takes two names of tensors, should be already allocated,
+        returns name of resulting tensor
+
+        Args:
+            x: ExatnTensor
+            y: ExatnTensor
+        """
+        #exatn.evaluateTensorNetwork('sum', 'SR1() = R1(a)*R2(a)')
+        res = next(cls.name_generator)
+        res_shape = x.shape[0], y.shape[1]
+        #print('create res', res, res_shape)
+        dtype = Numpy.get_dtype(x.dtype)
+        res_body = np.zeros(res_shape, dtype=dtype)
+        exatn.createTensor(res, res_body)
+        cls.allocated_tensor_names.append(res)
+        st = f'{res}(a,c)={x.name}(a,b)*{y.name}(b,c)'
+        #print('st', st)
+        _ = exatn.contractTensors(st, 1.0)
+        #print('contr')
+        return res
+
+    @classmethod
+    def get_matmul(cls):
+        return cls.exatn_matmul
+
+    @classmethod
+    def get_result(cls, x):
+        t = exatn.getLocalTensor(x)
+        cls.cleanup_tensors()
+        return t
+
+
+def format_flops(flops):
+    ord = 3*int(np.log10(flops)/3)
+    suffix = {
+        3: 'k'
+        ,6: 'M'
+        ,9: 'G'
+        , 12: 'T'
+    }[ord]
+    return f'{(flops/10**ord).round(2)}{suffix}'
+
+def obj2dict(obj):
+    keys = [x for x in dir(obj) if x[0]!='_']
+    return dict((key, obj.__getattribute__(key)) for key in keys)
+
+@lru_cache
+def get_gpu_props_json():
+    try:
+        import torch
+        devprops = torch.cuda.get_device_properties(torch.cuda.current_device())
+        return obj2dict(devprops)
+    except:
+        return None
+
+
+def print_results_csv(backend, size, dtype, results: List[BenchResult]):
+    tt1 = [r.gen_time for r in results]
+    tt2 = [r.mult_time for r in results]
+    m1, m2 = np.mean(tt1), np.mean(tt2)
+    s1, s2 = np.std(tt1), np.std(tt2)
+    flops = size**3/m2
+    print(f'{backend}, {size}, {dtype}, {m1}, {(s1/m1).round(4)}, {m2}, {(s2/m2).round(4)}, {format_flops(flops)}')
+
+
+def get_dtype_size(dtype):
+    dtype_t = Numpy.get_dtype(dtype)
+    x = np.ones(10, dtype=dtype_t)
+    return x.itemsize
+
+
+def mean_mmax(x: list):
+    mx, mn = max(x), min(x)
+    x.remove(mx)
+    x.remove(mn)
+    return np.mean(x)
+
+#whether to use the removal of max and min before mean
+# does not affect standard deviation or other times, only matmul
+use_strip = True
+
+def print_results_json(task_type, backend, size_m, size_n, size_l, dtype, results: List[BenchResult], experiment_group="default group"):
+    import json
+    GPU_PROPS = get_gpu_props_json()
+    tt1 = [r.gen_time for r in results]
+    tt2 = [r.mult_time for r in results]
+    tt3 = [r.transfer_time for r in results]
+    m1, m3 = np.mean(tt1), np.mean(tt3)
+    if use_strip:
+        m2 = mean_mmax(tt2)
+    else:
+        m2 = np.mean(tt2)
+    s1, s2, s3 = np.std(tt1), np.std(tt2), np.std(tt3)
+    flops = size_m*size_n*size_l/m2
+    res = dict(
+        task_type=task_type
+        , backend=backend
+        , size_m=size_m
+        , size_n=size_n
+        , size_l=size_l
+        , itemsize=get_dtype_size(dtype)
+        , bytes=get_dtype_size(dtype)*(size_m*size_n+size_n*size_l)
+        , dtype=dtype
+        , device_props=dict(name=platform.node(), gpu=GPU_PROPS)
+        , transfer_time=m3
+        , transfer_relstd=s3
+        , gen_time=m1
+        , gen_relstd=s1
+        , mult_time=m2
+        , mult_relstd=s2
+        , flops=flops
+        , flops_str=format_flops(flops)
+        , experiment_group=experiment_group
+    )
+    print(json.dumps(res), flush=True)
+    return res
+
+
+def main():
+
+    sizes_m = [10, 100, 1000, 1024, 1025, 2000, 4090, 4096]
+    sizes_n = [10, 100, 1000, 1024, 1025, 2000, 4090, 4096]
+    sizes_l = [10, 100, 1000, 1024, 1025, 2000, 4090, 4096]
+    # sizes_l = [2, 2, 2, 2, 2, 2, 2, 2]
+    experiment_group = "default_pod_matmul"
+    #sizes = [2000, 3000]
+    backends = {
+        'numpy':Numpy
+        # ,'exatn': Exatn
+    }
+    if get_gpu_props_json():
+        backends.update({
+            'torch':TorchCuda,
+            'cupy':Cupy,
+            'cutensor': CuTensor
+        })
+
+    repeats = 5
+    if use_strip:
+        repeats += 2
+    task_type = 'matmul'
+    dtypes = ['float', 'double', 'complex64', 'complex128']
+
+    # print(f'backend, size, dtype, Time1 mean, Time1 relstd, Time2 mean, Time2 relstd, FLOPs')
+    
+    import json
+
+    with open('data.json', mode='w') as f:
+
+        for backend in backends:
+            for size_m, size_n, size_l in zip(sizes_m, sizes_n, sizes_l):
+                results = []
+                for dtype in dtypes:
+                    for _ in range(repeats):
+                        b = backends[backend]
+                        _, bench_result = b.benchmark_matmul(size_m, size_n, size_l, dtype)
+                        results.append(bench_result)
+
+                    json_result = print_results_json(task_type, backend, size_m, size_n, size_l, dtype, results, experiment_group)
+                    # f.write(json.dumps(json_result))
+                    # f.write(",")
+
+if __name__ == "__main__":
+    main()
+
diff --git a/scratchpad/bench/matmul/benchmark_example.py b/scratchpad/bench/matmul/benchmark_example.py
new file mode 100644
index 00000000..d0c26ef6
--- /dev/null
+++ b/scratchpad/bench/matmul/benchmark_example.py
@@ -0,0 +1,414 @@
+from numpy.core.fromnumeric import size
+import pyrofiler
+from typing import List
+from contextlib import contextmanager
+from dataclasses import dataclass
+from functools import lru_cache
+import itertools
+import platform
+import importlib
+
+class LasyModule:
+    def __init__(self, modulename):
+        self.modulename = modulename
+        self.module = None
+    def __getattr__(self, attr):
+        if self.module is None:
+            self.module = importlib.import_module(self.modulename)
+        return self.module.__getattribute__(attr)
+
+np = LasyModule('numpy')
+torch = LasyModule('torch')
+cupy = LasyModule('cupy')
+cupy_cutensor = LasyModule('cutensor')
+import sys
+import os
+sys.path.append(os.environ['HOME']+"/.local")
+exatn = LasyModule('exatn')
+
+@dataclass
+class BenchResult:
+    gen_time: float
+    transfer_time: float
+    mult_time: float
+
+
+class Backend:
+    @staticmethod
+    def prepare(x):
+        return x
+
+
+    @staticmethod
+    def get_result(x):
+        return x
+
+    timing=pyrofiler.timing
+
+    @classmethod
+    def gen_tensor(cls, *sizes, dtype='float'):
+        raise NotImplementedError
+
+    @staticmethod
+    def get_matmul():
+        raise NotImplementedError
+
+    @classmethod
+    def benchmark_matmul(cls, size_m, size_n, size_l, dtype):
+        # this line will also trigger lazy import
+        matmul = cls.get_matmul()
+        with cls.timing(callback=lambda x: None) as gen:
+            x = cls.gen_tensor(size_m, size_n, dtype=dtype)
+            y = cls.gen_tensor(size_n, size_l, dtype=dtype)
+            if cls == CuTensor:
+                z = cls.gen_tensor(size_m, size_l, dtype=dtype)
+        with cls.timing(callback=lambda x: None) as prep:
+            x = cls.prepare(x)
+            y = cls.prepare(y)
+            if cls == CuTensor:
+                z = cls.prepare(z)
+        with cls.timing(callback=lambda x: None) as mm:
+            if cls == CuTensor:
+                z = matmul(x,y,z)
+            else:
+                z = matmul(x,y)
+        with cls.timing(callback=lambda x: None) as get:
+            zr = cls.get_result(z)
+        return zr, BenchResult(gen_time=gen.result, transfer_time=prep.result+get.result, mult_time=mm.result)
+
+class Numpy(Backend):
+    @staticmethod
+    def get_dtype(dtype):
+        return {
+            'float':np.float32
+            ,'double': np.float64
+            ,'complex64': np.complex64
+            ,'complex128': np.complex128
+        }[dtype]
+
+    @classmethod
+    def gen_tensor(cls, *sizes, dtype='float'):
+        dtype_t = cls.get_dtype(dtype)
+        return np.random.rand(*sizes).astype(dtype_t)
+
+    @staticmethod
+    def get_matmul():
+        return np.matmul
+
+
+class Torch(Backend):
+    @staticmethod
+    def get_dtype(dtype):
+        return {
+            'float':torch.float32
+            ,'double': torch.float64
+            ,'complex64': torch.complex64
+            ,'complex128': torch.complex128
+        }[dtype]
+
+    @classmethod
+    def gen_tensor(cls, *sizes, dtype='float'):
+        dtype = cls.get_dtype(dtype)
+        return torch.rand(*sizes, dtype=dtype)
+
+    @staticmethod
+    def get_matmul():
+        return torch.matmul
+
+
+class TorchCuda(Torch):
+    @classmethod
+    @contextmanager
+    def timing(cls, **kwargs):
+        class Foo:
+            pass
+        res = Foo()
+        start = torch.cuda.Event(enable_timing=True)
+        end = torch.cuda.Event(enable_timing=True)
+        start.record()
+        yield res
+        end.record()
+        torch.cuda.synchronize()
+        res.result = start.elapsed_time(end)/1000
+
+    @staticmethod
+    def prepare(x):
+        return x.to('cuda')
+
+
+class Cupy(Backend):
+    @classmethod
+    @contextmanager
+    def timing(cls, **kwargs):
+        class Foo:
+            pass
+        res = Foo()
+        start = cupy.cuda.Event(disable_timing=False)
+        end = cupy.cuda.Event(disable_timing=False)
+        start.record()
+        yield res
+        end.record()
+
+        #I'm not sure about this line, just guessed by analogy from torch
+        # Without it raises DeviceNotReady erorr
+        end.synchronize()
+
+        res.result = cupy.cuda.get_elapsed_time(start, end)/1000
+
+    @staticmethod
+    def get_dtype(dtype):
+        return {
+            'float':cupy.float32
+            ,'double': cupy.float64
+            ,'complex64': cupy.complex64
+            ,'complex128': cupy.complex128
+        }[dtype]
+
+    @classmethod
+    def gen_tensor(cls, *sizes, dtype='float'):
+        dtype_t = cls.get_dtype(dtype)
+        return cupy.random.rand(*sizes).astype(dtype_t)
+
+    @staticmethod
+    def get_matmul():
+        with pyrofiler.timing('cblas handler'):
+            cupy.cuda.device.get_cublas_handle()
+        return cupy.matmul
+
+
+class CuTensor(Cupy):
+
+    @classmethod
+    def gen_tensor(cls, *sizes, dtype='float'):
+        dtype_t = cls.get_dtype(dtype)
+        return cupy.random.rand(*sizes).astype(dtype_t)
+
+    @classmethod
+    def cutensor_matmul(cls, x, y, z):
+        [x, desc_x] = x
+        [y, desc_y] = y
+        [z, desc_z] = z
+        from cupy import cutensor
+        return cutensor.contraction(1, x, desc_x, cls.mode_x, 
+                                y, desc_y, cls.mode_y, 0, 
+                                z, desc_z, cls.mode_z)
+    
+    @classmethod
+    def get_matmul(cls):
+        with pyrofiler.timing('cblas handler'):
+            cupy.cuda.device.get_cublas_handle()
+        return cls.cutensor_matmul
+    
+    @classmethod
+    def prepare(cls, x):
+        from cupy import cutensor
+        if not hasattr(cls, 'extent'):
+            cls.mode_x = ('m', 'k')
+            cls.mode_y = ('k', 'n')
+            cls.mode_z = ('m', 'n')
+            cls.mode_x = cutensor.create_mode(*cls.mode_x)
+            cls.mode_y = cutensor.create_mode(*cls.mode_y)
+            cls.mode_z = cutensor.create_mode(*cls.mode_z)
+        desc_x = cutensor.create_tensor_descriptor(x)
+        return [x, desc_x]
+    
+
+@dataclass
+class ExatnTensor:
+    name: str
+    shape: tuple
+    dtype: str
+
+class Exatn(Backend):
+    # infinite name generator
+    name_generator = (hex(x)[1:] for x, _
+                      in enumerate(itertools.repeat(0)))
+    allocated_tensor_names = []
+    @classmethod
+    def cleanup_tensors(cls):
+        for name in cls.allocated_tensor_names:
+            # will produce a warning on non-existent tensor
+            exatn.destroyTensor(name)
+        cls.allocated_tensor_names = []
+
+    @staticmethod
+    def get_dtype(dtype):
+        return Numpy.get_dtype(dtype)
+
+    @classmethod
+    def gen_tensor(cls, *sizes, dtype='float'):
+        tname = next(cls.name_generator)
+        rand = Numpy.gen_tensor(*sizes, dtype=dtype)
+        #print('create ten', tname)
+        success = exatn.createTensor(tname, rand.copy(order='F'))
+        #print('done', tname)
+        if success:
+            cls.allocated_tensor_names.append(tname)
+            return ExatnTensor(name=tname, shape=sizes, dtype=dtype)
+
+    @classmethod
+    def exatn_matmul(cls, x, y):
+        """
+        Takes two names of tensors, should be already allocated,
+        returns name of resulting tensor
+        Args:
+            x: ExatnTensor
+            y: ExatnTensor
+        """
+        #exatn.evaluateTensorNetwork('sum', 'SR1() = R1(a)*R2(a)')
+        res = next(cls.name_generator)
+        res_shape = x.shape[0], y.shape[1]
+        #print('create res', res, res_shape)
+        dtype = Numpy.get_dtype(x.dtype)
+        res_body = np.zeros(res_shape, dtype=dtype)
+        exatn.createTensor(res, res_body)
+        cls.allocated_tensor_names.append(res)
+        st = f'{res}(a,c)={x.name}(a,b)*{y.name}(b,c)'
+        #print('st', st)
+        _ = exatn.contractTensors(st, 1.0)
+        #print('contr')
+        return res
+
+    @classmethod
+    def get_matmul(cls):
+        return cls.exatn_matmul
+
+    @classmethod
+    def get_result(cls, x):
+        t = exatn.getLocalTensor(x)
+        cls.cleanup_tensors()
+        return t
+
+
+def format_flops(flops):
+    ord = 3*int(np.log10(flops)/3)
+    suffix = {
+        3: 'k'
+        ,6: 'M'
+        ,9: 'G'
+        , 12: 'T'
+    }[ord]
+    return f'{(flops/10**ord).round(2)}{suffix}'
+
+def obj2dict(obj):
+    keys = [x for x in dir(obj) if x[0]!='_']
+    return dict((key, obj.__getattribute__(key)) for key in keys)
+
+@lru_cache
+def get_gpu_props_json():
+    try:
+        import torch
+        devprops = torch.cuda.get_device_properties(torch.cuda.current_device())
+        return obj2dict(devprops)
+    except:
+        return None
+
+
+def print_results_csv(backend, size, dtype, results: List[BenchResult]):
+    tt1 = [r.gen_time for r in results]
+    tt2 = [r.mult_time for r in results]
+    m1, m2 = np.mean(tt1), np.mean(tt2)
+    s1, s2 = np.std(tt1), np.std(tt2)
+    flops = size**3/m2
+    print(f'{backend}, {size}, {dtype}, {m1}, {(s1/m1).round(4)}, {m2}, {(s2/m2).round(4)}, {format_flops(flops)}')
+
+
+def get_dtype_size(dtype):
+    dtype_t = Numpy.get_dtype(dtype)
+    x = np.ones(10, dtype=dtype_t)
+    return x.itemsize
+
+
+def mean_mmax(x: list):
+    mx, mn = max(x), min(x)
+    x.remove(mx)
+    x.remove(mn)
+    return np.mean(x)
+
+#whether to use the removal of max and min before mean
+# does not affect standard deviation or other times, only matmul
+use_strip = True
+
+def print_results_json(task_type, backend, size_m, size_n, size_l, dtype, results: List[BenchResult], experiment_group="default group"):
+    import json
+    GPU_PROPS = get_gpu_props_json()
+    tt1 = [r.gen_time for r in results]
+    tt2 = [r.mult_time for r in results]
+    tt3 = [r.transfer_time for r in results]
+    m1, m3 = np.mean(tt1), np.mean(tt3)
+    if use_strip:
+        m2 = mean_mmax(tt2)
+    else:
+        m2 = np.mean(tt2)
+    s1, s2, s3 = np.std(tt1), np.std(tt2), np.std(tt3)
+    flops = size_m*size_n*size_l/m2
+    res = dict(
+        task_type=task_type
+        , backend=backend
+        , size_m=size_m
+        , size_n=size_n
+        , size_l=size_l
+        , itemsize=get_dtype_size(dtype)
+        , bytes=get_dtype_size(dtype)*size_m*size_l**2
+        , dtype=dtype
+        , device_props=dict(name=platform.node(), gpu=GPU_PROPS)
+        , transfer_time=m3
+        , transfer_relstd=s3
+        , gen_time=m1
+        , gen_relstd=s1
+        , mult_time=m2
+        , mult_relstd=s2
+        , flops=flops
+        , flops_str=format_flops(flops)
+        , experiment_group=experiment_group
+    )
+    print(json.dumps(res), flush=True)
+    return res
+
+
+def main():
+
+    sizes_m = [10, 100, 1000, 1024, 1025, 2000, 4090, 4096]
+    sizes_n = [10, 100, 1000, 1024, 1025, 2000, 4090, 4096]
+    sizes_l = [10, 100, 1000, 1024, 1025, 2000, 4090, 4096]
+    # sizes_l = [2, 2, 2, 2, 2, 2, 2, 2]
+    experiment_group = "default_pod_matmul"
+    #sizes = [2000, 3000]
+    backends = {
+        'numpy':Numpy
+        # ,'exatn': Exatn
+    }
+    if get_gpu_props_json():
+        backends.update({
+            'torch':TorchCuda,
+            'cupy':Cupy,
+            'cutensor': CuTensor
+        })
+
+    repeats = 5
+    if use_strip:
+        repeats += 2
+    task_type = 'matmul'
+    dtypes = ['float', 'double', 'complex64', 'complex128']
+
+    # print(f'backend, size, dtype, Time1 mean, Time1 relstd, Time2 mean, Time2 relstd, FLOPs')
+    
+    import json
+
+    with open('data.json', mode='w') as f:
+
+        for backend in backends:
+            for size_m, size_n, size_l in zip(sizes_m, sizes_n, sizes_l):
+                results = []
+                for dtype in dtypes:
+                    for _ in range(repeats):
+                        b = backends[backend]
+                        _, bench_result = b.benchmark_matmul(size_m, size_n, size_l, dtype)
+                        results.append(bench_result)
+
+                    json_result = print_results_json(task_type, backend, size_m, size_n, size_l, dtype, results, experiment_group)
+                    # f.write(json.dumps(json_result))
+                    # f.write(",")
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file
diff --git a/scratchpad/bench/matmul/data.json b/scratchpad/bench/matmul/data.json
new file mode 100644
index 00000000..e69de29b
diff --git a/scratchpad/bench/test.py b/scratchpad/bench/test.py
new file mode 100644
index 00000000..ea6b470f
--- /dev/null
+++ b/scratchpad/bench/test.py
@@ -0,0 +1,264 @@
+from types import DynamicClassAttribute
+from numpy.core.fromnumeric import shape, size
+import pyrofiler
+from typing import List
+from contextlib import contextmanager, nullcontext
+from dataclasses import dataclass
+from functools import lru_cache
+import itertools
+import platform
+import importlib
+import os, psutil
+
+from base import LasyModule, BenchResult, Backend, get_gpu_props_json, Benchmark, Numpy, TorchCuda, Cupy, CuTensor
+
+np = LasyModule('numpy')
+
+import sys
+import os
+sys.path.append(os.environ['HOME']+"/.local")
+exatn = LasyModule('exatn')
+
+
+@dataclass
+class RandomContract:
+    is_random: bool
+    contraction: str
+    num_indices_result: int = 0
+    num_contracted_indices: int = 0
+    fill_number: int = 2
+    is_transpose: bool = False
+
+
+class TncontractBench(Benchmark):    
+    @staticmethod
+    def get_task_type():
+        return "tncontract"
+    
+    @classmethod
+    def get_params(cls, *sizes, contraction:RandomContract):
+        *in_size, out_size = sizes
+        unit_size = in_size[0][0]
+        ops = unit_size**(contraction.num_indices_result+contraction.num_contracted_indices)
+        param_in = np.prod(in_size[0]) + np.prod(in_size[1])
+        param_out = np.prod(out_size)
+        return ops, param_in.item(), param_out.item(), unit_size
+
+    @staticmethod
+    def benchmark(backend:Backend, num_tensors, contraction:RandomContract, *sizes, dtype='float'):
+        num_tensors, *size = backend.get_ready(num_tensors, *sizes, contraction=contraction)
+        operation = backend.get_tncontract()
+        with backend.timing(callback=lambda x: None) as gen:
+            tensors = backend.gen_tensors(num_tensors, *size[0], dtype=dtype)
+        with backend.timing(callback=lambda x: None) as prep:
+                for i in range(num_tensors):
+                    tensors[i] = backend.prepare(tensors[i])
+        with backend.timing(callback=lambda x: None) as op:
+            if contraction.contraction != '':
+                out_tensor = operation(contraction.contraction, *tensors)
+            else:
+                out_tensor = operation(*tensors)
+        with backend.timing(callback=lambda x: None) as get:
+            zr = backend.get_result(out_tensor)
+        return zr, BenchResult(gen_time=gen.result, transfer_time=prep.result+get.result, operation_time=op.result)
+
+    @classmethod
+    def print_results_json(cls, use_strip, backend, *sizes, dtype, results: List[BenchResult], experiment_group="default group", contraction:RandomContract=None):
+        prefix = {
+            'float': 2
+            ,'double': 2
+            ,'complex64': 8
+            ,'complex128': 8
+        }[dtype]
+        import json
+        GPU_PROPS = get_gpu_props_json()
+        tt1 = [r.gen_time for r in results]
+        tt2 = [r.operation_time for r in results]
+        tt3 = [r.transfer_time for r in results]
+        m1, m3 = np.mean(tt1), np.mean(tt3)
+        if use_strip:
+            m1 = cls.mean_mmax(tt1)
+            m2 = cls.mean_mmax(tt2)
+            m3 = cls.mean_mmax(tt3)
+        else:
+            m1, m2, m3 = np.mean(tt1), np.mean(tt2), np.mean(tt3)
+        s1, s2, s3 = np.std(tt1), np.std(tt2), np.std(tt3)
+        sizes = sizes[0]
+        ops, param_in, param_out, unit_size = cls.get_params(*sizes, contraction=contraction)
+        flops = prefix*ops/m2
+        task_type = cls.get_task_type()
+        res = dict(
+            task_type=task_type
+            , backend=backend
+            , size=unit_size
+            , sizes=sizes
+            , size_idx=[len(x) for x in sizes]
+            , contraction=dict(contraction=contraction.contraction
+                , num_indices_result=contraction.num_indices_result
+                , num_contracted_indices=contraction.num_contracted_indices
+                , is_transpose=contraction.is_transpose
+                )
+            , itemsize=cls.get_dtype_size(dtype)
+            , input_bytes=cls.get_dtype_size(dtype)*param_in
+            , output_bytes=cls.get_dtype_size(dtype)*param_out
+            , dtype=dtype
+            , device_props=dict(name=platform.node(), gpu=GPU_PROPS)
+            , transfer_time=m3
+            , transfer_relstd=s3
+            , gen_time=m1
+            , gen_relstd=s1
+            , operation_time=m2
+            , operation_relstd=s2
+            , ops=ops
+            , flops=flops
+            , flops_str=cls.format_flops(flops)
+            , fbratio=ops/(cls.get_dtype_size(dtype)*param_in)
+            , experiment_group=experiment_group
+        )
+        print(res)
+        # print(json.dumps(res), flush=True)
+        return res
+
+
+def gen_sizes(is_random, contraction='', fill_number=2, num_total_indices=0, num_indices_result=0, num_contracted_indices=0):
+    CHARS = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
+
+    import random
+    from itertools import accumulate
+
+    # seed = 10
+    # np.random.seed(seed)
+    # random.seed(seed)
+    
+    if not is_random and contraction != '':
+        # square tensors of form [n,n,n,n],[n,n,n,n]->[n,n,n]
+        inp, out = contraction.split('->')
+        size = inp.split(',')
+        sizes = [np.full(len(x), fill_number).tolist() for x in size]
+        out_size = np.full(len(out), fill_number).tolist()
+        randomcontract = RandomContract(is_random, contraction, 3, 2, fill_number)
+    else:
+        while True:
+            num_indices_result = np.random.randint(num_total_indices)
+            num_contracted_indices = num_total_indices - num_indices_result
+            if num_indices_result > 1 and num_contracted_indices != 0:
+                break
+
+        all_indices = list(CHARS[:num_indices_result+num_contracted_indices])
+        contracted_indices = list(np.random.permutation(list(all_indices)[:num_contracted_indices]))
+        result_indices = list(set(all_indices) - set(contracted_indices))
+
+        # split the result indices into two array, append the array to contracted indices
+        # since each index has to be present in at least one tensor
+        while True:
+            num_result_in_first_tensor = np.random.randint(num_indices_result)
+            if num_result_in_first_tensor != 0 and num_indices_result - num_result_in_first_tensor != 0:
+                break
+        array = [result_indices[:num_result_in_first_tensor],result_indices[num_result_in_first_tensor:]]
+
+        # choices select the common indices in the results
+        choices = []
+        for i in range(len(array)):
+            choice = np.random.randint(len(array[i])+1)
+            choices.append(np.random.permutation(array[(i+1)%2])[:choice].tolist())
+
+        dom_ix = [
+            contracted_indices + array[i] + choices[i] for i in range(len(array))
+        ]
+
+        # filling the array sizes
+        size = [len(x) for x in dom_ix]
+        sizes = [np.full(size[0], fill_number).tolist(), np.full(size[1], fill_number).tolist()]
+        out_size = np.full(num_indices_result,2).tolist()
+
+        contraction = ','.join(
+            ''.join(ix) for ix in dom_ix
+        ) + '->' + ''.join(result_indices)
+
+        randomcontract = RandomContract(is_random, contraction, num_indices_result, num_contracted_indices, fill_number)
+
+    sizes.append(out_size)
+    return sizes, randomcontract
+
+
+def permute_sizes(contraction:RandomContract, fill_number=2, num_perm=5):
+    num_indices_result = contraction.num_indices_result
+    num_contracted_indices = contraction.num_contracted_indices
+    contraction = contraction.contraction
+    inp, out = contraction.split('->')
+    size = inp.split(',')
+    sizes = [np.full(len(x), fill_number).tolist() for x in size]
+    out_size = np.full(len(out), fill_number).tolist()
+    sizes.append(out_size)
+    perm_indices = []
+    import random
+    for i in range(len(size)):
+        new_sizes = []
+        for j in range(num_perm):
+            new_str = ''.join(random.sample(size[i],len(size[i])))
+            new_sizes.append(new_str)
+        perm_indices.append(new_sizes)
+    contractions = []
+    for idx_a, idx_b in zip(perm_indices[0], perm_indices[1]):
+        contract = idx_a + ',' + idx_b + '->' + out
+        randomcontract = RandomContract(is_random=True, contraction=contract, num_indices_result=num_indices_result, num_contracted_indices=num_contracted_indices, fill_number=fill_number, is_transpose=True)
+        contractions.append(randomcontract)
+    return sizes, contractions
+
+
+def main():
+    ### change contraction [line 219] and select backends [line 228 - 229]
+
+    is_random = False
+    test_contractions = {
+        'random26': RandomContract(is_random,'mfgjcehdiolqnbpkatwv,mfgjcehdiolqnbpkauzysrxv->twuzysrxv', 9, 17, 2),
+        'random28': RandomContract(is_random,'hjlageikdcbfztounxBrqms,hjlageikdcbfvqBrspAymwz->ztounxvqBrspAymw', 16, 12, 2),
+        'fixed40': RandomContract(is_random, 'abcd,bcdf->acf', 3, 2, 40)
+    }
+
+    contraction = test_contractions['random26']
+
+    # Backend
+    backends = {
+        # 'numpy':Numpy
+        # , 'exatn': Exatn
+    }
+    if get_gpu_props_json():
+        backends.update({
+            # 'torch':TorchCuda
+            # 'cupy':Cupy
+            'cutensor': CuTensor
+        })
+    
+
+    experiment_group = "Angela_nslb_tncontract_nsight"
+
+    # Tensor properties
+    num_tensors = 2
+    dtypes = ['float', 'double', 'complex64', 'complex128']
+
+    # Test properties
+    repeats = 5
+    use_strip = True
+    if use_strip:
+        repeats += 2
+
+    # Bechmark    
+    *sizes, out_contraction = gen_sizes(contraction.is_random, contraction=contraction.contraction, fill_number=contraction.fill_number, num_indices_result=contraction.num_indices_result, num_contracted_indices=contraction.num_contracted_indices)
+    for backend in backends:
+        try:
+            b = backends[backend]
+            tncontractbench = TncontractBench()
+            results = []
+            for dtype in dtypes:
+                for _ in range(repeats):
+                    _, bench_result = tncontractbench.benchmark(b,num_tensors, contraction, *sizes, dtype=dtype)
+                    results.append(bench_result)
+                json_result = tncontractbench.print_results_json(use_strip, backend, *sizes, dtype=dtype, results=results, experiment_group=experiment_group, contraction=contraction)      
+        except Exception as e:
+            print(e, file=sys.stderr)
+            pass
+
+if __name__ == "__main__":
+    main()
+
diff --git a/scratchpad/bench/test_circuit_contr/gpu_mix_test.py b/scratchpad/bench/test_circuit_contr/gpu_mix_test.py
new file mode 100644
index 00000000..200b3da8
--- /dev/null
+++ b/scratchpad/bench/test_circuit_contr/gpu_mix_test.py
@@ -0,0 +1,43 @@
+import qtensor as qt
+import networkx as nx
+import time
+import re
+import random
+import numpy as np
+SEED = 19
+random.seed(SEED)
+np.random.seed(SEED)
+
+N = 38
+p = 4
+gamma, beta = [.2]*p, [.3]*p
+G = nx.random_regular_graph(3, N)
+
+print('Optimization step:')
+
+print('QTensor = ', end='', flush=True)
+comp = qt.DefaultQAOAComposer(G, gamma=gamma, beta=beta)
+comp.ansatz_state()
+tn = qt.optimisation.QtreeTensorNet.from_qtree_gates(comp.circuit)
+opt = qt.toolbox.get_ordering_algo('tamaki_7')
+start = time.time()
+peo, tw = opt.optimize(tn)
+end = time.time()
+print(opt.treewidth)
+print('QTensor path finding time=', end-start)
+
+print('Simulation:')
+
+print('QTensor *contraction only* GPU time = ', end='', flush=True)
+comp = qt.DefaultQAOAComposer(G, gamma=gamma, beta=beta)
+comp.ansatz_state()
+backend = qt.contraction_backends.get_mixed_backend('torch_cpu', 'torch_gpu', 12)
+backend = qt.contraction_backends.get_mixed_backend('einsum', 'cupy', 12)
+
+#backend=qt.contraction_backends.get_backend('torch_gpu')
+sim = qt.QtreeSimulator(optimizer=opt, backend=backend)
+start = time.time()
+sim.simulate_batch(comp.circuit, peo=peo)
+end = time.time()
+
+print(end - start)
diff --git a/scratchpad/bench/tncontract.py b/scratchpad/bench/tncontract.py
new file mode 100644
index 00000000..4b70b785
--- /dev/null
+++ b/scratchpad/bench/tncontract.py
@@ -0,0 +1,273 @@
+from types import DynamicClassAttribute
+from numpy.core.fromnumeric import shape, size
+import pyrofiler
+from typing import List
+from contextlib import contextmanager, nullcontext
+from dataclasses import dataclass
+from functools import lru_cache
+import itertools
+import platform
+import importlib
+import os, psutil
+import fire
+
+from base import LasyModule, BenchResult, Backend, get_gpu_props_json, Benchmark, Numpy, TorchCuda, Cupy, CuTensor
+
+np = LasyModule('numpy')
+
+import sys
+import os
+sys.path.append(os.environ['HOME']+"/.local")
+exatn = LasyModule('exatn')
+
+
+@dataclass
+class RandomContract:
+    is_random: bool
+    contraction: str
+    num_indices_result: int = 0
+    num_contracted_indices: int = 0
+    fill_number: int = 2
+    is_transpose: bool = False
+
+
+class TncontractBench(Benchmark):    
+    @staticmethod
+    def get_task_type():
+        return "tncontract"
+    
+    @classmethod
+    def get_params(cls, *sizes, contraction:RandomContract):
+        *in_size, out_size = sizes
+        unit_size = in_size[0][0]
+        ops = unit_size**(contraction.num_indices_result+contraction.num_contracted_indices)
+        param_in = np.prod(in_size[0]) + np.prod(in_size[1])
+        param_out = np.prod(out_size)
+        return ops, param_in.item(), param_out.item(), unit_size
+
+    @staticmethod
+    def benchmark(backend:Backend, num_tensors, contraction:RandomContract, *sizes, dtype='float'):
+        num_tensors, *size = backend.get_ready(num_tensors, *sizes, contraction=contraction)
+        operation = backend.get_tncontract()
+        with backend.timing(callback=lambda x: None) as gen:
+            tensors = backend.gen_tensors(num_tensors, *size[0], dtype=dtype)
+        with backend.timing(callback=lambda x: None) as prep:
+                for i in range(num_tensors):
+                    tensors[i] = backend.prepare(tensors[i])
+        with backend.timing(callback=lambda x: None) as op:
+            if contraction.contraction != '':
+                out_tensor = operation(contraction.contraction, *tensors)
+            else:
+                out_tensor = operation(*tensors)
+        with backend.timing(callback=lambda x: None) as get:
+            zr = backend.get_result(out_tensor)
+        return zr, BenchResult(gen_time=gen.result, transfer_time=prep.result+get.result, operation_time=op.result)
+
+    @classmethod
+    def print_results_json(cls, use_strip, backend, *sizes, dtype, results: List[BenchResult], experiment_group="default group", contraction:RandomContract=None):
+        prefix = {
+            'float': 2
+            ,'double': 2
+            ,'complex64': 8
+            ,'complex128': 8
+        }[dtype]
+        import json
+        GPU_PROPS = get_gpu_props_json()
+        tt1 = [r.gen_time for r in results]
+        tt2 = [r.operation_time for r in results]
+        tt3 = [r.transfer_time for r in results]
+        m1, m3 = np.mean(tt1), np.mean(tt3)
+        if use_strip:
+            m1 = cls.mean_mmax(tt1)
+            m2 = cls.mean_mmax(tt2)
+            m3 = cls.mean_mmax(tt3)
+        else:
+            m1, m2, m3 = np.mean(tt1), np.mean(tt2), np.mean(tt3)
+        s1, s2, s3 = np.std(tt1), np.std(tt2), np.std(tt3)
+        sizes = sizes[0]
+        ops, param_in, param_out, unit_size = cls.get_params(*sizes, contraction=contraction)
+        flops = prefix*ops/m2
+        task_type = cls.get_task_type()
+        res = dict(
+            task_type=task_type
+            , backend=backend
+            , size=unit_size
+            , sizes=sizes
+            , size_idx=[len(x) for x in sizes]
+            , contraction=dict(contraction=contraction.contraction
+                , num_indices_result=contraction.num_indices_result
+                , num_contracted_indices=contraction.num_contracted_indices
+                , is_transpose=contraction.is_transpose
+                )
+            , itemsize=cls.get_dtype_size(dtype)
+            , input_bytes=cls.get_dtype_size(dtype)*param_in
+            , output_bytes=cls.get_dtype_size(dtype)*param_out
+            , dtype=dtype
+            , device_props=dict(name=platform.node(), gpu=GPU_PROPS)
+            , transfer_time=m3
+            , transfer_relstd=s3
+            , gen_time=m1
+            , gen_relstd=s1
+            , operation_time=m2
+            , operation_relstd=s2
+            , ops=ops
+            , flops=flops
+            , flops_str=cls.format_flops(flops)
+            , fbratio=ops/(cls.get_dtype_size(dtype)*param_in)
+            , experiment_group=experiment_group
+        )
+        print(json.dumps(res), flush=True)
+        return res
+
+
+def gen_sizes(is_random, contraction='', fill_number=2, num_total_indices=0):
+    CHARS = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
+
+    import random
+    from itertools import accumulate
+
+    # seed = 10
+    # np.random.seed(seed)
+    # random.seed(seed)
+    
+    if not is_random and contraction != '':
+        # square tensors of form [n,n,n,n],[n,n,n,n]->[n,n,n]
+        inp, out = contraction.split('->')
+        size = inp.split(',')
+        sizes = [np.full(len(x), fill_number).tolist() for x in size]
+        out_size = np.full(len(out), fill_number).tolist()
+        randomcontract = RandomContract(is_random, contraction, 3, 2, fill_number)
+    else:
+        while True:
+            num_indices_result = np.random.randint(num_total_indices)
+            num_contracted_indices = num_total_indices - num_indices_result
+            if num_indices_result > 1 and num_contracted_indices != 0:
+                break
+
+        all_indices = list(CHARS[:num_indices_result+num_contracted_indices])
+        contracted_indices = list(np.random.permutation(list(all_indices)[:num_contracted_indices]))
+        result_indices = list(set(all_indices) - set(contracted_indices))
+
+        # split the result indices into two array, append the array to contracted indices
+        # since each index has to be present in at least one tensor
+        while True:
+            num_result_in_first_tensor = np.random.randint(num_indices_result)
+            if num_result_in_first_tensor != 0 and num_indices_result - num_result_in_first_tensor != 0:
+                break
+        array = [result_indices[:num_result_in_first_tensor],result_indices[num_result_in_first_tensor:]]
+
+        # choices select the common indices in the results
+        choices = []
+        for i in range(len(array)):
+            choice = np.random.randint(len(array[i])+1)
+            choices.append(np.random.permutation(array[(i+1)%2])[:choice].tolist())
+
+        dom_ix = [
+            contracted_indices + array[i] + choices[i] for i in range(len(array))
+        ]
+
+        # filling the array sizes
+        size = [len(x) for x in dom_ix]
+        sizes = [np.full(size[0], fill_number).tolist(), np.full(size[1], fill_number).tolist()]
+        out_size = np.full(num_indices_result,2).tolist()
+
+        contraction = ','.join(
+            ''.join(ix) for ix in dom_ix
+        ) + '->' + ''.join(result_indices)
+
+        randomcontract = RandomContract(is_random, contraction, num_indices_result, num_contracted_indices, fill_number)
+
+    sizes.append(out_size)
+    return sizes, randomcontract
+
+
+def permute_sizes(contraction:RandomContract, fill_number=2, num_perm=5):
+    num_indices_result = contraction.num_indices_result
+    num_contracted_indices = contraction.num_contracted_indices
+    contraction = contraction.contraction
+    inp, out = contraction.split('->')
+    size = inp.split(',')
+    sizes = [np.full(len(x), fill_number).tolist() for x in size]
+    out_size = np.full(len(out), fill_number).tolist()
+    sizes.append(out_size)
+    perm_indices = []
+    import random
+    for i in range(len(size)):
+        new_sizes = []
+        for j in range(num_perm):
+            new_str = ''.join(random.sample(size[i],len(size[i])))
+            new_sizes.append(new_str)
+        perm_indices.append(new_sizes)
+    contractions = []
+    for idx_a, idx_b in zip(perm_indices[0], perm_indices[1]):
+        contract = idx_a + ',' + idx_b + '->' + out
+        randomcontract = RandomContract(is_random=True, contraction=contract, num_indices_result=num_indices_result, num_contracted_indices=num_contracted_indices, fill_number=fill_number, is_transpose=True)
+        contractions.append(randomcontract)
+    return sizes, contractions
+
+
+def main():
+
+    experiment_group = "Angela_nslb_tncontract"
+
+    # Backend
+    backends = {
+        'numpy':Numpy
+        # , 'exatn': Exatn
+    }
+    if get_gpu_props_json():
+        backends.update({
+            'torch':TorchCuda
+            , 'cupy':Cupy
+            , 'cutensor': CuTensor
+        })
+    
+    # Tensor properties
+    num_tensors = 2
+    dtypes = ['float', 'double', 'complex64', 'complex128']
+
+    # Test properties
+    repeats = 5
+    use_strip = True
+    if use_strip:
+        repeats += 2
+    
+    is_random = True
+    in_contraction = 'abcd,bcdf->acf' # tensor
+    max_num_indices = 26
+    num_perm=1
+    if is_random:
+        in_sizes = np.arange(4,max_num_indices)
+    else:
+        in_sizes = [10, 16, 20, 30, 32, 40, 50, 60, 64, 70, 80, 100]  # tensor
+    
+    # Bechmark
+    for max_size in in_sizes:
+        if not is_random:
+            fill_number = max_size
+            *sizes, out_contraction = gen_sizes(is_random, contraction=in_contraction, fill_number=fill_number)
+            contractions = [out_contraction]
+        else:
+            fill_number = 2
+            *size, out_contraction = gen_sizes(is_random, num_total_indices=max_size)
+            *sizes, contractions = permute_sizes(out_contraction, num_perm=num_perm, fill_number=fill_number)
+            contractions.append(out_contraction)
+
+        for contraction in contractions:
+            for backend in backends:
+                try:
+                    b = backends[backend]
+                    tncontractbench = TncontractBench()
+                    results = []
+                    for dtype in dtypes:
+                        for _ in range(repeats):
+                            _, bench_result = tncontractbench.benchmark(b,num_tensors, contraction, *sizes, dtype=dtype)
+                            results.append(bench_result)
+                        json_result = tncontractbench.print_results_json(use_strip, backend, *sizes, dtype=dtype, results=results, experiment_group=experiment_group, contraction=contraction)      
+                except Exception as e:
+                    print(e, file=sys.stderr)
+                    pass
+
+if __name__ == "__main__":
+    fire.Fire(main)
+
diff --git a/scratchpad/bench/tncontraction/benchmark.py b/scratchpad/bench/tncontraction/benchmark.py
new file mode 100644
index 00000000..6e5aa032
--- /dev/null
+++ b/scratchpad/bench/tncontraction/benchmark.py
@@ -0,0 +1,417 @@
+from types import DynamicClassAttribute
+from numpy.core.fromnumeric import shape, size
+import pyrofiler
+from typing import List
+from contextlib import contextmanager, nullcontext
+from dataclasses import dataclass
+from functools import lru_cache
+import itertools
+import platform
+import importlib
+import os, psutil
+from cupy import cutensor as cupy_cutensor
+
+class LasyModule:
+    def __init__(self, modulename):
+        self.modulename = modulename
+        self.module = None
+    def __getattr__(self, attr):
+        if self.module is None:
+            self.module = importlib.import_module(self.modulename)
+        return self.module.__getattribute__(attr)
+
+np = LasyModule('numpy')
+torch = LasyModule('torch')
+cupy = LasyModule('cupy')
+
+import sys
+import os
+sys.path.append(os.environ['HOME']+"/.local")
+exatn = LasyModule('exatn')
+
+@dataclass
+class BenchResult:
+    gen_time: float
+    transfer_time: float
+    operation_time: float
+
+class Backend():
+    @staticmethod
+    def prepare(x):
+        return x
+
+    @staticmethod
+    def get_result(x):
+        return x
+
+    timing=pyrofiler.timing
+
+    @classmethod
+    def gen_tensors(cls, num_tensors, *size, dtype='float', contraction=''):
+        tensors = []
+        assert num_tensors == len(size), "number of tensors does not match input size array"
+        for i in range(num_tensors):
+            tensor = cls.gen_tensor(*size[i], dtype=dtype)
+            tensors.append(tensor)
+        return tensors
+
+    @classmethod
+    def gen_tensor(cls, *size, dtype='float'):
+        raise NotImplementedError
+    
+    @classmethod
+    def update_params(self, num_tensors, *size):
+        return num_tensors, *size
+    
+    @classmethod
+    def get_operation(cls, task_type):
+        if task_type == "matmul":
+            return cls.get_matmul()
+        elif task_type == "tncontract":
+            return cls.get_tncontract()
+
+    @classmethod
+    def benchmark(cls, task_type, num_tensors, *size, dtype='float', contraction=''):
+        # this line will also trigger lazy import
+        num_tensors, size = cls.update_params(num_tensors, *size)
+        operation = cls.get_operation(task_type)
+        with cls.timing(callback=lambda x: None) as gen:
+            tensors = cls.gen_tensors(num_tensors, *size, dtype=dtype, contraction=contraction)
+        with cls.timing(callback=lambda x: None) as prep:
+            for i in range(len(tensors)):
+                tensors[i] = cls.prepare(tensors[i])
+        with cls.timing(callback=lambda x: None) as op:
+            out_tensor = operation(contraction,*tensors)
+        with cls.timing(callback=lambda x: None) as get:
+            zr = cls.get_result(out_tensor)
+        return zr, BenchResult(gen_time=gen.result, transfer_time=prep.result+get.result, operation_time=op.result)
+
+
+class Numpy(Backend):
+    @staticmethod
+    def get_dtype(dtype):
+        return {
+            'float':np.float32
+            ,'double': np.float64
+            ,'complex64': np.complex64
+            ,'complex128': np.complex128
+        }[dtype]
+
+    @classmethod
+    def gen_tensor(cls, *sizes, dtype='float'):
+        dtype_t = cls.get_dtype(dtype)
+        return np.random.rand(*sizes).astype(dtype_t)
+
+    @staticmethod
+    def get_matmul():
+        return np.matmul
+    
+    @staticmethod
+    def get_tncontract():
+        return np.einsum
+
+
+
+class Torch(Backend):
+    @staticmethod
+    def get_dtype(dtype):
+        return {
+            'float':torch.float32
+            ,'double': torch.float64
+            ,'complex64': torch.complex64
+            ,'complex128': torch.complex128
+        }[dtype]
+
+    @classmethod
+    def gen_tensor(cls, *sizes, dtype='float'):
+        dtype = cls.get_dtype(dtype)
+        return torch.rand(*sizes, dtype=dtype)
+
+    @staticmethod
+    def get_matmul():
+        return torch.matmul
+    
+    @staticmethod
+    def get_tncontract():
+        return torch.einsum
+
+class TorchCuda(Torch):
+    @classmethod
+    @contextmanager
+    def timing(cls, **kwargs):
+        class Foo:
+            pass
+        res = Foo()
+        start = torch.cuda.Event(enable_timing=True)
+        end = torch.cuda.Event(enable_timing=True)
+        start.record()
+        yield res
+        end.record()
+        torch.cuda.synchronize()
+        res.result = start.elapsed_time(end)/1000
+
+    @staticmethod
+    def prepare(x):
+        return x.to('cuda')
+
+
+
+class Cupy(Backend):
+    @classmethod
+    @contextmanager
+    def timing(cls, **kwargs):
+        class Foo:
+            pass
+        res = Foo()
+        start = cupy.cuda.Event(disable_timing=False)
+        end = cupy.cuda.Event(disable_timing=False)
+        start.record()
+        yield res
+        end.record()
+
+        #I'm not sure about this line, just guessed by analogy from torch
+        # Without it raises DeviceNotReady erorr
+        end.synchronize()
+
+        res.result = cupy.cuda.get_elapsed_time(start, end)/1000
+
+    @staticmethod
+    def get_dtype(dtype):
+        return {
+            'float':cupy.float32
+            ,'double': cupy.float64
+            ,'complex64': cupy.complex64
+            ,'complex128': cupy.complex128
+        }[dtype]
+
+    @classmethod
+    def gen_tensor(cls, *sizes, dtype='float'):
+        dtype_t = cls.get_dtype(dtype)
+        return cupy.random.rand(*sizes).astype(dtype_t)
+
+    @staticmethod
+    def get_matmul():
+        with pyrofiler.timing('cblas handler'):
+            cupy.cuda.device.get_cublas_handle()
+        return cupy.matmul
+    
+    @staticmethod
+    def get_tncontract():
+        with pyrofiler.timing('cblas handler'): #??
+            cupy.cuda.device.get_cublas_handle()
+        return cupy.einsum
+
+
+
+class CuTensor(Cupy):
+    @classmethod
+    def gen_tensor(cls, *sizes, dtype='float'):
+        dtype_t = cls.get_dtype(dtype)
+        return cupy.random.rand(*sizes).astype(dtype_t)
+    
+    @classmethod
+    def update_params(self, num_tensors, *size):
+        size = size[0]
+        num_tensors += 1
+        unit_size = size[0][0]
+        size.append([unit_size for i in range(3)])  # Hardcode
+        return num_tensors, size
+
+    @classmethod
+    def tncontract(cls, contraction, *tensors):
+        [x, desc_x] = tensors[0]
+        [y, desc_y] = tensors[1]
+        [z, desc_z] = tensors[2]
+        return cupy_cutensor.contraction(1.0, x, desc_x, ('A', 'B', 'C', 'D'), 
+                        y, desc_y, ('B', 'C', 'D', 'F'), 0, 
+                        z, desc_z, ('A', 'C', 'F'))
+    
+    @classmethod
+    def get_matmul(cls):
+        with pyrofiler.timing('cblas handler'):
+            cupy.cuda.device.get_cublas_handle()
+        return cls.tncontract
+    
+    @classmethod
+    def get_tncontract(cls):
+        with pyrofiler.timing('cblas handler'):
+            cupy.cuda.device.get_cublas_handle()
+        return cls.tncontract
+    
+    @classmethod
+    def prepare(cls, x):
+        desc_x = cupy_cutensor.create_tensor_descriptor(x)
+        return [x, desc_x]
+
+
+
+# class Operation:
+#     def __init__(self, backend:Backend):
+#         self.operation = None
+#         pass
+
+# class Matmul(Operation):
+#     def __init__(self, backend:Backend):
+#         self.operation = backend.get_matmul
+
+# class Tncontract(Operation):
+#     def __init__(self, backend:Backend):
+#         self.operation = backend.get_tncontract
+
+
+
+def format_flops(flops):
+    ord = 3*int(np.log10(flops)/3)
+    suffix = {
+        3: 'k'
+        ,6: 'M'
+        ,9: 'G'
+        , 12: 'T'
+    }[ord]
+    return f'{(flops/10**ord).round(2)}{suffix}'
+
+def obj2dict(obj):
+    keys = [x for x in dir(obj) if x[0]!='_']
+    return dict((key, obj.__getattribute__(key)) for key in keys)
+
+@lru_cache
+def get_gpu_props_json():
+    try:
+        import torch
+        devprops = torch.cuda.get_device_properties(torch.cuda.current_device())
+        return obj2dict(devprops)
+    except:
+        return None
+
+def get_dtype_size(dtype):
+    dtype_t = Numpy.get_dtype(dtype)
+    x = np.ones(10, dtype=dtype_t)
+    return x.itemsize
+
+
+def mean_mmax(x: list):
+    mx, mn = max(x), min(x)
+    x.remove(mx)
+    x.remove(mn)
+    return np.mean(x)
+
+#whether to use the removal of max and min before mean
+# does not affect standard deviation or other times, only matmul
+use_strip = True
+
+def print_results_json(task_type, backend, *size, dtype, results: List[BenchResult], experiment_group="default group"):
+    import json
+    GPU_PROPS = get_gpu_props_json()
+    tt1 = [r.gen_time for r in results]
+    tt2 = [r.operation_time for r in results]
+    tt3 = [r.transfer_time for r in results]
+    if use_strip:
+        m1 = mean_mmax(tt1)
+        m2 = mean_mmax(tt2)
+        m3 = mean_mmax(tt3)
+    else:
+        m1, m2, m3 = np.mean(tt1), np.mean(tt2), np.mean(tt3)
+    s1, s2, s3 = np.std(tt1), np.std(tt2), np.std(tt3)
+    size = size[0]
+    if task_type == "matmul":
+        pass
+
+    elif task_type == "tncontract":
+
+        # 'abcd,bcdf->acf'
+        # size = [[n, n, n, n],
+        #          [n, n, n, n]]
+        # ops = n**5
+        # bytes = dtype_size 2 * n**4
+
+        ops = np.prod(size[0]) * size[1][3]
+        size = size[0][0]
+        bytes = get_dtype_size(dtype)*2*size**4
+        
+    ops = ops.item()
+    flops = ops/m2
+
+    res = dict(
+        task_type=task_type
+        , backend=backend
+        , size=size
+        , itemsize=get_dtype_size(dtype)
+        , bytes=bytes 
+        , dtype=dtype
+        , device_props=dict(name=platform.node(), gpu=GPU_PROPS)
+        , transfer_time=m3
+        , transfer_relstd=s3
+        , gen_time=m1
+        , gen_relstd=s1
+        , operation_time=m2
+        , operation_relstd=s2
+        , ops=ops
+        , flops=flops
+        , flops_str=format_flops(flops)
+        , experiment_group=experiment_group
+        , fbratio=ops/bytes
+    )
+    print(json.dumps(res), flush=True)
+    return res
+
+
+
+
+def main():
+
+    experiment_group = "Angela_pod_tncontract_restructure_test2"
+
+    task_types = [
+        # "matmul",
+        "tncontract"
+    ]
+    contraction = 'abcd,bcdf->acf' # tensor
+
+    # Backend
+    backends = {
+        'numpy':Numpy
+        # , 'exatn': Exatn
+    }
+    if get_gpu_props_json():
+        backends.update({
+            'torch':TorchCuda
+            ,  'cupy':Cupy
+            , 'cutensor': CuTensor
+        })
+    
+    # Tensor properties
+    num_tensors = 2
+    dim = 4 # tensor
+    sizes = [2, 4, 8, 10, 16, 20, 30, 32, 40, 50, 60, 64, 70, 80, 100, 120, 128, 130, 150]  # tensor
+    # dim = 2 # matrix
+    # sizes = [10, 100, 1000, 1024, 1025, 2000, 4090, 4096] # matrix  
+    dtypes = ['float', 'double', 'complex64', 'complex128']
+
+    # Test properties
+    repeats = 5
+    use_strip = True
+    if use_strip:
+        repeats += 2
+    
+    # Bechmark
+    import json
+    with open('data.json', mode='w') as f:
+        for task in task_types:
+            for backend in backends:
+                for size in sizes:
+                    input_sizes = [size for i in range(dim)] # square tensors
+                    results = []
+                    for dtype in dtypes:
+                        for _ in range(repeats):
+                            b = backends[backend]
+                            _, bench_result = b.benchmark(task, num_tensors, [input_sizes, input_sizes], dtype=dtype, contraction=contraction)
+                            results.append(bench_result)
+                        json_result = print_results_json(task, backend, [input_sizes, input_sizes], dtype=dtype, results=results, experiment_group=experiment_group)
+                          
+                        # f.write(json.dumps(json_result))
+                        # f.write(",")
+
+
+if __name__ == "__main__":
+    main()
+
diff --git a/scratchpad/cuquantum_comparison.py b/scratchpad/cuquantum_comparison.py
new file mode 100644
index 00000000..ce0143c4
--- /dev/null
+++ b/scratchpad/cuquantum_comparison.py
@@ -0,0 +1,119 @@
+import cuquantum as cq
+import qtensor as qt
+import quimb as qu
+import networkx as nx
+import time
+import re
+import random
+import numpy as np
+SEED = 10
+random.seed(SEED)
+np.random.seed(SEED)
+
+from quimb.tensor.tensor_core import concat, _gen_output_inds, _inds_to_eq
+
+N = 38
+p = 4
+gamma, beta = [.2]*p, [.3]*p
+G = nx.random_regular_graph(3, N)
+
+
+print('Optimization step:')
+
+print('Quimb = ', end='', flush=True)
+# -- Quimb
+terms = {(i, j): 1 for i,j in G.edges}
+qu_c = qu.tensor.circuit_gen.circ_qaoa(terms, p, gamma, beta)
+start = time.time()
+qu_r = qu_c.amplitude_rehearse()
+end = time.time()
+
+print(qu_r['W'])
+
+print('Quimb path finding time=', end-start)
+# -- QTensor
+
+print('QTensor = ', end='', flush=True)
+comp = qt.DefaultQAOAComposer(G, gamma=gamma, beta=beta)
+comp.ansatz_state()
+tn = qt.optimisation.QtreeTensorNet.from_qtree_gates(comp.circuit)
+opt = qt.toolbox.get_ordering_algo('tamaki_20')
+start = time.time()
+peo, tw = opt.optimize(tn)
+end = time.time()
+print(opt.treewidth)
+print('QTensor path finding time=', end-start)
+
+print('CuQuantum FLOPS = ', end='', flush=True)
+# -- CuQuantum
+info = qu_r['info']
+qu_tn = qu_r['tn']
+eq = info.eq
+tdata = [t.data for t in qu_tn.tensors]
+
+# ---- CuQuantum with hyperoptimizer
+# Turn cuquantum logging on.
+import logging
+#logging.basicConfig(level=logging.DEBUG, format='%(asctime)s %(levelname)-8s %(message)s', force=True )
+network = cq.Network(eq, *tdata)
+
+# Compute the path.
+# 1. Disable slicing for this problem.
+# 2. Use 16 hyperoptimizer samples. 
+start = time.time()
+slicer_opt = cq.SlicerOptions(disable_slicing=True)
+reconf_opt = cq.ReconfigOptions(num_iterations=0)
+samples, threads = 8, 1
+path, info = network.contract_path(optimize={'samples' : samples, 'threads' : threads,  'slicing': slicer_opt, 'reconfiguration' : reconf_opt})
+end = time.time()
+
+print(f"{info.opt_cost}, largest intermediate = {info.largest_intermediate} Elements")
+print('CuQuantum hyper path finding time = ', end-start)
+
+# ---- Vanilia Cuquantum
+#cq_r = cq.einsum_path(eq, *tdata)
+
+#el =  re.search('Cuquantum vanilia: Largest intermediate = ?(.+)', cq_r[1]).groups()[0]
+#print(el)
+
+print('Simulation:')
+
+#qu_c = qu.tensor.circuit_gen.circ_qaoa(terms, p, gamma, beta)
+print('Quimb = ', end='', flush=True)
+
+start = time.time()
+#qu_r = qu_c.amplitude(''.join(['0']*N))
+end = time.time()
+print(end-start)
+
+
+print('QTensor *contraction only* time = ', end='', flush=True)
+comp = qt.DefaultQAOAComposer(G, gamma=gamma, beta=beta)
+comp.ansatz_state()
+sim = qt.QtreeSimulator(optimizer=opt)
+start = time.time()
+sim.simulate_batch(comp.circuit, peo=peo)
+end = time.time()
+
+print(end - start)
+
+print('QTensor *contraction only* GPU time = ', end='', flush=True)
+comp = qt.DefaultQAOAComposer(G, gamma=gamma, beta=beta)
+comp.ansatz_state()
+#sim = qt.QtreeSimulator(optimizer=opt, backend=
+backend = qt.contraction_backends.get_mixed_backend('einsum', 'cupy', 12)
+#backend = qt.contraction_backends.get_mixed_backend('torch_cpu', 'torch_gpu', 12)
+sim = qt.QtreeSimulator(optimizer=opt, backend=backend)
+start = time.time()
+sim.simulate_batch(comp.circuit, peo=peo)
+end = time.time()
+
+print(end - start)
+
+#print('CuQuantum = ', end='', flush=True)
+#cq_r = cq.einsum(eq, *tdata)
+print('CuQuantum *contraction only* time = ', end='', flush=True)
+start = time.time()
+cq_r = cq.contract(eq, *tdata, optimize={'path' : path})
+end = time.time()
+print(end - start)
diff --git a/scratchpad/tensor_compression/Plot tensors.ipynb b/scratchpad/tensor_compression/Plot tensors.ipynb
new file mode 100644
index 00000000..addc39bd
--- /dev/null
+++ b/scratchpad/tensor_compression/Plot tensors.ipynb	
@@ -0,0 +1,346 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#t = np.fromfile('./tensor_dims-22_dtype-complex128.bin')\n",
+    "t = np.fromfile('./tensor_dims-14_dtype-complex128.bin')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x7ffb1f393130>]"
+      ]
+     },
+     "execution_count": 51,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(t.real)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 66,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([0., 0., 0., ..., 0., 0., 0.])"
+      ]
+     },
+     "execution_count": 66,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "_ = plt.hist(t.real, bins=100)\n",
+    "plt.yscale('log')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/plate/.local/lib/python3.8/site-packages/numpy/core/_asarray.py:83: ComplexWarning: Casting complex values to real discards the imaginary part\n",
+      "  return array(a, dtype, copy=False, order=order)\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x7ffb1e89e7c0>]"
+      ]
+     },
+     "execution_count": 53,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "tft = np.fft.fft(t)\n",
+    "plt.plot(tft[:32*128])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 103,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.7669677734375"
+      ]
+     },
+     "execution_count": 103,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "tft_cmp = tft.copy()\n",
+    "tft_cmp[np.abs(tft)<0.006] = 0\n",
+    "sum(tft_cmp==0)/tft_cmp.size"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 104,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "t_cmp = np.fft.ifft(tft_cmp).real"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 101,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x7ffb1ed27b20>"
+      ]
+     },
+     "execution_count": 101,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 9000x7200 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "t2d = t.reshape(2*64, -1)\n",
+    "fig = plt.figure(figsize=(15, 12), dpi=600)\n",
+    "mx = max(-np.min(t2d), np.max(t2d))\n",
+    "plt.imshow(t2d, cmap='seismic', vmin=-mx, vmax=mx)\n",
+    "#plt.savefig('img.svg')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 105,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x7ffb1e31a8e0>"
+      ]
+     },
+     "execution_count": 105,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAHJAAAA61CAYAAABE9FtsAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAFxGAABcRgEUlENBAAEAAElEQVR4nOzdf7Cld30f9ve5Orq6Wt29ulrtslerRVmkRV4LoQiFH5qg8RAKWIkVg20IjKGAHQ+lthtnXPrDHY/LJJ6OQ5wYzzjU6cQupMZxpoS6KS6E0jhjUypSgm2MBJZlsZYWeSWtVtery+pqdXWf/mGaTjCzR4h93ss9+3rNeDyjczjv5+7z6/vreT6TYRgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwHgWzvcGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMw7BSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDIFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGJkCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGQKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACMTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJEpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMgUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAyBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiZApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBkCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICRKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDIFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABGpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMgUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmQKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACNTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgZApIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAkSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAyBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDIFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGJkCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGQKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACMTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJEpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMgUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAyBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiZApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBkCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICRKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDIFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABGpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMgUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmQKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACNTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgZApIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAkSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAyBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDIFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGJkCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGQKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACMTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJEpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMgUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAyBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABjZ9HxvALRNJpNLklyf5GCS3Ul2JTmd5PEkx5L8wTAMZ87fFgIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADBvJsMwnO9tgNFNJpNbk7wuyV9N8oIkF53l608nuSvJ/57kfx2G4c7RNxAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIC5poAkc20ymbwpyX+R5JZv4mf+XZK/PwzDPz83WwUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMCFRgFJ5tJkMjmS5B8n+Y5z+LP/Jsk7h2H4g3P4mwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFwAFJBk7kwmk+9N8oEkyyP8/EaStw7D8L+M8NsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADMqYXzvQFwLk0mkx9J8qGMUzwyX/3dfzGZTH54pN8HAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgDk2GYTjf2wDnxGQyeVuS/zHJpBA3JHn7MAz/tJAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADADqeAJHNhMpm8NMknk1z8DL7+qSS/+tX/fzTJ40l2J7k2yV9O8uYkL3sGv3MmyW3DMPw/z2KTAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuIAoIMmON5lMVpL8bpLnzfjqHyb5T4dh+D+fwW++Jsn7klw346tfSnLzMAynnsGmAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcIFaON8bAOfA38ns4pGfSPKSZ1I8MkmGYfh4khcn+c0ZX31eknc/k98EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgwjUZhuF8bwM8a5PJ5IYkv5dkepav/d9JXjUMw+ln8fuXJfnXSV56lq9tJblpGIYvfKO/DwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwIVh4XxvAHyT/tucvXjkySRvfDbFI5NkGIavJPkbSdbP8rVpkp96Nr8PAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAhUEBSXasyWRybZLvm/G1nxyG4YFvJmcYhj/OnxWqPJs3TCaTQ99MDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPNLAUl2sh9JctFZPv/DJP/DOcp6X5L7zvL5RV/dHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPhzJsMwnO9tgG/YZDK5KMkDSa46y9d+eBiG//4cZv5Ykvee5SsPJnnuMAzb5ypzJ5lMJseTrH6dj87kz/YVAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAkjw3yeLX+e/rwzCstTemRQFJdqTJZPLqJB8/y1c2kzxnGIbHz2HmapKH8vUvFP+f/2gYhn99rjJ3kslkspnkkvO9HQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwI715DAMS+d7I8aycL43AJ6lvz7j8984l8Ujk2QYhvUkH53xtVnbBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAVIAUl2qlfN+Pw3Rsqd9buvHikXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAHWwyDMP53gb4hkwmk6uSPDjja9cMw/DACNmHknxpxteuGobh+LnO/lY3mUw2k1xyvrcDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADYsZ4chmHpfG/EWBbO9wbAs/DSGZ8/MEbxyCQZhuFokj+Z8bWXjJENAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAzjU93xsAz8ItMz7/7Mj5n0ny18/y+YuS/G8jb8O3ojNJLvna/3jxxZfk6quvGy306NH7R/vtr3XRRdfUspLk6ac3alk3fPtltay7v/BQLevqq9dqWUny5S9v1rJu2LNey7r75HIt68iRXlaSfPGLT9eybrjqVC3r3kevqGUd/gtP1bKS5OHHLq5lPefK3vFx9x9MalmHDnVryD/6aC/ruc95spZ1/0N/rtkzmuc+txaVJHn44V7W/vTaBY8s7K9l7Vt+opaVJI+evrSWdeX0T2tZpyaX17JWFnpt7yTZnPbaPEuL27WsB4/37jEHDtSikiQbxUNk+ZJe++rRU7221ZV7hlpWkmw+2WtfLU23almnTveGc1cu67WHk+TM0xfVsha3e/33MwtLtazFhd6xuL3QnVpYGHrH49bQOxanF/WujdtD77qYdPfZU9u9fXZx79aZrd4pnaR7PD693TseL+odHtnuNb3redPiZf+p4nDjxQvd9s4fHe0dkMvFofYnisMgh67ujkc/+Ejvwt+8x5w508u66qpeVpI8+GAvq3mePV28XF253BtnT5JTT/bG2i/tDaNW72e7Lunez758vHc/W12tRVXbVrsn3fHo9a3ieHRvGKR6bbxsqXuebTxRHJsotvWr+2xXdzz6qa1eP3fSHeKpmaY7ELK51Tv4m2MTQ/HQb45HJ8lTQ2+fze15Vhz/S5InNnv/kJcuzedY+8LT3XGQp9IbnFgoLl9rXoebHYvtdNcANu8xTRdNevvs6aG7z5r3s2rWUOzAtxsFxWtIdU58UuwMNm8wSfUYmdf5sye3mjfq5JLecHS+9KVe1sGDvay2i6e9RsjDjxTXGxbHUVd2dxtyzT5Tc11vcw5h9XJjm+dC897ZPKfbHn+8l7V7dy+rOV+RdMflmuvnm3NM1fGddPueW9vlfkxJe581z+vm/Wxe/66ke68+fbqXtbjYy2reO5PumsPmEE+zvbPn8m4jpPmMRfMa0uwLrq7Mb5ugOW57+snesbjr4t4NZvui4sLv9J9VaWn2K9r/hguTXl+wOb5TfQanPO8zpPfv2HxmsPmcSntdQTOveQ1p9qmbfbMk+fKXe1nN+bPmedbeZ4891suqzp+t9LKa4xJJcqr3isPq2ETz2YCtp7sDZc12QTPrst5rbevXxuZ5vXpp8TnP5qKasuZ4UvPYn9f5iqR7P2u2Cy7K/Papm/PUzf5Zs63ftr7ey9p3Ra8R8vRkfkutNOe0mu/QmNfnVJLyuyYWi4394sB+sw3Sfs9bc21B8zxr7rN2G7X5rtnmedY8PtrnWfM5hHmdRGiuFUqSxWnx37HYZ2q2CdqP1Y39tz3wwB/lqae+7vhY+ejsmt9eDfPs5hmff27k/M9ldgHJC9EDSW742v949dXX5YMfvGu00Je//Gy74tzas6dbF/SRR36jlnXX7766ljW55L+qZb3nPT9Xy0qSN7957Pq1/7+73vYrtazJz91ey/r0p19Ty0qSyy/vrVK5693/cy3r+p99Ry3rrk/0CvkmyX/zi71ivv/d3+5V0Zvs7836fuADxRnmJO99by/rwz99dy3ru//rP9fsGc2HPlSLSpL85E/2st6T/7KW9XeW31PL+qnb/20tK0n+4SdfWsv68f0frGX98+mba1lvXO61vZPks1d9Vy3rlsO9FTHveFdvRcwv/mItKknyiU/0sl5z+L5a1j/89WtrWT/+o90x1s99sTc7etPeXoWSD9/Zq576vbcVq0onuWf9ObWs6zd6/fd7lm+pZV2/3DsWTy13K/mubJ2sZT24uaeWdWBv79p4arO4aiTJymbvGnL/Zu/60Xxw7JFHellJsv+K3vF4cqN3PO5Z7S0KOLXRnT1vPrCwttbLOnasl3XNUre9c9Oreter23vD+rnzzl7Wb72/119Kkh/86V6f6dChWlTuvbeX9Qu/0MtKkne+s5f1qlf1spoPYvz47b1x9iT58Bd7Y+0vfnEtKkeP9rK+48ZefylJ3vq3e32mt7+9FlVtW333Rd3x6F9+qDceffPNtajqtfGVN3fPs49/pnee7d1bi+rus1u7b9u4/8SuWlbzxWlNB1KsBJ7kcyd645vNhyabD9A0x6OT5P6t3j6b2/OsOB6dJJ/+nd4Y4Mte2Lvun9rqXfNXTnTHQe5LbxykWSy+mbWw0VufcSrFN5ak/5Bmy55pb5+d3Orus+b9rPkSv8XN4puB2pWAioMTDz3V63funxTnYpqN7yTbS712QXO88drl3j67+0Rv7ixJbjjSmzv+y7f15o5/pfdoUb2/dM3eXlv/p36md043x1G/945uX7C5PumjH61F5cnieznf+qbuPrvvWG+fNZtXDzzQy3rhC3tZbR/7WC/rjjt6Wc2XnifJ/t29+9lnv9i7n119dS2qXiRt11av7/nQE73xguaL05pjckn3ZZnNF8WeONHLag+DNNeJ/vZv97KaawC/53t6WUl3zWHzePzIR3pZf+tN3TXL9230xl2a+6z5jOdbXzefbYKkO277W1/sHYvfcaj33pNTq713niTJE0/0sprtxgNr8/u8z8q01xe873ivL3jtanEtZXne5/RWb5ys2da/5mDvPDuzVS5QstnLaq4zb67rbc5BJt1nA37t13pZzWeOm/3pJPkn/6SX9YIX9LLe+IbetfFTd3avjc13lDXH9V95W2/+7KHHuu9jaBbXPX68l/WKV/Sy2tfGT36yl/WDtxaf8zxypBa1ne61sTmedNttvaxdS7372cn1+b2fvf71vaw9W8Ux4vJkXfM9b/P6jpW25prDn/qh3vNnJ5e670Nras5pNd+hMa/PqSTld00cLj7nWbw4Ntsgzf5Skhw+3MtqjqM2x76b7yxIklvWeufZ9lrvfta8DrfPs2vWiuuxiwfk9t7e/HtzrVCSXL9WfGawOA9539He/ay9bnPs9s4b3vCC3Hff1x0fKz4p0FeuAwrnxPUzPv/DkfNn3bKeP3I+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAO4wCkuwok8lkkuTQjK+NXZN41u8fGjkfAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAHUYBSXaa/UmWZnznwZG3YdbvXzaZTJ4z8jYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwgyggyU5z4Bl85/jI2/BMfv+ZbCcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXCAUk2WmunPH5qWEYnhxzA4ZhOJ1kY8bXZm0nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFxAFJNlp9sz4/FRlK2bnzNpOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALiDT870B8A26Ysbnj1e2YnbOt0wByclk8iNJfrgQdV0hAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYEdSQJKdZmnG51+pbEWyMePzWdvZtC/JDed7IwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC5kC+d7A+AbtDjj863KVszOmbWdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXEAUkGSnUUASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAHUcBSXaaWcfs05WtmJ1zUWUrAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2BEUkGSn2Zrx+bSyFbNznqpsBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADtCq9genCtnZnzeOqYvnvH5rO1seiTJ3YWc65JcUsgBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADYcRSQZKd5asbni5Wt2EEFJIdh+EdJ/tHYOZPJ5K4kN4ydAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsBMtnO8NgG/QxozPlytbkeye8fms7QQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOACooAkO83JGZ+vVLZids6s7QQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOACooAkO82jMz5fbWxEkstnfD5rOwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALiAKCDJTnNixueXTCaT1TE3YDKZ7EmyOONrCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADw7ykgyU5z/zP4zv6Rt+GZ/P4z2U4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuEApIsqMMw7CR5NEZX/sLI2/GoRmfPzwMw1dG3gYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB2EAUk2Ym+NOPz54+cf3jG57O2DwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAuMApLsRHfN+PzbRs6f9fuztg8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIALzPR8bwA8C59N8razfP6ikfNvmfH574ycv6M89VRy9OiYCb805o//B267rRaVJDl48LtqWX/v52pR2bevF3b8eC0qSfLzPz/r8nDuPPTGXtbzP1KLyuc/38tKkl/6pStqWXff+o5a1ttP1KLyufVremFJXv/6XtbdJ55Ty3rnO2tR2dzsZSXJ617Xy/r04zfUsprH4u+UW5dveUsx7NBP1qIOfqgWlZOHX9oLS3L7ci/r9KE317L23VmLyn2Hem3vJLn6sl7Wgxsrtazm9ePYsV5W0u0P3n/i2lrWm3undB56bLEXluTGG3tZJ9cP1LKOHKlFJXv3FsOStaVe1v3rvT713uJ9enu1dywW/6wkyXb21LKW1mtRVUvFcyxJziz1+tRrtaRkYfN0LWv/7lrUn9noDRgsL/fO6ZzoDZStrK7WspJka6vXvlrIdi0rWehFlffZ29/ey3r5y3tZN9/cy8pytxXynd/Zy3rjG3rn2ec+3zvPVtbvr2UlyWtf25uzaO6zB48Xr43Tbl/w1lt7WQe2esfjwduK82eb3cZ+cwyweXysr/eycvyqYlhyczHulpt718bTm8VrY3l+tTksd/hwL+uJJ3pZmXaXxTb32a6Nh3thzT7TVjErSbPFs1YcvNrY6GVluloMSy55vJe1f9I7z86s9sZRTxfHkpJkd3N8szgGuLRWbOsfOtTLSrJWbPPsOnZPL2zauxCfWeqtz5hu1aKSJFvFvGZTrrnPVstPbjXXiTb32cmt3j5bKp9nS6u9+bNLi+3GU+m1d1amZ2pZSXfu+ODBXbWs7Wlvny01+zBJzmz1xpOazwZce2hOx+SSaiPkFa+oRVWzTm92+4LN6dx9+3pZzXHU9tjmtQd798/mOuKXvaj3d51J9zxbnPau+zfe2LvuN/+uffvK97P05nObw0l7lnrt4foC2K1e3qW1pO4/Y/OcTpLptHdeN+dimm2Q6hxT6ks3aw4e7GU1x2yT5More1lf+Uov6447elnbe3tjLkl/fLOleW1sziFcUW7uNNeJVvvUS72BiZVpsT2cZOWK3njBgye6/dyWlaXuHELzGa21td4cQqa986w95rJrqdePWV1trn9tThwXj8WyZh9mcfNULyy99k6S/NiPVeNqmvPGm5vd8+z223tZ113Xy2rOeZYfhcyLX9zLaj5T2m4XzKvmO3iabavLL+/O+1T7ucWw5pqa9nh09dhPcbxgozkA2G03Nt+tVb1Xl5/dbmr2mZpz4s3xpJMb3fZO9V2zRXs2H6xlndnbe89b0n2n88pyry13cr3XBtmz3B0jvuZgcR3giWJWcbxxT3H+bM+R8mRd8d/xsSd640nNZ+0vK77POUlyaa/huLDRGyPemvba+tcc7K4nO7nea1/tKTaIm+8BvL45BpKk+Xbb5jhIcz3Z4rH7emFJTiyP++70hfZy728RF+ifzQ732Rmf3zyZTC4aI3gymUyT/MUZX1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgP+AApLsRJ9JcrYS6ctJ/tJI2S9NcraS6ZtJ/t1I2QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOxQCkiy4wzDsJnk/5rxtVePFP+qGZ//9le3DwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP49BSTZqf6PGZ9/70i5r5/x+cdHygUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAHU0CSnepDMz6/ZTKZfNu5DJxMJjcmeeFZvjJk9nYBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwAVJAkh1pGIY/SnLnjK/9Z+c49m/N+PxTwzAcPceZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzAEFJNnJfnnG5z8wmUyuOhdBk8nkYJL/eMbX3n8usgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJg/Ckiyk/1PSR4+y+e7kvzMOcr6e0mWzvL5Q1/dHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPhzFJBkxxqGYTPJz8/42lsnk8n3fDM5k8nkbyT5/hlfe+8wDE9+MzkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADMLwUk2enem+SBGd/5wGQyeemz+fHJZHJrkl+a8bU/zuxClgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFzAFJBkRxuG4XSSH5/xtd1JPj6ZTO74Rn57Mpm8Nsm/SrI846v/+TAMT3wjvw0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMCFRQFJdrxhGD6U5FdnfO3yJP9yMpl8cDKZHDnbFyeTyQ2TyeTXkvx6kpUZv/vBYRj+xTPeWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC5I0/O9AXCO/CdJ/lKSbzvLdyZJvj/J908mk99J8qkkX0qykWR3kucleXmSv/gMM7+Y5J3PdoMBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC4cCggyVwYhmFjMpl8Z5LfTvLcZ/A/edFX/+/Zuj/Jdw7DsPFN/AYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXiIXzvQFwrgzD8MdJXpnkj0aOujfJK4dhuH/kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOaEApLMlWEY7k3ykiT/aqSIjyV5yTAMYxepBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYI4oIMncGYbhsWEYbk/y9iQPn6OffTjJ24Zh+KvDMKyfo98EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgAqGAJHNrGIYPJLk2yY8k+cKz/Jm7v/q/f94wDP/0XG0bAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF5bp+d4AGNMwDF9J8r4k75tMJtcnuT3JLUlekOTqJLuT7EpyOsnjSY7lz4pGfjbJR4dh+MPzsd0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADMFwUkuWAMw3BPknvO93YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABw4Vk43xsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMO8UkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmQKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACNTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgZApIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAkU3P9wYA821rKzl+fLzf/yt/5Tnj/fjXuOOOWlSSZG1tPrOOHu1l3X57LytJ7r23l3Xxxb2sH/3RXtZ11/WykmR5uZe1tdXLuvXWXtbSUi8rSU6c6GW96129rN/8zbtrWb/3ezfUspLk4MFe1iWX9LLe9rYv1bL+wT94Xi0rST70oV7Wpz7Wy/qbf/OztaxDh26pZSXJz/xML+vjP/u5Wta7331TLesjH6lFJUne//5e1ute18taX+9lNfswSbcN0rx3fv7zvaybjpzphSXZzmIta8/0VC3rqStXalnZ3OxlJUl21ZKuWT5Zy3roqT21rIVs17JObSzUspJun7p5zV9d7V2rNjdqUUmSlfSujZ872rs23nSodzCe3Cpe85Ps2VyvZR0tnmfX7+1NhZ7a7J3TSbInxfvZI737WbOt/9Bj3X126FAv60Uv6mXt29fLqt6ok1x1VW8ecju99lVzbiTT7pKU5z+/GFac9Fxdu7aWlePdhuPWtHeeNa8hx3JNLeua6XotK0l++qd7/fffete/rGX9/v7vrmUd+Me/UMtKkp/d/OVa1q+++aO1rDsv/a5a1iuPdScRfu3zb61lvef1/7aWdXz1pbWs/b/xK7WsJLnz0A/Wsl55cL2WdbJ4n96zfqyWlSTrm7321YGNe2pZW3uvr2W1BxyffLLXBjmz1jv2m1Mx1b5gkiNHelnbxfZ39dBf6s7FNLvw24eL16uixeJc3fHj3ePjmoO9v+2hR3p/W3M+674T3Xmf5lj7wubpWtae9G6e20u9uZEkWdjoHY/Tae943DXtrRc6uVGeq1vt3TwXt4rrrtZ7DZ61te55trjZO8/W1orX/eLY967V1VpWkpxO79/xsstqUXnkkV7WpZf2spJko9hnarZ39u7tZTXnjZNkq7jWdvfuWlRV87hPkqXieMFnPlOLyvXTo7WsheZi/bKPfax3Tr/pTb0x2/aS9um09+/40d70al796l5W81qVdMc2x3xnxtea5zmE5j5rPgPf7DKVl+VV32vR3GfNc7rdbmy66KJeVnMtdvM5pvY53XwmrPoukuKF+OR6t73TfE9T83g8sLRey9pe7Y5Hb0x7eXd+shaV17y4d0PbSHefnTjRO6+b95gb1nodi8XiXG6SPFZ8drtp18W9A6T9vo7nPreX1Xz/1PZSb5ysPbTZbBf86Z/2sprzZ811lEn3HrNndT7fa7F/d28dVJI8OqfXkHafqak6xlN8QdmJO95Ry2q/t7T5Xrl33Ha0lnX/cu9dou2xzU98opf1Hau99ymePtx7n2KzTZB032F38829rJVp7x9yebm7/rV6Ld7qTURuL/fWGz5WXAPYtlKcO64uSS1fG6vaDayW4t/VXrfZTJvXuf4nnuhlJakupjxz2ytrWVvFYf177u2eZ9cv3V/LOr3Ue755vfjqtfJr3nLTUu99DIvFxSfN91IenxbfT5bk+kPjjhEvdrtJ3zLmd2QVAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4FuEApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBkCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICRKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDIFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABGpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMgUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmQKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACNTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgZApIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAkSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAyBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDIFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGJkCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGQKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACMTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJEpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMgUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAyBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiZApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBk0/O9AcB8u/TS5NZbx/v9w4fH++2vNS1fMZt/29ZWL+sNb+hlHT/ey0qSG2/sZW1s9LJe//pe1qOP9rKS5ODBXtbRo72stbVe1mOP9bKS5NChXtYdd/SylpdvqGWNeV/+eo4c6WU1r40/8RPPq2UtL9eikiTvf38v68OfWKll/cAP3FLLOnasFpUkede7elkfvvemWtZb3lKLykc/2stKkh/6oV7W5mYv6/bbe1ntNsjSUi9rfb2X1WxbncliLyzdQc+TW7372aWX1qJyOrt6YemOu5zc2lPLau6zUxsLtayV5e1aVpLu4FXxerWwfrKWtbzaO+6TJMX+WbPfmfQaBXum3fPs9OaBWtZS8ZQ+vdQ79tuTrg9u9P62Znv4xIleVnvMpTmHsLh5qpZ16FCvPZwTe3tZSQ4Vj5GFEw/Xsq5dK/5hx4sDEym3CzZ6/467tnrndHXyLMlq8xBZ612IDzYbBlvda2NzbLO5aOJFxfUZ+b7vK4YlP9Y8RJ6+ohZ124trUcnR7gTrW24uhi33DpCDxXUMeXHzAEleeeRML+x4c2yi2AbZ272fVVs8m6u1qD3LxWMxq8Ws5JLi3OBiev+Oi9Pm2HdxgCfJma3enEVzn60U/xlPbXbnV5tjZQspzzOVNI/79pr25uKTK64ozlNv9f4hm+t6k2TXtHdt3J4W99lSL2th83QtK0l1TnxXcb5/uzj/vmepvM/We9fG7eZ8fzGr20JNstVLrHZzmw25ciOkmXbVVb2s/Zf2xlxOpTiXm2Rl2rsWX3llr13QbFudXO/2Bfes9toFW8U+U7Nttbzc3WeLW73z7Lrrim398hjxvLr55l7Wwr331LJ2NR+2T7Kd3vXqRS+qRVXnfU4Vn69oay6raTb1m8/lJt01qaurvax51txnzWchq/fO8tzISvGBjuZzdfv21aK6+6z6zFSSpW4/pqU5V9d+DmFuhwCLN5j2adZsX1XXzxcbV3vK987Nzfm8hpwpPlfXXL+TJE8W3yt3Te6vZW3vu6aWVb6d5aKLelm7d/eyum394jh7un3qZr+zabH8nPjqavEYKTZ4lpaa443lOfFiXPO9FqvFtSfNsaSk+56mrPWei2le83ctda+Nr31t8dr4UK/z2ex3ttcsV9+TWmyE/P7v16Lyspd0z7PDh3vn2YGtXv/s5Gavf9Ze/3pivbjuarP3ApmF4qDLvn3d/ll1XXuxfbVQvMlsT7tzI80x6cU5XVzQXL/T7ldMi8/gNN/j1byfPf109x2pzfeeNMfap8X1r5dfXotKkpy6tNeWWyr2mQ6s9dr61bHGJNlYrUXdd6x37F+72huTW1orv2t27KI7Tz017u9/iyqfeQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXHgUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAyBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiZApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBkCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICRKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDIFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABGpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMgUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmQKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACNTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgZApIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAkSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAyBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDIFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGJkCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGQKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACMTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJEpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMgUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEY2Pd8bAMy3EyeSv/t3x/v9n/iJ8X77a/36r/eykuSvHb6nlvW+f3N9LevGG2tRWV/vZSXJ2lov65Of7GUtL/ey2vvshtUHa1nTwwdqWUtLtag89lgvK0n27etlffGLvax3v7uXdfx4LytJ/tqhu2tZHz92Qy3rFa+oReVP/qSXlSTXHzpTyzpxYrGW9a531aKytdXLSpKbjvT22d339vbZwYO1qHobZNfWqVrWJz+zUst6zSt6x+JXvtI7FpPk2un9taz7c00ta1ocGWxmJd1rcfMasrnZy7rhyHYvLMmZrYVa1upqLSqPPNLL2r+vt8+a+ytJFosXkT2bvbGC5sG4sNW7TyepDk40r42Ly71jsX2eNe/Vl1zSy9qV07Ws7aVdtaykO267stS7hpxZ7rX1223Uz3++l3X90TtrWZu3vaaWtet3f7eWlSR/cnnvb7tm94la1pnV59SyFsuDLieK5/U1Ux3Pc2HpUG+euvm3LRSPj9PptkFe9api2Cd7N8/F5gTrt397LyvJocuKYY+u1qIWN3vj7NUJiyQ3FecQ0muCVPtn1cVJ82xjo5fV7OSmu64mG8V2Y7OjW158sr+5MG+zPOHfUm7rV2dz53RicKV53CeZ28dKivez5nzWgdVa1J8p3jybR+KZYp96qXyKbRevxAvrJ2tZZ5b31LKqYwXpzjM15443t3rH4q72ws1iP2Zhs9inLjq11R3bXEmvTbyxUWwR39mbF8ytt/aykiwWz+uNjd5a2yz3/q6Vpe71o3k/u3ROu+/NtY1Jcnqztz5p17S4fm3aa8stprzWttiPedlLin/bvcXxxvK8T7PNc/hwLSrZbI7Zdsc2t6a9fXb94eY1pNeHWSlfG6tzWs25mBO9v+uJobeeLElWpr126lbxOrxyrPcsdY4c6WUlWUyvAX58szi2uVFcn1GeEz+z1OvnLhX7Z83x6O3V3nh098mR/hr6luZS2z2r3fbOwYPF/vtm7zw7nd55tmurO07WbIM0lxZUx5KWuufZgb3F56aKc7mL0+Yzx913P+zdWwxb6o0nNZ9J3727l5Ukl17ay9p1rPfuxuagXHtK/NixXtZNN/auVyfXe/ezxx/vtvar80wnig8iHCzO5ZY7TNVx/Y057QyWNd9bmvXius3i4bFdHgm54opi2NO9Ruqh1VpU9/mbJNcfLPbh13vjti9sTlOXG47XHyqGFV8kUB0DPL7ey0qy1Hw3zt7iwd889qfdcZDqOvP2fH9Jey32ZnGMeDHzuWai+czD+nr3nG6O61fbVs3n6opj+kny0GO99wPvL85pbRXnK5o1JZLu/aw5f7a4sV7L2tVe1L7U61Nfu9xsF5Q71U1j39DmdXHLDO01RAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXHAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAyBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiZApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBkCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICRKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDIFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABGpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMgUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmQKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACNTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgZApIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAkSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAyBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDIFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGJkCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGQKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACMTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJEpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMgUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEY2GYbhfG8DMAcmk8ldSW742v/+vOfdkH/2z+4aLfdlL9ke7be/1uc+3625e+RIL+vYsV7WtWuna1n3HNtVy0qSQ4d6WdV9dvBMLeu+Y4u1rKS7zx55pJe1f3fvPDud7nm2a+tULevTX1ipZb3s23t/1+lp7+9Kuvus+bft2jxZy8ryci8rSdbXa1Enp8+pZe1Jb5+dWd5Ty0qS6bSXtbnZy2peP7aXu9fGhfXe8fjQU73jcf8VvXbjyY1uu3F1tZdVvAxXtW9n83pt3NrqZa0s98Zc2h56pDfGc8UVtajq8dG8TyfpXkSOHq1FbR+6tpa1kPI53Twgmxf94t91eqvb3mlq7rLFrd44WfW4T3Jyq9eP2bPau4ac3uzdp5vHYtJtN66s31/LOrN2TS1rcaM4Jpf0OzIl29PePWZho9tubI7xNC/7zfvZ9lJ33qf571i9Dk97++zUVnefraR4XjcnxdfWelnt+0vzRCu3iWuWlrp5x4/3svbu7WXNsea6ieq4XLPTVD7Pmn3PXdPe/FnVxkY17tS0Owff0mw31u9nTXPa3jkz7bb1F6fFeYTiNWRuxwoyp/eXpNsGad7P5nSsMUn337F5os1x/705Blidpy63Uavtq+K1sdpfSrE9nH77qqU6f9buvzfHXIr99zOxHuRcaF7257lL3ewLnlzv3WOa61yqk5Dp3s+q86tb8/uMVnONRnVsYo7bINUbWnsB27ya14bBHI9dNa+Nzen3A6u9fu48zyFUxybWH6xlnV49UMtK5ncJT/NyNa+3l2R+++/N46P9jNZ2etfGuV3Xu9SdX22OATbXmT/0eK8Nsm9fLSpJ+bmH5sFffEFCs50/z5qHR3tY4sSJXtaBtd69unmfbk+Jz+vQ1bz+Xcn8Pjc115N189ppairP1c3roMuZpd5a2+p65aS7Lm9O5wXbh/28vnewOZ50Zqv77vTFzWKfek7XbdZPtGZe84WKxXGQ+nu4i+8+3l7tPcNXfa9tec1y+50dfHPmed6n+rfN6yRTMrd96rld15vuedZs7lT/Hed4QLr6nMrS/L7Teezr/gtuvjl3f+ELX++ju4dheMGo4edRt0cPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAFSQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgZApIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAkSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAyBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDIFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGJkCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGQKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACMTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJEpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMgUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAyBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiZApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBkCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICRKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDIFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABGpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMgUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmQKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACNTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4P9l735DLLvv84A/O765ubq9noymI+2wni4TZS22siwcoyRrI4xalKAmamJMaEMpJYTglr5K/9CYUoIJJfhFKaF1S0khuMVtQ164bipaI9TWuLaxG9VdHGmzkTdiUbbbkTUZ3czejK9GV7N9kb6y/bLnkbn+fF5KMM+ee875nd+/c74AAAAAAAMbvdX/AGC93b2bvPnmcH//dNWrg7uzU4tKkowXR7Ws5XK7lvXSwbSWNSo/5V57rZfVPLbj5biW1b7Pmu65pxi2XNai7rzRu6eTZHXPZi3rf/7PWlR+5PWrtayrow/UspLk/a/991rWJ//3T9SyPnzlVi3rc/NHallJ8oGtg1rWZ2/cX8v60GOrWtbNm7WoJMmDy6/Wsm6Oetfj/n6vzT/s3dJJkou7s1rWm4e1qGQ+r0VNZr32I0k2lie1rNFoPcdM49FZLyxJVr12f7rq9b+zWBSzelFJcrJ1oZZ17721qOq1P27Ogyy7ky4ny94c4HQyqWUVh+9Jer9hkty505tPuu++WlSWq95xFR9lSZKD3lAwD+705r4z6/W9U2w/kiTzblzLdNJ7djbXmJJkM8e9sK2tWlRzXHEy6a1nJcm02JdrXo/jFMdn3Q5PMuvNJ3XXIXth7T7IOKe9sEmvL5dRr1+w2bynk+TzV3tZzRut2Zdr9lGT7nxScY64es6av2HSPbbD4iLCut7TSUaz4r6J5rO62Jc7m3T3nkwPXqplHe88UMvanBX7BeX7bDO9tbrT4lpds99YnQBMqm1I9z4rPs/K47PmgPCsOH5vqq6Jl6+Pk+L6yLQ6V9Brh8/Ka3Ubq+LvWBznNn/H6m+YVMeei1Wvv7PZnAZpr9UVn52n6bXDzeH7WbPvne76yNG8115t3+ptgD293N3T3lyru33Qu88uzHrrxqeTbt+7+/zsnbPxqjcvUVccW2xtFdv95jp1eQ1hXOxfjZsXSPN3LO6pSbrvIazSu8/GxXN2ttXdL9R8nlX3R6+Ke9fa47NiXnWerDl3NSruqUmyMe/tI57Nim1Icf19vLdXy0pS7V8tl73n2bTYL2g3jc0u8bS4lnu86F0f7S1e66o537ixxvujN4rz0eNmVi0p9Xdlx82x57J3zs6/vThPtip/NKzZYDUfMsXjar+H0JxOap6y5u/Y7MclydveVpwjvnGjFrXaf7CWVd0jmvLc1bL4znHxOd3eL1Qdex7Oe1nFD1MeLbrzZKNRbz23+f5Z911Z/n9o9kGq38VJqn3i5tz3waI3931xp9tvbO4z37j1ci3rbO9iLav9He61HTQV9+W1T9q1ee87b839Qhfmt2tZ061aVJLklTeKa56v9qKa3wHMojuv//nnetf+B95T3A9S1OwTvHijO35/cK851957dp4Ux7ir8mhw0hwzLZv3dHGfeft7HcU2pDknV51zaW90KfaJy0e2vtqLg98lur0SAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgO9CCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICBKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYApIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGAKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIEpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBgCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICBjd7qfwCw3sbj5Ad+YLi/f3g43N/+ZrNZLytJjrNdy9rbq0Vltepltc/ZeHlcyzp5+2Yta1TsLTSz1tnxqNd+nB/1rvsk1Ubkqad6v2NmD9eiLteS/p/Dd9ainviztahktFWLutI+aTd6jfF73lOLShaLWtTOzv21rCTJcqcWNVnWojK99WIta2fvwVpWkur1uLVVfJ6l1wFv9xtPM+2FFcdM1d+xOYBPclZsizdWvXs6u7u9rPI5a16Py+LzbJmNWtbm7KyWdTYptotJlvNe1rQ4oXTnTi0q993Xy0q699lGetf+aNS7p6ej01pWkqx2xr2w4jPmrNgfbl6LSXVYke3FrV5Yc8Gi7GzWm9dvXo/NNr++htBc1EqxHW42IOWT1jy0Zv/7tHh9jEfd59nJsnds1f7Vstd+nDTnrZJML13qha3pQnXznk6S8WRSyzrd7821N/dntDefHBX3CxUvj+ot3X6eLea9rO1Z8aQV+8Mbq+48SHZ666vVJqR4ztpzxM3h2TjF63FRHFS37e/XojaL8yBnxXWftrNRr5+6sTypZTXHTKtVcV2w2CVIkml656y5Z6LaIW5rdsCLk3IbxXPWbBeTZGNrq5bV3OZyvOi1jZNJe86ld5+Ni/2d7jmrRf0/vWPb3irOTUyKc7Zlp8X+1YXJUS2r2d9pruUmybj4kNmsTrr02vzj4tpZ0u02Npv901FvLDgedW+041Xv2DYnvXmyk52LtaxpeT66OTcxnRT7IMUxDP+fNJ+d7U5IMW9aHMhU24/y/tdmJ6S6fa35vk9zo1y6+19n1Xfd5rWojd3uREjzvYeMesfWXBdsOll21yCnq96+q+Y7Ws3fcVLeM7GxKO6Vaz48m33U6nsB5bzm/tfqnMv69lGb7dVoPS/FJOW1mKZJ7/qofj8jydvfXgy7pzc+G6+K+6CK88NJMl18vZbV/TZIcY64vPekuv+12N955bXe79j+HkP1eizuWV6NenNJzXemku4+4uZYsLlH9KzcB2nuWW6un20V+9/191eb8yBFazu/kyTzeS3qZOtCLWvanCsoHleS3PmDXlb1Ub27VYtq7t9Jkjff7GW97W29rOr7guX3xL/3e4thX/pSL+vxx2tRGwe3a1mXLnXb4dxaz6Iq0+Y3MNf4Hc/mOdsurr+fLHtzBUl3faTZ32kveVYVD26+6M03zma99qr+zbCB5wvu5tygf/871Ro/4QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC+MyggCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGAKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIEpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBgCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICBKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYApIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADCw0Vv9DwDW28lJ8oUvDPf3P/3p4f72N3v88V5WkkwmvazFYj2zrlzpZSXJZLJZy3rjjVpUvvzlXtZP/3QvK0lu3OhlzWa9rOWyl/Xww73rPkkWxWNr/o5fOdyuZe3s1KKSJIvJg7Ws+WEtKi9tXeyF3epFJcnepYdqWQ/ktJZ1+/CBWtaFrbNaVpKc5UIta7+WlFy73ms/Hhr1rsUkeeWNXrt/fnRcy3r/k71+wdNP16KSJJ/4RC/rb/yNXlaz//1bn+52QprXyE++pzfQ/dDP99qPT31sXstKkn//3+6vZf3lv3hSy/q1T05rWR9+6qCWdX3e638kyUOTl2pZz9zo9Rt/7OHbtayvXO2es/fuvFzL+uqt3vjskb2jWtbprNfmJ8n26uu1rGurYl9/2Wvzj5a9Nj9JLqZ3n335//Tusx+Z9K7Fm/Ne/yNJHrzUmy/4Cz+xUcv66EdrUXnhhV5Wkjz55LiW9Qu/UIvKL/xCb/zeXBdMkt/4jV7W9eu9++xnf7YWlSef7B1X0h2/7+/37ulm1uXLtagkyedu9MYWt4rrI+95Ty9ra6uXlSSrVa/db66/X77cO64Lu911n9/4F72sO3d6We9+dy+r/Tx77rle1s5O7xmzu9vLujDpzbkkyRev9+Zdnn22FpWnnmpeH7WoJMkf/EEv64UXer9jc9x5Ybe4eS3JP/l4ry1u7oX64Ad7WdNVb60/ST71bK9/9fDDvbnUB/d6c8SZ9F7Nefmg134kyXzey2uuxZxNetfizZu1qCTJzk6vHd4svvRwNupdi81+XJI8+mjv2JrvqUwXvXWfr9zorvu84x29++y++2pR2UyvD/LSre57CM1xzOc/37s+/ny+VMtaPvrna1lJsjnq9eW+crM3V/DeybVaVva6e08y6vWJv/hc79n5/p0Xa1mLWW9PTdJds2iuITy40xtXnEy699ms2Jd78UbvPntwt9cHOS6unSXdd0qP5r0+yHbxYpzPa1FJkq2t3rV/57VaVKajVS2rOeeSJPPi3s1bxefZI5d777r9+ie6842PP95rix97rBaV208/X8t65vC9tayk+zs298r95j/qtY1f/u3uPoZ3vrOX9bGP9Y7t7/ydWlRef72X1fymRZLcKs7LNddy9/d7Wate85EkuVE8Z5cu1aKyql773f5Oc1/e+Xt7WeNVcf19Wb7Rigto0+Leguaguj1PNi3OkzVfjFmm1+a351w++9le1l+bfKYXVvxgR3F6J0nyYvHdywef/6+1rNPHemue3f5OcnjY6/NcbH6E56//Ui1qY9Hdt9lcX83Vq7Wo0ZUP1LJOV905l8PiNw4vLIthxU017XmQSXHNonlszeaj7ZVv9PrE55e97zSdFr9V3WyrkuTZZ3v3WfN7eb/2dO9d6ud7S0xJkn/6T/9+LesP//BXalm/9LHetfjoo7WoJMlP/dS/qmXdfeUv1LI2d3vjzqtXu3PEV67851rW1/Ljtax//rfu1rL+8c/2HmiP/0z323yfu/NTtawv/rP/VctqrtU1v9ebJL/1s5+qZX1l/0O1rOY5a34PKkn+5mNfrWX92+cfqWU1+8O//snus/Pnnv0rtaybf/ff1rLeu9d7r+5z17vv1X3g5r8e9O+f+6P5oH//O1V3thMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgu5ACkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGAKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIEpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBgCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICBKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYApIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADO3f37t23+t8ArIFz5869kOShb/7vFy8+lH/5L18YLHe5HOxPf4vDw15WkvzcXz2tZT3z2XEt67HHalE5OOhlJckDO8e1rM9d3axl7e7WorJY9LKS5L27t2tZn7txoZb1gYePalmvvLFdy0qS86+/XMs6ml2sZU0mtajqszNJZrNe1muv9bLO39Nr86sXSJKsVrWok0xrWdPJWS3rLBu1rCTZmPfa/eNRr93fXPWOK1tbvaykep+9eLPX1//852tRefzxXlbS7RP/x//Yy3rf+3pZxcs+SfecfeYzvaw33uhl/eiP9rKS7rH9h//Qy3rqqV5Ws+/dzEq645jmfNL+fi+rPefSHMY0nzHTnPTCyg/P00lvvrF5T2+OiudsNOplpdvXb/atNie9tZG2r17vnbPmmtbOTi+r+exMkt/93V7Wu9/dy2q2w9uz7j39yx/r3Wcf+UgtKtev97Ie2eqtwyTJVw57azHvPXymllWdvLp1q5eV5OXRA7Ws5jNmPu9lXZgV15iS7gCtOfhsHld5re63nu6tM/3kU+u5fraxLI4Fk1y72VvzfGj+xVpWtQNengdp9kHe8Y5aVF5/vZdVngapurB4sZZ1uv9gLau9VtdcP/vQ3v+oZZ08/MO1rOmyuGciyemstx9k/OnfrGWd/fRfqmVtLIp9/XJDfDbp9Xea7VV1v+H3dO/p6oJuccLxlW/01rPazt9bnEtd085cfd/mrd5c6tlebwzTfJ4drbr39PZWbx7kpZu96/GBreIzpr1hqNkxaO/XLzlZdtvG6Wo925Dtg2u1rNNL3/J67qDGy945O07vnG0erOf8TtLtyjWb4fFqffd4nY16+xia7xY138Gp9/WL60yno96cyzhrPO4szk0cr3rnbDO95/SXf7c7PvuRd/baq099tjf3/aFZb2/S6eM/VstKkvFh73sMr7yt9z2G81/4VC3rxYc/VMtKkgd3e23IF5/vtSHvn321lnW8/0gtq9nmJ+Xx2bw3j3q625tHrfatkhwve+OKzVlvHrVpnccVzf7wUXp9q+1Jdw/g2iqOz07Ta6uSZLzojSvOtnrX/quv1qJyzz29rKS7X//i5Ou1rOPJ/bWs9pRL8ztN1b0nd3rzO/feW4tKUu6nNj/IsLfXy2p/uPTmzVrU2ZX317Kaa0zr/D3Fjazn+Ky+j6H4PDte9I6t2S+Yjsrffmi/+FDS3Iu9sVrf73U0x57PPVeLqo6XkuRXf7WX9cyv9vZdPXOrt+/qxx7v3meferp37X/o8NdqWf989eFa1t/c6b3HlHTfZcrbzvWy3uzVM9r4h79cy6p/i7jY8J9+5JdqWU3tWjEXli/1wpr78opz3+3+TvO2bs7rn3+zt3+n3jZ+/OO9rJ//+V7WjRu9rPY7MQN/FOpdf+7P5dqL3/adgGt3795916Dhb6HuzBkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAdyEFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYApIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGAKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIEpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBgCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICBKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGNnqr/wHAevue70n29ob7+zdvDve3v9ljj/WykuTajXEta3e3FpXDw17Wzk4vK0luLzZrWc1zNpv1soZsL76ds8mFWtajW7WonE22a1n31ZL+xFku1rK+9JlaVLa2elmTSS8rSS5f7mX93u/1sv54r9fmt8/ZbNbrgxwc1KLy2msbtaw/82dqUUmSSbHdz6oXdXvZO64LOatlJcnxsnefNduQ5vOs3W987bVe1vve18taLHpZzT5BksznvawPPXVay/rK8732Y3v19VpWktx+8/5a1od/vtvu1xRv6uPiHEjSba9u3OhlNed3mu1i0j22q1d7WVeuTGtZzfFSkuwU+43Nc/aBh5e1rKMUx2ZJHrzUe5598Uu9MfX7LxefZ6PuOXtk/7iW9a+v9p7VV67Uoupt44+886iW9eXf6V2PP/iDtajqemeSfPCDvaxl7xGTS5d6WWeT3jpMksyKv2Mu9xb8T9O79kf7D9SykuSTH+tlNZ8xzb0FF1bzXliSX3+2d1//zM/0nmfNfsED+925pI9+tJf1k0/2Fn6ev95rGx+ZP1fLSpLPX/9ALeuhh2tROdvt7anZuH6tlpUko+LO6ddf72U193g11wWTbv/75dWDtaziNGpdsy93svXDtaxpTmpZ1cYq3fts/OSTtayNVW8tt9kQP/Nsb8426c5NNNeYzt/X6+s/82x3PvqJJ3pZy1F3DrDlv/yXbt5fefh6L6x5UxcXqp8/7I1hkuSRSe/hubEs9kGaGw6Le0GS5HTVe35Wx0yr3vxOc+9rkmzOen3io3nv+thObw1ystXtgzTv6+p9tuj19cej8t7G4thzszmmLi78FJvhJN29lNX77OatWtTZpd78X5JsNN9VaZ604sV4UN6zfGGn1zY225DxvPdy//GsOz7bnBTnUsvtfss995QDi2PP5vpZc6K9vZfy4l5v4vYPi9Nk5/f3a1nlZZ/1vc+Kiwjdd/u7HxKYF9uQzeKLwK+9WotKintEk+T3f7+X9f73FN/BWfbe0Wo7OOgd20N7vU5qs+t9OupeH7d6UxPdPanFPuq43N85KX5jZVqc3zlf/JDXybK796S5Nyk7xU5qca5gOumuITSvkWlx0NTcL1R/ub+5iNDUnEitDnKTFOcmNg5u17JWW7054vYp21j03hPP88/Xos6uvL+WNR0V9/UmybzXNm4W2/3TveI7pdWOXLofGS/aaH4wr/3h0mJfbrzstcM/8AO9deovfKEWlaR8Wxev/f3i3ET7GxrPFV+XffIffLiW9cF5LSqZ9d5jSrrDwe2Pf7yWdVwcdm5+5CO1rKNF957evvpfa1mfKX5bv/m9jqef7mUlya8se/fZM0/+41pW892zT3+6l5UkP3frl2tZ/2b2S7Wsv/1wb66g+pJ4ktNf/MVa1vNP/L1a1nuvFzdCPf54LytJPjbwB6iaBa2+g3RX7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC+CykgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGAKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIEpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBgCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICBKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYApIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABnbu7t27b/W/AVgD586deyHJQ9/837//+x/Kv/t3LwyW+0M/NNif/ha3bvWykuRiXq5l3R5drGXt7taislj0spJkNutlvfpqL+vee3tZq1UvK0mmOallvXw4rWVd3DquZVUv/KR6Y3/u6mYt6+GHa1FZLntZSXJhtZ7Pswujr9eyTmb317KSZLrqtSHXbvXus4cundayXj4Y17KSZG+vl3Vw0Mtq3mev3O3eZ+fP9Y7t5WXv2HZ2alG5c6eXlST33NPLms97Wc1+40uHvTY/SR7YP6tlvfLqRi2rOT67ebOXlXSHFpNJL2t71uuDHC16fZD2ULA5X9C89vf3e1nN6z7pnrP2fFLLdNHrMybJ7VWv37i1VYvKdNRrh09W3bFgc3zWnNdvztm2J8puL7drWc22sTkWbD/PmvdZs21sqt7TSW7Pe2sx6zp3df6e4hpTktNJb75gvOwdW/O42pr7JprPmM1Jr9/YHsRU28ZZsQ1pdgxGo15Wkv/0md58448vfrOWdfrBv1TLGj//lVpWku6C/yc+0ct67LFeVtkrf/pbtjkO5vy9vWfMaXpzE+NRbx0mSU5XvbaxemzFfVBns24fdSPF37HZSS0O4E9G3XM2XR5V82qK/cbTUa/vXd9rW5xrPxv1nmfNtuosvWdZkmwc3O6FFQfwzbWY6aTb38lnP9vLevTRXlbT9evdvObEfnFzwbq2w0mqD9CXbvV+xwf21nPcmXTn9auboZovu7UXWJsbYJvzts2s8jmrzic17+nifpDTre57COu6L29zVZyXaG/QaO5Parf762pdz1lzI9QabzQ/nfX2ADbXK47m3bmr7dF6vsv0wPJaLetkv7fe2dZ8v7k5PjuaXKhlJev7LtP2qrdvs9nXH6e4dy3pdvaLY+p1fq+uOZ20PSnu/S72h9trdU3VufZi+9Fcr0i6U5vNqYmNRa9vVd/nUtzHUH12FtvG40W3bTw87GU1vzOxzs+Y5jRZ9Z5uKr+/epxeW7w5KvYbm2t16/rRgmRt+98by+77q9XrsfjwPNvtzl01Va+RZhvSnJxot43FdwPO9h+oZTXHZ23N96mb3at13uL1pS/1sn58v7d+du1byyIMpvnNsKS73P/A6sVe2KVLvay25klrvld3+XItqvku5MZh9ztvzUni5h7R5rcbv+/7ellJcv73PtcLu3Kll9Uc47YLIjTfL2p+Z6L57ln7Y8TveEcv693v7mVdvdrLKt9nL18Z9vsxTzzxrnzta992PHHt7t277xo0/C20vqtOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN8hFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGAKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIEpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBgCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICBKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYApIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGNjorf4HAOvt7Cz54z8e7u/fujXc3/5ms1kvK0mOcrEXtuxFNX3jG9281aqX9frrvazx4qiWdbDYrmUlycXRvJY1Gk1rWVksalGnk81aVpKMizfa1lYtKqNir3w+72UlyYX9nVrWVi0pSXodg+b1kSRnxfv60qVaVNXu7lv9LxjOZNJM613895b7+ln2fsjnn6tF5cefOK1lHb4+rmUlyfl7e8d29Wbv2C5e6vUb/9Sf6vYbmwO03//93jnb369F1edBLuye1bJeeXWjlnWy6l0fb7xRi8p4/vVeWJJs3V+LavZRi8P3TEe9Z1nSHb83ewVHy978zrTcEL/tTi9rOum1+afFdrg7Xkp2elMu1XN2NO/dZ1tbxTnbJH/w272sH/zBXtaNG72sh/aOe2FJDg9745jmfNL1672shy53G8fm/PeFvd6xvb05R3xwWAxLFlu9+2x7Ma9lLWbF45p1+/qLRa9/9cDo5VpWtSFuDgZT7vMU90w0F9COF725pCS5cqUYdnNNF+vWdREySR59tJe1t9fLKg+q/+hmL+v8H/c2OI6biwiH3X7ja3d7c8TnXy9uSi32QTZW3X7jK6/1+o3nmxuJi5Ny7Xn9k0lv7+b01ou1rGq/oNgfbl8fOTioRW0U77OTFNd9Vt25zWr/qjjOXY2K+8zbm22bCz/F66O5Z2LaHC8lOUtvvmAjvbW65qU/GnXnXDZHzfcQijsZiidtOemNzZLufpCXb/Wux4u7vXb4qDinnyTbxXnb6hhm2Xuv7rR65SfjUe8Zc1ZcP9so9nea75Mm3a5+89jOin39Zfld6smkN/Zs9hvXtT+cpLoOWf0d1/Vl2SRno97zc7zozfE0n511xWukuXyWp3ubKaeXL9eyklTnAKv9xuKa5xtvq0X9ieJ8wRvFtdz80bwWNdopHte8u5+s+hGNYgd8O8Xf8bA7sJhsXahlnRa/izMu9vU3iv24JNVB9XFxTL056/Xj2mPBra3e+Kw5NzEtTiZN2l8zLT4/m/PRzZ2U7W8ZNZfEu+tnxfWK4jueSTKf99rG6Vbx2bnq9Xc2y+8cb65OemHF/s4rd3rn7Px95caxuC+vORZcVccVZcUH6OlObyy4qvZRu8+z5j7RO8VvH99X/BTJxhp3HKtjz/bHSNbU5rz3zvGtRe+b8A9d6r4bMJkUn6Cf/GQt6tJHf6WW1f722nJZXLO40fsYyen+g7Ws8WefqWUlSW7e7GUVxxXHl3+4lrV5cLuWVT1fSXX9ffz447Wsvb3iuyPz4vWRdN+3b+7FXhbn/8rvpJ9cfm8ta9qck2u+N1XebHv6oz9RyxoXz9nJEz9Zy5revFbLSoZvrs6dG/bvf6fqvmkHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8F1IAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGAKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIEpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBgCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICBKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYApIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgZ27e/fuW/1vANbAuXPnXkjy0Df/93e+86E8++wLg+Ve3Dsb7G+/5VarXtZo1MsqHtfZaFzLSrqnbLHoZW2vvt4Lm816WUn1hzzbub+WtbE8qWW1nU2mtazmPT3OaS+seWBJMpn0spbLXlb7d2xqnrNmH6R4fRyvem1V0j1l1faqeH2cZaOW1dbsN24ubvfC1rjfmN3dXtbNm7Wo070HallJMl71+sTNdn9z1Duuk3SfZ9NJb47nZNlr96er41rW2WyzlrWx6B1Xkmq73+wXNIcwzT5jkmwcrud80umo1zaOF0e1rCQ5mWzXsqZZ0+d0um3j6aTX7jf7Vs35v2pbleR0qzdH3Jxymc97Wdtb67su2OyjrumUXJJkc1a8RpoXf1PzAmlrd4pL2mvi1XXI4lpMs2/VNh4V28bmOUvv2m9ODyfJ9qg4tige3OnOhVpW+3FWbRuLHayzrd5cwUa6ff3mHGDz+mjO69fnG1fFdeqiZl+uvc2lOr/ZHHxubfWy2g+05jh3Z6eX1bw+1nVSLt39r03rvFbXPLbpqPecbj4713kv9tGy12/cnq3n9dG2tnva2/2d5iRPc39jsV9wOuvNFSTdS6Q5N1Hdu1Z8TiflZ3VzrmCNO463D3vn7MLOevYL2v3G5r6apmY7fDTvvjuyPVnTfVfFa7+5bzPp7pWr7kktHte67s9IsrZr4tXrI1nfb2gcHvaymusVydre181+Y3vvSXMv5Tq/m9vy6qvdvPPf01vLPUpvPqk5H918Tifr25db13f4kvV9p7S6Bll83zjJ2n4/pjquaO5XTqrn7HjZ+x2bS0ztfZunq16737ylm8Ol9rii+Ts2h7nVNaZ1XhNvfhOqOfdd3q+8rvuIq2v95ffEj0a9vZTNtnFt9yYlOVqsZ1+uaZ1fOW5a13dikuSV13r32fl7e7/jyap3XM25pCS5vejNJ124+cVaVq5c6WW1B2jNh8zBQS+rOahuruUmyde+1st63/t6Wc2OYzOr3ZFb0+8pVsdn7T0MazoPUl33KX5zMCnvy5v3rv3m9+vGBy/XspLkq/OLtazLl2tR6zplm2T4V5meeOJd+drXrn27/3Xt7t277xo2/a1jFxYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBgCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICBKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYApIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGAKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIEpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABjY6K3+BwDr7c03k/l8uL+/u9urg3twUItKkuztjWtZr75ai8o99/SOq20262Vtb531whaTWtTZZFrLSpJlennT1WktK8tlLep4tF3LSpLN5Ukt63Deuz4urHoPmZdzsZaVJBcnX69lHU/ur2Vt5riWdbTarGUlyXbWs71q2pwVn9NJ9XdsPqs3ms/OUbePurHotSGrZhsyKfYbZ922caPY2T9Z9sa50/39WtY43bbxtNjX/8adWlRGb+8dV/GWTtK99kfFWfGT9Nqr0aoWlXHzR0y5bUxv3LlcFuclJuU+6tZWLeqs2JdbLmpRGZcb4mrcvDgWHBXnG5sTxElWxZ+xOWJaFO+zzfLz7NatXtbeXi/rjTd6WVkVOzxJjpfruabVbPPLTWPO0us3bjSvx2Lf6mTVve6no94cYLPf2HyelR9nSXN99da1Wtb48uVaVg4Pe1lJTma99bPpYl7LylbvuLYnvbmCP1G8sW/erEVVnzDtxrH4rG6uC2405/WH3GD4baxmvb0u42LHYDoqThZMtnpZ6fZTm2Om5rpxe17/tHmfzYp7C5ra56zYv0pxSL0orsU0bTf7H0k2Dnt7AJsN8bK4p6a5Bpkk02YbUuyjLooji80b12tZSZLd3VrU1m6vbTwpzrNPV937rLmXclzc13tavM/GzT2iSXfRorym1dI+rPGoNzfxyqu9Nabz967n2kiSbBTf9zkt7gcZF+cKmu1wklzYWdNnTHNuszx+3zi43Qsr9lGbC6yTSfc9hLdgQbei2x/u7n89az5jis/O6vtg7XdHVr2+3HruJkv/5ZHmvok1Xcutv1e3ru1V8biae66SdPcWNCcMisfVXDtrzhUkSYr7G7eba7nF62O8nNeykiQ7O72s4nN6o9gHqa6dlTWb4er7ieXvkFTnGxdHtaxFevt3tifdc3ZU3A+ypsvvmUx64+mk3F4192isehfIqLzuszkqrvusiu3wGvcLqh9KLX6rptl+tOf/Nm69XMsaN186biq/wLq96u39TnrHNi5u7G3vY9geNc9Z8dtrxd+xve5Tbfib7zKt8d61e+9dzxW0O8Vvyk3f3u2jNt+Br34be9Eb526W+yDdb68Vld+LqVrXZ0xRtb/TfGcqWdtzVp1ILX4fIUl1L+VG8XecTorn7Pkbvawki71HalnbxTa/2vP+nd9ppuUbO72aGc13tCaT4nt1By/VspJkPnqgmvfdort6BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPBdSAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIEpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBgCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICBKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYApIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGAKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPxf9u4/SrPzoA/7945fjcfj0TAadr3LZhEbIYSQhSMbEytgXBdMTEhJDHFI2gOJm5OQX0BOUpKQNKWEnpTQNsRtkkKDSxIaigmc4PDDOEASEjtgY8VWHFkoliIWsZV3rfVqWI1H49Fobv+Q2wOy0Lvanftd693P5xwdnaP36n7vO++9z31+3fsATMwCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATs4AkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMSGcRyv9jEAC2AYhg8mue3p//1zP/e2/MIvfHCy3LW1yXb9SZZnB72wJHv7vTV+Z7NaVLa2elmba3u9sCQXd5drWSsrtaiq5d2L1by9lfVaVvM6W9ovnvv7+72sJHuz1Wpey/L+Ti1rJ92/YbO8ap6OzXpBs07QtpzuvbqmXDY2L7SD9M7HpRTr3+37WXr1xqZqfad5frTt7l7tI5jExf1uHWR91qtfHaz0vluzrt8uq5a3L9Sy9tY2a1kLW99pFvpJt2xc0E6Xnd1uu2J11jv3D2a98mppt3d/qbcrmnkLep0tar9VUr6fte8xRRe2emVxc/ysaYFPj2o7t9m/s71di0qSrKc4ztT8cseP16Ka50dS7uNpDlQXC+JmfTgp/2bN66z5m7WvswXtT2rWUevX2ekHe2HNiuPGRi+r7fz5XtaRI7Wonf3eud/sS0pSbVws6hzAdtdVde5m8cs17zHt36w6drzdawserPXmGy6yRf3NFnmeSz2vpDmXst23ubBzlhe0Hpd0f7Pm8Hvze7Wf9zn3SO8cOXZ0Mecst3+z6vzX5tyCBZ1DnHTvMe0+wEVVPfcXdNynPaemOu+q2WYy3/BQNOccrq4s8LMBC2ph61bpzgOsPk+9wOXVws4jbjaq251Xzfkgi9rp0h5/X9A+4oWtDyfd66yZtahzT9rlcHNMvPnc5QI/73Pu8d6Y5w031KKqfcTtvs1m11XT5saC9u9ksceOWxb4FSsL27fZvE8ni/s+tGp9p92uaF7Yi1o4tt8dc999tai9219Ry2o+O7LI71i5OOu9Y2V9bXHnUjbPkQXtkqsPV3h2+8q131mwqHNSF/bdjUkubve+W/U9Agus2d947MmHa1k7GydqWav7i/vu9Gb9u/n8art5tjnrnSMX0zs/mvWCRZ1WkHTr+s32WXW+4W6vPZ1kYd8fs6jv8U/SLUTOnq1FXTx+Sy2rXTYW/4y5KcX3uZw6VYtqvt8wmf4cedWrXpr77rv3mT66dxzHl06bfvUs7kokAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJ8iLCAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDELSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMzAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABOzgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxCwgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxC0gCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATMwCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATs4AkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQsIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQtIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEzMApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE7OAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDELCAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDELSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMzAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABOzgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxCwgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxC0gCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATMwCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATs4AkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQsIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQtIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEzMApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE7OAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDELCAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMLHZ1T4AYLEtLSVra9Ptf1Ysxfb2F3fN3aX9vVrW5sp+LSvnt3pZSdY3NnphxT/jwcpqLWtntl7LSpKt872sE0d619lelmtZu/u9rKRbeb3rrl7W3Xf3rrNjx2pRSZJTp3pZR4/2st7xjl694Au+oBaVJPnYx3pZX3pn74b23d/bu87e+MZu2fiLv9jL+kNf3buf/czP9/6Or3td9zd7/3t7WTfc0Mu6555e1p13dttnZ8/2sl5xx0ot6xfe3fs73nFHLSpJcu/pXrl//HgtKvfc0yuvXvPqg1pWkjy4tVnLOjlhX9XTfeC+3m/2slt79+md3W45vL/fu6Z/7m21qGrZeOZMLytJXvPqXgv+H/7DWlTe9Kbeudj+zW7MQ7Ws739br8z/uq+rRVXrjEn3N3vf+RtrWa+4daeWdWG3d00nyeZa7159cbdXB1mf9X6znWKdIElWes2zHKRXv2qOC64X/4ZJcmG7N860m17Wxm4tKquz3vmRpDrgv7fWq4M0Lafbfn/Pe3vl1as+c7uWtbfSu6aXzzxYy0qSD+3fVMu6+eZaVC5s9eo7m7lQy0qSD2z3frMjxXv1brGde9PxXh01SS6snKhlPfFoLao6/t6cB5UkH7indz9r9ts2/47d0dXkQw/0Em+5uVdHbbbPlpuTbZN86IHedXbLkd7J3/zNqhOkk1zY6v1mm8UCq/qb7fe+14fOdPvJbtm9rxdWbFisbj1cy7p3q1dnTJLbVoptzyNHelm7vY6y01svqWUlyS0rvXGf1eZvttXr33l4v/ubndgotj3P9B56WG4+E9MciEmyVCxD2nW5RbXTfFal2KZujsUczMot+Oa537yfFev61awkaZ4j7e9W0hzrT7rt3N3i3JPVB4oPIjQHtJLquX/u8d6Y57HriuNn7bpVMe7h4jyXE7lYy2rX9Zt20uuXW93t/WYPbXWf7T9+vJf38z9fi8rvPnm6lnVx1p4H1asXvPvdtajcfnsva22tW298vFgv+I8P9LKaz7o16/rbvW7UJMnZs71ruln9fnird59+wQtqUUmS7/quXtZ3/7VeXf/cE7372XXX1aKSdJ91u/POXtatt/bKxvPnu2Pi73pXL+u1r+1lNZ9/P198h1fSvX/uF987ePvtvXO/XQfZ3u7VQU4cX8yxuv47MHu/2aOP1KKq7+DZLT8LuV58ccHyos6lbA9nNedoFMv95rtIVlbKY+LNuQWn7+2F3XprLap/P+vlLW/32tSzlV6b+pHifTpJPvax3nV90/lfqmUtNa+z4rOySbc9uHaq+B6BBZ5u+OvFd+Mcu//9taz9L+nN12/Oz0iSJ4t1uRP7vRNk5WTvXUb1aQy7vQt7/e5fqGVdvP2LalnrzXku7bZg8eZ5Mb13FlSvs/Z81Le+tRZ15rV/pJZ148ne+PuDp7ttwZtO9xaWuHDHl9aynni8FpWPfrSXlSS33fdPa1k7X/E1taz9Yj2u/d7Slx2Z9tncpYPFfPZgnsVdDQ0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgU4QFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmZgFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIlZQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYhaQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiYBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJmYBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICJWUASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGIWkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACZmAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAiVlAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBiFpAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJgFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmZgFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIlZQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYhaQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiYBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJmYBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICJWUASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGIWkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACZmAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAiVlAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBiFpAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJgFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmNozjeLWPAVgAwzB8MMltT//vt956W97zng9Olru+djDZvp9ub7+75u7y1kdqWXsbL6llzWa1qCzt7/XCkmR3t5fV/EMWXdxfreatr/TOkYPZci1rf78WVc1Kuqf+Aw/0ss6f72UdOdLLSpJTp3pZ7353L2tjo5fVLvKbv1nz3H/kkV7W0aO9rKR7Pp4928ta0OpOkm5ZvL3dy9ra6mXdfHMvK0lWZ71641569cZmOby21stKumXIykovq1lHvWWj1y+RJOfGXt/EsRt61/TOfu+aXs1OLWsn3fZ785q+555eVrPu3Syrkm43WfN+1vw7Hj/ey0q6f8df+7Ve1stf3stqnvdJ9zdrlsMnT/ay6mMIRece7dVBjl3fq4PUO6SbBX+xUX1wpFf3Xtq+WMtKkp3Zei2reXo0T/3lWW/8PUkubvfG4Nf3L9SyDjY2a1lL6f5mH3qg95vdcmpB2+/bC9znMpjnchiafYDN8Yrm33GRx5ia4xVV5bp+s3+z+Ztd2O7dz5pj1Em5bVEcFL94/JZaVrtsXN0v/mbFL9csP9r9jZvptZmag8fVuv5Kr322s9ud07669XAvrNnp0rzQ2jfPRR1Aa9Yb279Zc5JXcxJPc0JZe1C8mbeoDd3y92o+E7a83xs/O/dYr47anHOVdNu5zaJxUYv8JFnOYvbrL7Lm7ax57q/PFncuZXOe6KLOmajXrdr11Jbm37HcUbY3613X1efty3MLmppzTxa1a6JZDCfdorH5LORNp3rX2blHun3ETR/7WC+r+TxH8/nmJLn++l5WswxpPmPRrIIsapUxSZZ2e22Y5rtq2s2Ku+7qZb3mjt5Y/4X93rzvttOne1l33NHLatcbm86c6WW97NbFnE/Wvp899lgvq/rcVPEPeZBuu6LZpq72uRTrO+0LrTk/aVHf59KuN1afP1vQccHmHMAkubDVu842Z726/sX06vrtMfHqc+nNAdZmh3T7OfF2XsmHzvT6QdrveateZ8UG/IUjvWdHNje697Nm22LpfO/51eZzue33ljbHLI79+odqWa6zw9Fs51af8WzOuVpki/q8T7vOWGzINOfUNDXniCapts8urizmOzTal1nz/ULnnui9X+jJJ2tR9XdgLp1+sBdWnDC0qP3sSSa/V7/0Va/Kvffd90wf3TuO40snDb+KFvPODQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPApxAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABOzgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxCwgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxC0gCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATMwCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATs4AkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQsIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQtIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEzMApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE7OAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDELCAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDELSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMzAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABOzgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxCwgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxC0gCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATMwCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATs4AkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQsIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQtIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEzMApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE7OAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDELCAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDELSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMzAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABObXe0DABbbMCQrK9Pt/6C4Du7+fi0qSbK8sdHLyl4tK82/46x7m9tbWa9l7e7WorK21ss6+0AvK0lWTi3Xsra3alGTlrtPd/58LytJbjyyU8v69m9frWX9nb9Ti8oP/mAvK0n+whserGW97W031bK+8RtrUbnrrl5Wkpw61ct6y1t6WW96Uy/rvvt6WUnyFV/Ry3r3u3tZN9/cy2rWrZLkiSd6WR/+cC/r8z6vl1WvgxzvZTXPxyNHelntNnUz7/TpXtYtRy7UsnZWXlLLSpLri1nnHu21BY8erUXl4navDdNsdybJt35rL6tZt2rW9Zv14SR585t7Wc37WbO91KwPJ8lP/EQvq1k2fvzjvaz2b3b2bC+rWUdt1uNms16dIOmWV08+2ctqVgwubPXGBZNkszl+VjxBls5/pJaV4nhnkmwV+wtOrF2sZS03B+u2t3tZSdar47m9rKX9Xvmxs9+9n91y80Ev7K67a1GrJ0/WstodZTcU+zZzX6+SutysXNX16jybZ++tZaV6nfWikuTCfm++0Oqs2EAr1vUPVnp9m0mymuL97Gyvkrp5vFfoN+dtJunOAyx2Aq7Piudie7Buu1de7W30xrRWiqfi6qzYL5Ek54v3mGJ/wWrzOita3e2NGydJ3v/+XtYXfmEvqznoWZ7TXp3I8MpX9rKav1lzICbpToZq9ts224JbW72sq5HXUmxXtCduLi/oQzjduUnd/ujNjcVsM20Wh33aDopj8Ku7vbG65vOCy9vduv5ONmtZ67Pe82DNa3o1vXMxSbdt0exPuueeXtadd/aykuylVzY2qzvr53vPCx6c6j0vmKQ6zrS0XSxDim2Yg5M31rKSbtG4vlasoxYv6s21xX3t0PHjxXbMmTO1qOuPdK+zxx7rZTW7AJd2e3XUo0e7Y+LNesGJI8Uxra3e/MbV8vzXpr393nj/cnG84uzstlrWLae6Y7n33NO7n73mf/m6Wtbpb//xWtYrbu623//b7+v1J33P7X+vlnX35/3ZWtaXvrY71v+jP9orG19291trWWfu+CO1rJed7PZt3vUfe32bx46crmXtnOrdz1b3u2XjdnGu7WaK52Oz3lieA7hffFZlp9iP2rRcnrs2mxXn9panpC6q6pSy6vOJvaj2O8NWF/Tk39ntlR/tZ/v3i/eY1fT6G5vlx1Lz+Zuk+4xzcd7myslbalnteuPZ873r7MRu7/w4drx479zq3tCOHd3ohb2oNyd1sziWW3/vyVqvT7r5nOdqcayu/fzq0lbzXZG9frLV4js0FvrZkeJ3W98qfrdmP9lbf7SXlVRfLDd7Ze9Z2dXt4vun2tfZA72FTq577dfUso5dV+z7/ulf7GWVnXtxb07qseuL8+eLc2qSTP/8avMFop9Cym/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALj2WEASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGIWkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACZmAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAiVlAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBiFpAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJgFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmZgFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIlZQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYhaQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiYBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJmYBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICJWUASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGIWkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACZmAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAiVlAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBiFpAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJgFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmZgFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIlZQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYhaQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiYBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJmYBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICJWUASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGIWkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACY2OxqHwCw2IaMWd7fmS5gf7pdP93q7m4vLMnBxmYta2l/r5Z1cXe5lrW+0vteSbK8vd0LW+udH2fO1KJy6lQvK0mWdy/Wsp54Yr2WtblxUMva2CivR14si1/72tVa1rGjvd/s+PHyb3bkSC2qWYbccuRCLevM8V6ZnyTrux+pZZ069ZJa1i0bve+1fbz3vZJk6e731bJms1fUspq/2bmx+5sd+/UP1bKu+5xbalnN+vf68VrUU2a9LrT1tV694MJWr16wOevVvZNUf7OVk71641569YL9bjdI1tZ6WeUunoXU/hu+9rW9rGITJidP9rLav9kdd/Sy7ryzl7Vf7I9unh9Jct99vayveUOvvnPukV5959j1E46FPIPza706yBfd0ftue7Pe91re7vXvJMnF/V5dbmOjFlXVrDMmqd5Ad2a9MYTVlZVaVrNtlnTP/YOV3m/WrMutrPW+V1tzTLx57q+mOyZ+kN54/9Ltt9eyqhdauYG2POvVv5sNmYP06vpLKf4N0+2byH4xrNmobmYl2TxSrKgWpyY1y6ulYhU1SS5s9+5nm8WLeme3VzaWq/pZbrZjtrZqUc05ovvFelySLBcbaM36TvM6S/k3y8aJWtRqsX61sPXGdkfZy1/eyyreZPaKc7GXzz9cy0qSNNvUxfp39ZpuD7A2J8AWv9si/2Y7zXvnSu8es7ff+8320xsXTJKs9PLa865a2m3BahlSvJ81x8Tbv1mzW67ZYqo+Llisoybd8uqgOM+lOS547tFu+/3o0WpczVJzslzzok63vKqejcU+26Xt7nMI1f7o5s2z2J9UHqprno7VNlPzXOz2fXfbuVvna1FZPd572K3d7mw+A99sC2arOSbeHRRfbcZtFetXzYZu84ZWbsBP+g6op2uWjWdrUfW2YHPYJ2tvrEVV58mVy+G/+BeLYXf1Oguazwu259q+6U3FMYuf/fRa1K231qKS893f7DW3F58JK95jmu2lnd3usyMrzSrPrDivpt0RUtT8auuzXh31oDhuXD8/ZsV6avO5qeYzMeXfbH2tWDgWx0dWis9dtsfEk/KDDyWrs8V87jJJlneLfVfFtme1Td12+nQv6+aba1HVrolyFeREinOki3/I6hyvje5cyvYY/CJqvvM7SbLbHLPotSse3uqd++1HcNabgcXT46B4fhQf8czG8d5zAUl5ru2iVhybLx1MqmOeVc1KanmsrjlAUr3HNMdi2hOWi/OIm/OgsqDPFiXJwSt/57QBL3rRtPv/FFVePQYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADg2mMBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICJWUASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGIWkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACZmAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAiVlAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBiFpAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJgFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmNrvaBwAtwzDMknx2klNJrk+ylmQ3ycUkH07yH8dx3LlqBwgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDCsoDkNW4YhuuS3Jrk9iQv/cS/TybZ+MQ/n5bkyTy10OKFJA8n+ZUkH0jy3iS/MI7jXvu4L9UwDJ+f5GuSfGWSO5IsP8vm4zAM9yd5R5IfT/Ivx3EcJz9IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFp4FJK8xwzAsJXl5ki9N8mVJviTJ6pz/bZbkhXlqMcnfnuSLf8NnO8Mw/EySf5TkJ8dx3D/0g74MwzC8Psm3Jnntc/nfktzyiX++OcmHhmH420m+bxzHJw/9IAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALhmLF3tA2B6wzDMhmF4/TAM35/kkSR3Jfmfkrw+8xePnGc1yRuS/FieWnDxG4ZheMEV7vOyDcPw24Zh+KdJ3pHntnjkM7klyfck+XfDMLzqSo8NAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAa5cFJBfYMAwvHYbh+5KczVMLKv7XSTYnjPztSf6PJL80DMPLJ8x5RsMwfEmS9yX56kPe9e9I8s5hGP70Ie8XAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAa4QFJBfbVyX540k+vZz7iiS/OAzDn2wFDsPw+5P8iyQvmSjiuiT/+zAMf3Oi/QMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALDALCDJVF6Y5HuHYfjrUwcNw/DlSX44Ty3yOLW/PAzDf1fIAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYIHMrvYB8CnlySQfTPLLSX4lyfkkH0uykuTTk3xGklcn+dznsM9vG4ZhZxzH7zrkY02SDMNwKsk/yVMLVs7zH5L8X0nemeT+JL+e5MVJPjPJnUn+UJIvSzLM2c93DMPwgXEc/9llHjYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADXGAtIcl+Sn0jy00neM47jzrz/YRiGz0jyDUm+KU8tLDnPdw7D8B/GcXz7FR3pJx/HLMkPJ9mYs+m5JN80juOPPMNnv/6Jf+5J8pZhGL4wyfcmecWcff6DYRjuGMfxoed21AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFyLlq72AXBVbCV5c5IvGMfx88Zx/EvjOP6rS1k8MknGcfzwOI5/PclnJXnLJfwvQ55anHHjMo/3t/KNSX7nnG3+fZJX/BaLR36ScRzfm+SLkvzQnE1vyFN/QwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJjLApLXlgeS/Mkkv20cxz8/juP7rmRn4zh+bBzHP5HkjyZ5cs7mn5HkL19J3m80DMPRJN8+Z7MHknz5OI4PP5d9j+P48SRfn+Sfzdn0q4dheN1z2TcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADXJgtIXhs+lOTrktw6juPfH8dx5zB3Po7jDyT5pkvY9JuGYVg/pNhvSfJpz/L5XpKvHcfxkcvZ+TiOT+aphTFPz9n0Oy5n/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFxbLCC52M4l+TNJXjqO4w9+YlHESYzj+D1JfmDOZi9O8rVXmvWJRSj/5JzN3jyO4/uvJGccx19P8ufmbPa7hmH4kivJAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYPFZQHKBjeP4D8Zx/J5xHPdLkX81yc6cbd5wCDl/NMmnPcvnW0n+xiHkZBzHH0/yzjmbffNhZAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC4LCDJoRnH8f9J8kNzNvuSYRiu9Lz7+jmf//1xHC9eYcZv9LfmfP5VwzA824KWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXOMsIMlh+8k5n68n+azL3fkwDJ+T5AvnbPZ9l7v/38JPJPnws3z+wiR/4JAzAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWCAWkOSw/ZtL2OamK9j/V835/N+N4/jAFez/k4zjeJDkn8zZbN5xAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcA2bXe0DYLGM43hhGIa9JMvPstnGFUS8bs7nP3UF+5633z/3LJ//58MwvGAcxycnyn/eOhiHXNxfnWz/p09PtutPcvvt032PZ9L8bjetnK9lndk6Ucu67fh2LStJLs42a1nr+zu1rP0Jr+GnW85eLStJ9lbWa1nHth+uZe3t966z9VnvXEySC/u96+yxx2pRed/dvXXd9/drUUmSC/u96+yOO2pRec/9vXPx+PFaVJLkPb/yklrW7bfXovJv7ut9r5Mna1FJknMvfkUt686ba1F58Pzi/mYPfuyWWtYj99ei8uSTz9YVcLhOnapFJUle8IJe1rHre/Wru+/u1fVf/epenSBJzp7tZTXLkN3dXtbWVi8rSdbXDmpZGxuLWf9eWellLc96v1eSPP547ze7775aVDY2elmz8mhQs67/znf2sn7P7+ll3XNPLytJbr21l/VP39a7pr/4i2tRk46FPJNmnfhDZ3rf7eZiu/NCev07SfLE472so0d7WRe3e9f0+kp3DOFgrdeOWU2vfnWQ3vda2u2OIcxmvfJqab93Pq6uFCtz293x1Z1Z8Tor/h0P0isbl8oN+NPbvX7bm7aKDbRmhfjMmV5WkoeKY8c3bvSus0ceqUXl2NCbU5MkZ4vjI5un1mpZO+ndp1e3P1LLSpILW71yf7N4P7uw2/vNVsrzGJpjCJuz07Ws/eO9McjVdOv6D5/vnY8njm/UsprV7/Vc7IUl3UGt4gDJrDjfsK06d3OrePJvFPsAi+f9XrEPJEmWm4Oexazl4lzs+iTApuINbWm7eD9r/2bni23PI0dqUc0qwexIrw8kSVabZch+ry04m/XmALafHTkofrfmud9unzUdFPuTmv0gm7Pi/Wyt1/+XJLNZr5+sOcaUYnW4XTbuF8vGpmaZf/31tagk3Tmpy7vF8qrYrjg4dVMtK0mWqvNBiuPU53tjMc35O227K72+q2a9sVkfTrpz6Jv9+puzXthjj3evs2a98YEHalE5cfquWtb6nXfWspJkb7/3m93V+zPmla/slcPLxfmGSXJhu9kP0vs7ntgo9oM05+UV+2yT7nMP68X7dPO5qRe9qJeVlJ/zLFbmXvjCWlT2nvVVeIevWQe56XXzXsd3eJrn4tlin23Sndr7u1/+8lpW9dGAle5YXfM3e9ntG72wYjm82mxQJ9nZ7bUrquPvzQfFy79ZM+5gpfg8WPFZt/Ycr/1qv1zvml6d9drUO/vdeuNq8Z0d1Wf4imOeB+W6frVS3GzoFgv95nhWkqQ4ztQcF2x6+Gz3NzvRfFlNUXUuZXkuyPn02oMnjvTuMc3frP1O54e2emXjjdv31rL2br6tltX2wOle2+K24xdqWSfWivWd9svXikv/NNvvzTb1ZpqN3I1iVrJ8vviA86I+y1R+X0czb7U47pP9YgHSful3cfLJdvEy22zez8rPIeT9769FPfT5v7eWdWNxOsiFWe89NUmyed/Edf2Pf3za/X+KKveccY2YN3J6WdOghmGYJXnNnM1+7nL2fQnemTxri+HTknzhRNkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8z1lAkimszvn8cpduf2mSFz/L508k+aXL3PezGsdxN8m8pYctIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAzsoAkh2oYhuuTfNqczR69zN2/Ys7n947j+PHL3PeluGvO5y+fMBsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDnMQtIcthenmSYs81/usx93zHn8w9c5n4v1bz9W0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAZ2QBSQ7b753z+cUkD13mvm+Z8/n9l7nfS/XAnM8/Z+J8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnqcsIMmhGYbhBUn+0JzN3jWO48FlRvz2OZ/PW+DxSs3b/4uHYTg68TEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwPGQBSQ7TG5J81pxtfvxydjwMw3AJ+374cvb9HJxNMm/xy3mLXAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHANsoAkh2IYhhck+Y45m+0l+ZHLjLghycqcbc5e5r4vyTiO+0k+OmezE1MeAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM9PFpDksPzpJLfN2eYfjeN44TL3/+mXsM1HLnPfz8W5OZ9fynECAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwjbGAJFdsGIZTSb5zzmZPJPmuK4jZvIRtLl7B/i/VvIxLOU4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACuMbOrfQA8vw3D8IIk/yjJ2pxN3zyO43+6gqgb5nz++DiOT17B/i/VY3M+/5RbQHIYhj+b5M8Uoj67kAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPC8ZAFJrtT/kOQ1c7b5tU9sdyVW5nz+sSvc/6XanvP5vOO8Go4mue1qHwQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMC1bOlqHwDPX8MwfFWSb52z2Zjkj43j+NgVxi3P+Xz/Cvd/qeblzDtOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArkEWkOSyDMNwe5IfTDLM2fTvjuP4c4cQaQFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnrcsIMlzNgzDS5L8RJLr52z63iTfckix887VJw8pZ555OS+oHAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADPKxaQ5DkZhmEtyduTnJqz6UeT/MFxHPcOKXp/zuezQ8qZZ17OE5WjAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4HmltegeC2AYhuUkP5bkC+Zs+niS3z+O468eYvy8hShb5/J1cz4/rAUzD9MjSe4t5Hx2khcWcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJ53LCDJJRmG4QVJfijJ6+Zs+kSSPziO47895EN4Ys7ny4ec91t53i0gOY7j30vy96bOGYbhg0lumzoHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADg+Wjpah8An/qGYRiSvCXJ18zZ9CDJHxnH8acmOIztOZ+vTZD5TK6f8/m84wQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOAaZAFJLsX/muRNl7DdnxrH8a0THcOFOZ9fNwzDykTZv9H6nM/nHScAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADXIAtI8qyGYfgfk3zTJWz634zj+H0THspHL2GbjQnzLzXjUo4TAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAa4wFJPktDcPwV5P8lUvY9L8fx/G7Jz6c85ewzfGJj+FSMiwgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwCexgCTPaBiGP5fkb1zCpv/zOI7fMfXxjOO4k/mLMx6b8hiGYVhNcv2czX51ymMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADg+ckCknySYRi+IcmbL2HTvzuO41+a+HB+o9NzPv+sifMvZf+nJz4GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnocsIMlvMgzD1yf53kvY9P9M8s0TH87T/cqczz9n4vyb53x+bhzHnYmPAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgOchC0jy/xuG4Q8m+QdJhjmb/lCSbxjHcZz+qH6TD875/HMnzp+3/3nHBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwDVq6K8ByKeiYRh+X5IfTXLdnE1/LMnXjuO4P/1R/WafOMZ/9iybnBnH8TMnzP+/k/yXz7LJ3xrH8Vumyv9UNwzDB5Pc9vT/ftvnfV4+ePfdk+Ve2F6ebN9Pt7ZWi0qS3HdfL+tlRx6uZd27daKWddutB7WsJNnZ7a3LvLr9kVpWjhypRR2U17be2uplbc4u9sL2i7fpjY1eVpK9/d45cuZMLSovfnEv66Mf7WUlyalTvayVlV7WI4/0sq6bV0M/ZLNZL2t9Za+WtbPfqze2Nc/9pqV063JN1XrjrHedPXy+d50Vq6hJkvPne1nHj/eymvXhdpv60Ud7WTfc0Mtq3qebzYp23upK7x5TLfOL36vdfm+2z5pe+MJe1ote1MtKuuXV7m4vq3k/a5fDTc6Pw7G93ctan+30woqN3GZfY5Isp9c+a9pLry1Y/xs2C6wFde6R7nV29Ggva2m/dz42r7O2Zvv92It6Y3U7s/VaVrP/L+nO0djc7c1juLjWm8ewvlsc609yceUltaxFHfdpj8M0xyGvv76X1ey7qjYGkxysrNayFrUOssj90c2ysXqfXuvWQQ5mve+2tNvrB9lJr/yolsNJdyByQdvvF9NrV7StrxXPx2Kh3yyr2pa2i/Nfi6rt9/3u33BRv9veSu97LW912+97G732+6LOPVmeles7xS/XrOs3Hw1otwWX93t1/b1Zr66/qNd00h0bXNR+kPYYQrX+XeyTa3Y3tq+zZv93s7xq9qNe3O22BZu/WbVOvKgnY1L9bs25vc25a+2xuma9sdpHnN73urDb+15JspkLtaydlc1a1upu73vtrfW+V9Itis+e7WWd2FjMdmfbos6hbw6dJd375xNP9LKa81yaZdWCDnfWLfKzsg880Mu6bf8DvbCbb+5llRsWzWdKm5r9ZO2ysZnX7Ldd1DlXyeLWiRf12bNkcefVNNsw7bKxWe43+66afXKL+j6opDsWs6jlR1Kel9cssBb5hQyL2ogvfq/2u2qq77Bb0Plk7X6Q6jxAzzwcjmalZ1Er4OVnIavzzJvvTm++q6Y4pz3pnvrV5y6Lzxa16yCLOubZ/F4L3abe6s0HuZDefJDmcwj159yKLyPeO3lTLas5B7DerljQ5xCqYwgL/PKHg7VeXW6R57RP/Q6Nl95xR+795V9+po/uHcfxpZOGX0WLOdOA52QYhtcn+SeZv3jkTyf5w1dj8chPeN+cz08OwzDlU9NfMOfz90+YDQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwPOYBSSvccMwvDbJjyV54ZxN/2WSrxnHsbi08G82juOZJL86Z7PXTpE9DMOJJLfM2exdU2QDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADw/GcByWvYMAy/K8lPJHnRnE3fleT3jeO4O/1RzfVzcz7/8olyXzfn8/vHcZy3uCUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADXKAtIXqOGYfiCJD+dZG3Opu9N8nvHcfzY9Ed1SX52zue/bxiGF0yQ+8Y5n//MBJkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsCAtIXoOGYfj8JP88yafN2fTfJ3n9OI4Xpz+qS/ZTSXae5fOXJHndYQYOw7CZ5PVzNvuRw8wEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgsVhA8hozDMMtSX42yafP2fTeJF8+juOj0x/VpRvHcTvJj8/Z7JsOOfZPJVl+ls9/Lcm/OeRMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFogFJK8hwzCcSvIvkhybs+n9SV43juMjkx/U5fn+OZ9/5TAMdxxG0DAMa5m/IOUPjOM4HkYeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAi8kCkteIYRhO5KnFI0/O2fR0ki8dx/HDkx/UZRrH8WeTfOBZNhmSvPmQ4v5KkuPP8vnHk/ydQ8oCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgQVlA8howDMPRPLV45E1zNj2TpxaPPDP9UV2x75rz+X82DMOfv5KAYRi+KMlfmrPZPxzH8dyV5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALD4LCC54IZh2EjyM0lunbPp2Ty1eOSvTH5Qh+OHkrx3zjbfNQzDV13Ozodh+JwkP5pk9iybPZbk2y9n/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFxbLCC5wIZhWEvy00numLPp+SRfNo7j/ZMf1CEZx3FM8o1JxmfZ7LokPzIMwx9/LvsehuGLk/zrJJ8xZ9O/Po7j2eeybwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK5Ns6t9AEzqh5LceQnb/XCSLxqG4YsmPp7/z4fHcfypK93JOI6/NAzDdyb5q8+y2QuTfN8wDH8gybeN4/je32rDYRg+K8lfTvInMv/a+NdJ3vzcjhgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBrlQUkF9vnX+J2f3bSo/hk/zrJFS8g+QnfluTVSV4zZ7uvSPIVwzDcl+SdSe5PcjHJi5N8ZpJX5anFNodLyPxIkv9qHMcnL/egAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuLZYQJLntXEcnxyG4Q1J/lWS33EJ/8utn/jncm0lef04jg9fwT4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC4xixd7QOAKzWO46NJvjzJXRNHfSRPLR5598Q5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALBgLSLIQxnF8JMmXJPmBiSLem+SV4zj+0kT7BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYIFZQJKFMY7j7jiOfzTJf5HkwUPa7WNJ/kKS3zWO468d0j4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC4xlhAkoUzjuNPJbk1ydcnee9l7uZXk/yVJKfGcfzb4zg+eVjHBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwLVndrUPgOmM43jqah/D1TKO4xNJ/nGSfzwMw2cm+T1JvjDJbUk+K8l6ktUkH0/yWJIPJ/nlJHcn+efjOP77q3DYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCgLSLLwxnH8tSR//xP/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQN3S1T4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgEVnAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAiVlAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBiFpAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJgFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmZgFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgInNrvYBAItt/8kh5x5dnmz/118/2a4/yf5+LytJTp0qhq0dr0WdXKtFJdvbxbAks/Ve1pEjvawzZ2pRSydP1rKSZDYrrqW9Vjz5z56tRV3Y6q5Hvjm7WMt6xzt61/SfeeUv1bL+7ZnfWctKktt231fL+uH7X1HL+uqvrkXlJ3+yl5Ukb3hDL+vt75iunvh0X3nrg7Wsh2Y31bKS5MY8VMt6cP/GWtZNR3p1uQfPF+txSW7auFDLenh3s5Z1YmOnlvXQ2dVaVpLcePKglnXukV79qtmmbjt6tJe1tNW7prO7W4ta3tioZSVJZsXrutjJs3q216beOd6rg6xuPVzLSpK3vOVELes73tBrw7z9bK8N85U3f6iWlSTf8dZbalnf9td69+mf+bneffp3v7pXt0qSt/98rxz+yld+pJb16PiSWtb6Vq9tliSPv7DXPptd3zs/9ovd+usre72wsou7vT6Xpv1Z93utFGdTNIe0msMVN9zQy0qSpd3i/bP4o82O9O5n7eHVYzcUy+Jekzqr+73xrJTnMWyeP90LK/aDrK+s1LIy607Xq8YVf7PVWfHkP98tHI8e7ZX7S+d77bNsFX+z4715UEmylF7fRNPyVu/8aNZ3kvK5n949ZnOld52de7Q7VtdsWywX6wWrzTbMVrFCnOTirDdO3dRsUxcv6STJcpp9ZcVKarFC3GxTr5/tjvtUJ9EX50c/NvbmC62+qBb1VN52sb5TvM6WZ8W69/nzvax068RL+70y/+zZXr/+jce7N8+d/d5329zonfsH6Y2Jd+sfyV5xblK5C7CmWg4nadYbl4v9O83nmA7SHV/db+aV20xcuWY/avM+vT7rzvG6uNu7ny0XnynNzTfXopp1giTZb45Tp3c+ru8WO0JWNnpZSbUyt7pfLEOKfd/NodwkyUqv47b5mx1s9PrZl4t9BUmqdbkTG8Ww4rP9y+X3MVT7AJv3mOazRUeaL1lJDorzbavj77ONXtbWVi+rOQiZdPu/i+XHxvHes2dLp3vvLEiS204W3y/0h7+1FvXwW95eyzoxa84VSs5u98Z9bvrJ/62WtfXGb65lndguj4k3X/T2trf1st74tb2s8oMIj469Pp5j1xXfI9B8tr88Jr6/0Ssbm+OQy8X6zt5+9z1vq7Pe37HZ9918pnSvOF6RJMvbvfJqb63Xd9XsKmhrPsvU7CtoTjecrXSvs2Y/yMWV3r3z8cdrUTl2dDGfv2lrzk1qz/HKbq8QaY7FFB+7rI4bJ933WqwXByKbc0/a97PmPIZqgVXMaq9RsLpSvH8WC6y9/V5bsFkOJ8n62mL+Zs3nLqtjdeW+zb3jvXeGbTbrctvFC+1v/s1eVpJ8y7fUoh59tBbVbZ+96129rCS5/fZeVrGfrOqtb63G7X3dH6tlPfpILSpHjxbbS+1njqce0zq4NvuQuiNBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANcgC0gCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATMwCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATs4AkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQsIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQtIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEzMApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE7OAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDELCAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDELSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMzAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABOzgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxCwgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxC0gCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATMwCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATs4AkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQsIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQtIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEzMApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE7OAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDELCAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDELSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMzAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABOzgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxCwgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxC0gCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATMwCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATG8ZxvNrHACyAYRg+mOS2p//3W2+9Le95zwcny11bm2zXn2R/v5eVJLu7vaz1lb1e2ALb2V+uZTXPx+Z11ra11ctqXtMnNnZ6YSsrvayyt7+jt9b6V37FQS3r4bPdNeRPrF2sZf3CPeu1rM/+7FpUrr++l5Ukq/u93+yhrd5vdvx4Lapeb1yd9epyD53t1XduPLLA97Pz52tR58aX1LKOHq1F1a+zdl5L89Rf2u7dX5JUGzIH6dWvqn/HdmOweKE9fL53PztxvFfX39ntnYvN+keSvO+e3m928821qGxv97I2NnpZSXLmTC+rWddvWt/9SDXvod1evfHGtQu1rIONzVpWu75zsNZrUy+ldz+r1q2K36uu2CG9k9Va1upur/xI0r2BNhues1kvq6xahpwv3qub52L7/CiWVwcrvfJqab/XZjqY9dpLSbK0VSyLm+djs6OsOUidZGetV9ev3qsX9T6d5OJu77pe33qoltW8zvY2eud9kizvF8e0mmVjMevCVncew+ZGrz24t9/9bouqeeo3i/1q+VHW7C9onh/LKY6PlNtni9ov1yyHl2eL+b2SZHm32P/drDemV/dud7lUxyyaberijXpv1ruXJcnydrFNXZwP0rzOqvfpdPvlqnXU8t+xqfmbNeeDLPDjHN2ysfmHXOQfrak4FztHjvSyyv3RC3uvblbAmw8MpltPrZbDizoumFS/W7V/pzgm3i4bF3VuQfP597bqczG7vX795rnYfmaq2ZdavVc3G4PNOmpb8+9Y7CdrPu+TlMfPimOe7X7blgWe1lsdFzz3SO86O3a0+xzCxe3ed1v/0e+vZV184x+rZbWbgtX6TvEhvnMvvLGW1b7OqpXi06drUQc331LLqvYVJPpcnoeaY3XN9nuz/Gg+T5p0m9SL2oZZ5BfjXJz1nt1e5DZTs566qNd026LO/a4+J75Srusv6CSe5rhP+/1COXu2FnVxo9fOXV8rnvvN8z7p3mSa4yPF77Wofd9JsnzmwV7YqVO9rLJqH3FxjYLm3LX6+4GL73S+sN/rL2i+lnKR383XvHVW69/NH+2++3pZSbWh+9CRV9SybtxY4PfaNueZN9973JzbeM8HallJcnD7y2pZC/vepPJ19tCZaeuor3vdS3P//fc+00f3juP40knDryJvJgEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACZmAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAiVlAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBiFpAEAAAAAAAAAAAAAAAA4P9l7/5jLL3r+9C/dzgcjidnh/Ew65mstqu5lmOWZUGurxMsCywuBYcEFCUUJSilqRNVVRpQm1ZRQbpVVF2hq0aKUlKIEiVR5N6LbqGX9loKaQmQykoJmGK5vpFxNmTju3ez2eyy0/FkPAwnw+Hs/SP3L5N/n7etk9frT1ua955znuf7fH8+HwAAAAAAAAAAAAAAAAAAYGAKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIEpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBgCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICBKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYApIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDARi/2PwBYbidOJJPJcH9/f3+4v/1iG/J7+zaj4uNgNutlVb/EZPVwrxc2n9eiruzfUcuaTmtRSbqXyMb+s72wyU4t6uCwW4+8eY1sb/eysrtbi5rPe/d0kmq7f+bMWi1r6+u9e/r49jtrWUmS3iMmZ7ePe2FF84xf7H/CYNbXi2HF9uPG86u1rCTZOtHLeuyxXtZtt/WyqtdiOe/69V7W4WEv6777es/pJMl+L6r5Pe7u9r7HnZ1aVJLk8LD3/GyOK65c7Y2ZmmOYg1m3v/OpT/WyXv3qXtbJk72sV72ql5V0+yCveU0va3Ozl7Wz0x2/f+xjvaydnY1iVi0q6+vd/k5xOinb273nWfM5PZl05zab44r9WW+c+81v1qIyv63XfiTJ2rw3d7UYLed80sr1a928Yqd4b9R7Vo+Ky6vttbpMeu1Vc5l6tTjR3p6PvnS91xafP7eoZTXX36v7M5I8/3wva/VkcQG++Jsdt++zS72sey/0np3N73Gc7hrkXrH/vTEtfrbiw3Nj2m0bv/Tl3vV4++21qOo+qLPrB72wJE9e6s27NL/Hc+d67cdKcYybJJcu9rJef6HXbzxY0vWspNsHuXu9OLm53hu/7+335hsffbQWlST5ifsu98LOnatFjUe99uM/PNqdj37X5lO1rKP7HqxlpTiueOTXa1FJkp+69KFa1vG//IVa1ni3N0d8ZX66lpUkZz/3G7Ws8TvfWctqWmx218RX0mv35/Neuz+eH9Wy2me0jqfdtcGW8WFvTH006u5jWJ31ztW125Ca8rpxdVbusDffeDzpXfvtlf7mOKa6flbMWky7bePKfvHM8Xrx2dncQF8+PNL8zQ5Gvd9sbfa1WtaNW93ndLMP0uyjji8+U8u6Ojlfy0qSO9f3a1nV3+yD769lLX69Ny+RJCu7vTbkuDivP/5wb55s9P5/WstKuvMFzbO5W7/9v9WyFu/9sVpWe6/t0XpvLnX16SdqWf99+j21rK2/uFrLSpK1M2d6YZ/8ZC3q8O0/Ucta2y2+7yfpHvT8zd+sRZ36h++rZeXy5V5WkmuT3jtdTn/5y7Ws+c7dtaxx+UWA1X7jpd74bHGuNz5r7ydrXiIbu71n9eKu3n3WnJJLkrXJcr4Tqukg5XesFBd+mvsbV4rrq+3frNkW7+/3VrWa3eH286y62bb4koRRcztIcw0ySa72+gVHO72+3Gp683+LUffdfCvFl2g8celsLest9/f2TNT3C232OgbN/fpPPdW79u+5pxaVJHn66V7Wgx/9YC3ryQ/+u1rWvTvFvSBJ/uCPemueb/hE7zcb//zP97LmxRdNJNU+yEaxj7p45w/UsjbmvTXqXCyec0uyWnzZ7I3XvqWWtfXbj9ay8vf+Xi8rSU6dqkWdLbYf+bX/vZf10Y/2spLuiykffrgWtfLpT9eyPv3Lv1zLSpK3f6h3rq56fTTnQf7xP+5lJTn727896N9/+bfK/beXiO4pZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIC/hhSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBgCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICBKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYApIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGAKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIEpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABjY6MX+BwDL7URuZZzjwf7++vp4sL/9QivXr9WykiT7s1rU0fadtazVWlJyPO/WSR7P57Ws4/U7almveK4Wlcmkl5Ukq/ODXtjOTi+reC1Op712OElWZke1rO3tYou1vt6L6j1e/tK8N+QYNUc3o16DNR4tallJqm3I0bzXhqyOhuuTflvW4ddqWUm3X7A26X2POexFbb18rxeWJOubtahmF+TUqV5Wtc1PMp32sorNcB56c++evrbb7TeeXu/1G39/v9dvfPBCr706mmzUspLk7Hbvetw77F2PG/Nev2AxKvYJUhxPJ7lwYa2W9da31qJy9Wovq9knSJJvfauX9cBOb972Wk7Xsk5Pun3U7e1eu/+j9zxTy/rq6Hwta7PXzU+SzIpzPHfv/9da1tGZ76llre6X133mvYtkozioPr69136MD8vj91lv8Lky7WU118/GxbnvpL822NKcB1lJdz56kd5v1pwjXox6cwXjeXHONsmrXlWc42muv6f3uZr7CpJk6/bmNbKcWxHb89EXLhTDrl+vRY3OnK1l7e1356Obc4CZFTfWFC/+G891f7O/8Td6We35gp7uJq9z53pZq5PyHo2Wch/k9TvFyauLvcn2tebF2JwATHL3mWJYcc6lqTkNcv/9vawkyeZ2L6vZXhWz3vnO5g76ZDF6sJa1WtzXu5j0vsefenNvPStJ8sr/sRY1fvrJWlZz09XZz/9GLStJd3NBU/FAR/NcQJLszbptcU3xedac00+63YLnn+9lbZ1czv5wW/P6aJ7naN9nTceT3h7A5rz+Qfn5UtzSnpXiQHcx6s0RHxbPqSRJRr19NZNi2zha732udr9xUfxsa83PVnx4bhXPciRJJuu1qPFhcQ/9dm9Obr2W9P8rPqzH16/UsvK3/3YtaqW8X6hpfKk4L/ee99Siykt11f1J1bO5b397Lao77uzOFVT3Ut7XOxuw3tsGlczKN3Vxj1f+zt+pRVW3mc+aYen+Zj/+472spvI5hNPTYv/qb/7NWlT3HTzd59l4Xhx7FsdnTc3980n5vXLFA9XNMziTSXkNob2JvqT5nonme2qS7jimOTdxNOqtMU3L78BsnsFpvoNn0XzbbHvS5Uxxs231ZVe9qPpi3V131aJmzY9W3Es5Kt9mhzv31rK+449qUdW+VbsXd+Vqr5/anC4oNh/ZSPcdGg/eX3zGXOztta2+W2t/vxiWvOE7iw+Zd7+7l1U8N9U8h5CU91298wdqWTdv1qKydVtvgLa33Xs/WZJsNA8d3+pFVQ8Bf+hDvawk+c7vrEU191KuvOlNtax813f1spLkvvt6WY8+2st6//trUW+/dKmWlSQ/N/qfa1kfmP+7WtaV+3+4lnX294rXfZJ/9OFha1td369P1r4kLO9pEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICXCAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBgCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICBKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYApIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGAKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIEpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAY2erH/AcByu5UTOZqPB/v7zz832J/+NrdNT/fCkswnxbBZL2o0Xa1lzYqfK0lmkztqWWvzo1rW7bf3frNx8XMlSSbFG213txa12OxdiytZ1LKS5HjUux6bl0euX69FfeMVZ2tZSbJ2W2/IsblZi0ouH9ai9vZXallJslG9+IsOe79Z92JMxvPjXljzexz12o/FdK2WlSQrs16f59Sp3rNzZ6cWlZs3e1lJsrFe7PPsdNv9lu3tcmBxPHjXXb2sxWSjltXuESwy3PzRi6rYt7p0qRaVzc3us/Onf7qXdeWpvVrWb/5m757+J/+kFpUk+ef/vJf1nz/cm3P51OO9OeJ/8PC0lpUkn/50L+snpk/Xsv7brfO1rB95W6/9SJIndnttSLJfS7p4sRaVe+/q3mfXdnv9ndPb67Ws54rjs9tua173XaPiGKY7/dfdkjJOb55sMund083f7GjWnZdYnR/0worzjc1v8WDWHU9//evFsBP7tahRcX016+u9rCQ3nutdI1svL/aJi9/jfF6L6rt6tRZ1uN5bp94YFZ8vSTIpji2Ke0+ONnu/2W231aKSdO/r6l6oYn+nvTFvVOx/N/vEq1nS66Odd+5cL6upuT8jyfF6r088Lo5zl7hp7HrkkV7WT/5kL6t4n83Xe/t3kmT8yK/2wt773lrUyn5x3Pmxj/WykuTy5V7Wm95Uizre7o0rxl/+ci0rSXeTxhvfWItqzje2D7VuHF6pZTWv/Yx68xLlLmqm3eXcmsWk1y9YLe5XTlKddBmPivt6i5+rvoO4OGgapznZ3vtca+22qjn4rI6ZevMS7SNTzbmJ6jnP5kR7uROy0rxIihfI0Xpv/+vqpHzmeN57go6L10dzv2H9vE/ztm62Ia97XS3quHz+Ztzc61K8z6pnSstrCMeT3mcbHxbnbYuTBdXl1fJ+suZ7LVaKn+10c3x28XIxLN01i+J+stUf+qFaVnUdJkn+03/qZRU39q78/b9fy6pPSP/Jn/Sy9vdrUSvNA/Dt36z4PGt2DObT3rmp9nay6l7KWXHuqvhFjoprTEmq89HN9bPmPvPjdN/H0JzaPB7w3bIvtKyvQqtrN/wt7Quk2Jd79nJv7rv5urzZqHtO/BvF91X/8R/3su6/v5fV3CaXVKcmqtMFr3td79lZPHqWJPniF3tZ3/3dvazq2YD17nN6yDoBL7R6zz21rGa3YLFzZy8s3Xdubp0rTrYv6bv5kmRarGNxWPxszenGg8PemHpjWnyfc5KDWW+v3NYT/7mWlT/7s1rU080XHCa58Bd/UctaefwLtazmhqHj7/3eWlaSfP53btWy3vKRj9Symmf4vvbZz9aykuSDn/2tWtYH/k2vs998t+c/2P9kLyzJxz/+zwb9+3/+54P++Zes5XwjPQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBLiAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYApIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGAKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIEpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBgCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICBKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYKMX+x8ALL/RgC3NbbcN97dfaO3xz/TCklw591Ata329FpXxaNHLmu/XspIkk0k3r2R8uNcLOzzsZSU53j5byxoXb7SV2VEtK7NZLytJphvdvJYhH5YvcOpULeov7c9rUc0mZKP4m02ntai/NOv9ZpPmZ5us97LKbeON51drWVsvr0VlMV2rZa1cv1bLSpJsb3fzSlbS6+ufOrVSy0qS43kvr9ruF59n1T5qWfFrzMp+cXzWnCxIkv39WtRkUhxX9LpW1cfL2qh7T3/oQ73+TnZ3a1E/9EO9a3Gc41pWkvzbfzvuhX3pci3q4YdfX8vK5cu9rCQf+cjdvbBffKoW9baf+eFaVq5f72UleWh6sRf2/9ysRd17oTg+K85bJcnp9WLYrNdJ3bq9l7UYFZ8v6Y5zF+mNO1fm3X5B08Gsd42s5aCWlXlvDXJ10t5G1JsIad5nTdVrMclouzdvm+K6T3Xuat7tg5w6VXx+zop7JorfY7cHku41cu5cLaq7paa8f+fq1V7Wzk4tarXZNpb7INWxxbz42ZrtR3NxJOU9h82J/cPe3oKj5tpIypdI8SerzrWX1+qee66XdfJkb91ntTi/szrqXYzTabmXes893byW4n22Ouldi0mShx/uZRX3yi3We8+z+kzSI4/0soqbbZvLZ2dPnuyFJfmPs7fUsr5/3hufzefFefZJd73ixit6Z0e2iv3G4+Jv1t7T3hzmro56v9miOeNYHr8fr99Ry2p+spX2uamiG9/orfucPNm79leLc0nNPeZJMm72vzd79/S8eJuVl+qyNi2PB5dRuRNS3VtQXa/oRbU1H9Wj4rzcy15Wi+pr9lOX9Axf+2xAVXFzQbtfsLSaz+ryOLelvj+6uD5ykN64c21ePHdZ3L+TJHnzm3tZZ870spruuqubV1xfXXzfO2pZK1ev1LLq91nzGdO8Hpufq30mvfjZnp2drmXdWZzbrJ+vKP5mRynuTSquMbWXKyaT4tn+puK12Nz72recZ7TacwXjJV0gmU9649x5ea2u2TI2h2fVd82W+41rxamrkyd712OzvWoPz5qf7S1vLO4XKs4Bnt3uriHsv6b32e6cPVPLuvGq87Ws+rvMm32e4hpCc3zWfF9v0n2nS/O9Fjdu9p6dr3xlLSpJt2ZGc0m8+Tq0O88U92KX3ySw9vQXemHF9wg0z6lcuP/+WlaS6nsp62taJeNPfaqaV90u9HM/V4v6xP/Va6++789v1bKSZLJVDHtvb9726r+oReVdT/+zXliS979/2L//0Y8mN3uvvnzJWM6ZdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICXEAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBgCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICBKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYApIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGAKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIEpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAY2erH/AcBy+9a3kueeG+7vb51aDPfHX+AL04dqWUnywJneZ7tytVdPeO3wei3rYHq6lpUka1e/2gs7c6YWdTzdqGXtznpZSTKd9bLGk17WwXy1lnU462UlybTYe93d7WVtzPdrWYfttvHwsJY13S62IYe9i3HUHrVNeg3WysVnalnVZ+dkrZaVJLfd1ss6nvTus/Hu12pZN17WbRtPFbMefbSX9YM/2BtXXL1ai0qSvPrVvaw//dNe1nTa+82m026/sdmX+8Y3elk7O8X+zs1eVJJs3T6tZe32piZy5kyvXzCZ16JyUB4Lfv7zvawfe+9dtazLn6tF5a67xr2wJL/zO72sH33322tZFy/WonLhwt29sCS/92gv610/+IO1rMuXa1HZOLPZC0vy7OR8LevOnZ1a1tF6b3y2OumtwyTdtZhXvKIWlZMne1n7xX5+kpxe7y0irBTn5KoDps1u2zgv9okX672+/kqK7VXz+kiy2LyjlrUyP65lHafY/y7PRz8/4P6PF1r978XrcX29l1Ve+JkV18SbswWLUXec27RSvEYWk+KvVnxOV9vhJKOdO2tZ1X5B8Vo8mnd/s88/1su6777eZ1tf72WtXCruk0vy7Kg3V7a93fseR8V9eauj7jzI0josdq7K/cbbbutd+6vzg1rW8bw3ZpoXn2fNOZAk3QWS++/vZRX3Njb39SbJ2lOP17IWb3ywlrWyv1fLyn339bKS5OMfr0Udv+fHalln1mtRydXufPT35wu1rOPRA7WsaW/7Tn38vvX1Z3thp3ZqUc1eY3VeIsm4+OEWxetx5bDXH26PK8aT4txmeuvv1e+xOamf5Pbbe1nj+VEvLL3193F7zqV53uf6tVrWanGtblHe015VHOdW28bmnpqyZr9gMu3uLWham/T2gzTXPLde3runj+fds/3jp5+u5tU89lgv62d+ppeVJM3frLhnefzpR3tZ7353LStJt1/QzNrfr0XN7+rt1R8fFue+y9amxef0rNhHLV6LSZLnn+9lNfcRN/v6ly71spLqpMvKU0/WstpnA6qK7yJpviTh+Exvb+O4/WKc4vV4Z/FZfVR899rq7pVaVpLqQuTqF79Yyzp+2ztqWatpzrMnzbn26rO6OO5sr/s09yetjYrX46g5R1xcg0yqfeIbN3ufbas4Z9tco06SXO+9rObSfu+8/flz67Wso1n3Pms+P69e7bXDd28W+6jFdw4m3WOe/8cne/uFfvQ9vb0Fe4fdfXkXLvSyDg5787Z/XFwa2bqnezhgtfn8/JVfqUU9+fC/rmXdu1NcG0ly5bDXFp995F/Wsk7+zM/WstrzIMe3n61lNc9YbDff+V0cU4+vX65lJek+PP/Lf+llFdeYDh/vnZlKkq8X31e9dfF3a1nVzvcnPtHLSnLXr/fmbfPJ3vX4Iw+fq2XlX3y4l5Xku77rF3phxRe1v+9976plbf1hsf1I8ok/G/ZMafMdii8l5RlqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgL9+FJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGAKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIEpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBgCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICBKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYApIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGNiJW7duvdj/BmAJnDhx4itJzr/wv59/zWvylSeeGC54NBrub7/QpUu9rCTHd33b1zmY5te4Mj+uZS1G41pWkqzs7/XCDg9rUcfbZ2tZbc8918va+vqztawroztrWZubtagkyWTSy1qZHfXCmh9sPu9llfOOslrLan6N7Z9sI8Xn2XTayypa6j5IseO4mK7VslayqGUlyfF8pZZ18WItKuvrvaxXvKKXlSS3397Lms16WcVhRbW7k3Svx5s3e1knT/ay2r/Zyu7XalmLzTtqWc17enV+UMtqPqeT5PHHe1kPnOv1rW58c6OWdepULSpJt23cOtXryzX7ce2x4O5uL+vs4TO1rL3t3jz7xrQ3950kx+mNPcfz4jxZ8eK/dth9njXnUpttyGp618di0pv/S5KV69dqWYvt07WslcNev7E9/7dI71ndXPOsLuY2OwXpjs+ac4DNa3GZNee+F+u98VlzriDpNiHL2gepT5Q111fnvXHF6qj37DyYddfqmtf+xnpxTau4iHA06o7PmutnFy70sqrt8O6VXliSK+ntXzu73Wuv9g577VV77qp5QTbnC5Z5/+v+fi+ruZbbHAsezZZ3LLh6vbf/NTs7vaziAK25tzEp77Ut77uqaS5SJ8k99/Syitf+8bQ35zLe7+07Scpzm8X1ioNpb72ivYW4uodn1pvbrN5n6Y4rmnNXzWdnc9/mWorrgkn3xm6uaRUX+9trTNW+3JL2v5vrMEm5LW6eHSle++21utVJ7z47OOx9j81rv/2bVeeumufBmh2eduPYziup7oNqz+9cvtzLat7UxYn2xU7vPQJJ97zP8XpvzmV8WGyHm9di0j+M0FK8z46mvWux2WdMuv3Gtflynn+vTvAk3U5xMWtxrnfep7rvO1nul5GUtM+vVvvES7ovb0mHZkmW97PVx4LNzUnN51nzPFj7N2v2QYo3WnOf+dqk3AdZ0j5x83nWHp8treaYqf2gLj7P9ia9Z0zznMoy77VtWub3C12/3st62ct6WVsne2chr+139yw3LemyT05vdvuNzbMqK5/7TC3r2oWHalmnp+V9ec0+T7EhPtjsrXnWx2dNxd/s2qh3xvP0evE9Au1xRbPOSfNlV825pPJ5n8W7f7iWtbT1EJod/STZ3u5lFa/HK2ceqGW164585CO9rA/83d4ZrSev9+Z32q/FOX/XsP2r195zT575gz/4q/7XM7du3XrtoOEvIjNnAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYApIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGAKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIEpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBgCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICBKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYKMX+x8ALLfFrRM5mK8O9vfXRseD/e0XuvGq87WsJNnavVbLWmyfrmXl8LAXNdqoZSXJdL2Xt1L8Hq9fr0U1L48kyajYE9raOVPLmha/x/m8l5UkK/t7vbD19V7WxYu1qKOd7vNsdX+3F7Y+XJ/jhdYOe8/pbG72spJkPullXb1ai1rs3FnLajso9nma1/7KdFrLahunN47Z3BzXsk4ffrWWdbB+dy0rScb7X6tlzSZ31LJOj3qfK+vd59kiK7WsrdsOallp9r/L47N6n6dk9Wqvbdzb7LWNG7OjWlaSPP54r6//wKd+vpb1f7/5f61lPXT4H2pZSfKl0btqWT/wJ79cy7r0P72vlnX+6mdqWUly5q0P9cI+/Ola1Ow9xXmQJx7rZSUZ33dfL+zy5VrU4p57a1mn58W5xiTH6Y3fV2e9z3bjm73PtVVcF0xSnSNeyaKW1XQ8743NkmQ262Xt7/fmXM6eWc7rI+le+0ez3vW4WmyvFqPetZiU26vi4vF+8Tnd1pxqXz0szjcW55Kac41JslJchJ9Mem3I8byXtTbtPjub10gzazZaq2W1957ce0/xGil2Upu9guPts8W0ZLN5jRR/s41J84N1jwwMuW/4hQ6L+xtPT3vXx0qKg9wkk0mv3d/fr0VlY7qcfauVi8/UspIku8U9gGd6e22bbf7qbL+WlaS7Qbq51l/cb5jHH+9lJfnq5gO1rLt3etdHc852/NRTvbAkF8/01ld3dnrnfZq9xpXrxb3YSUabve/xeLqk843NmzrJvDrS7Wk+po+L8ztJcrjfy9ponvdpHnabdn+zquLFv8wvTjguto3jw97+6MP0rv1J8chU29qkt07dvBbbR4uaaxbjYtu4mPTmbFfK+8ybP9rxqPc9jkfLu1+oena72Ig0x4Lj8n7DxWbvrFvz3FT1XG75N9s77D2rN0a9fuPeqHctTosDi7397t6kjcMrtayjzd7egtVLv1/Lqp+D/OAHe1m/8iu1qOq7Y9oDi3/1r3pZP/7jvaziGKa5dy1JVp/4fC1r78KDtayN4lxBs/+RdJ9nizPdvXItzfMVSdIbUac67uzOJfWyknQnU4vrkM09Xu3zPjdv9rK2vtVbP5ts9/oF7baxuXbcfNfVorjm2T6HMJ739lL+0R/VovK61/Wu/eZ1385r7o+eNddXu9uF8sQTvay3vrWX1Txf0Z4GefrpXtY99/Syqlvlyvvy9ovnPDcuXKhlVfsF5QfaUXFU3Ry/F19llJ2d7vis2TY+sN27+De3a1G58Vzvaqy+RzTJ3nbvfWgbjxXfO9jsXH2+N6efJD/5uR+uZf3qh3pzLs0+6lqzYUzyH5/qnR35/nO9xvFzn6tFVce4SfJLv9TL+sA/7A2amscQvvnNXlaS/MbHhu1f7f/5iUH//ktVd4YaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4K8hBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGAKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIEpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBgCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICBKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYApIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxMAUkAAAAAAAAAAAAAwem6MwABAABJREFUAAAAAAAAAAAAAAAAAAAAAACAgSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDATty6devF/jcAS+DEiRNfSXL+hf/9Na85n6ee+spguePRYrC//UJ7+92au9/8Zi9r6+V7vbDd3VrUwfbdtawkWZt9rZZ1vH5HLevxx2tROTzsZSXJ/ff3sjamx7Wsr14e17J2dmpRSbrtfubzXtb1672s5udKkjNnalGLUe/aX7n8bC0r6+u9rCQZjXpZ+/u1qBuvOFvLOnWqFpUkuXmzl7V1qtcO37jZ639vnTyqZSXJUVZrWcXbLKcnvXHF8XSjlpUk43nvGmleH6spXvuTSS8rSWazpcxqXvvVvnfS7ac2s4p9q+P0+sPNdjFJ9ma9tnHji79Vyzp40ztqWWu7xTFMUh0L5uLFXlbzczXHZm1Xr/ayzp3rZTU/V9Lt70ynS5l1NFqrZSXJ6qTYv2r2UUe95/R4dlDLStLtNzbvs6LmnG3SbYrPbvb6xItJ7z5buX6tlpUke5PTtazm1EQzqzn/lyQbkyWdTyo+O6/t9+7pJDk9LT4/m8+z4nO6/TxrdkGqc4BLOmebpNteNTfWbG72stqa32Pz+ijOJx0cdvdSrk16+66qHazis7M5fk+6z7NlXRNvzxUczXt9nub1sZYl7Q+3N9s2b7Tt7VpUs6/f7qKuzovXfnNNq5lV3mv7mc/3ntX33VeLWtbpnSTVYzHV/frLuk8u6W9fa1lJb37neN4dC453i2sWxWfMYrN3Hqytuae9uV9/me+zpmXtyrX3UtbPhJVcO+zt4SkOO5N025Cl3S9U3tO+SK8trl4fS6z5/Kxej805wPJ8dPU+my3pPpcltqx94nY3rtn/braNzeuj2QxX9+Ql3faqefE3J4nba3XNd5E0z+A0G6v2IkJzvrG4z7z5NbaP1TWbq2Xdbljd39XWbkNKFtPuubrmPEhzf2P12i8PLJrrudUxTHFev/l+hKTbXJ3eXtL3AJZV3w/SXH9vvy+vqbiXcrHdO3e5stt7h257HnVv3u3ztGys99rho1l3zrb5+ph7z/Su/aNpb7/Q6qg7Prtyvfc8O5srtaylPlfX7Dgu6bm6ZZ0rSPrzBS3NafakuwTfrIewN+o9z5rv8d877L5HYOOw9zxbnOm9h3vlqSdrWW17O/fWsprz+mdnX61l7W12a8U0H9XNbuPHP97Land3ms/Ov/W3elm/1XutbX1K7s1vHvbvP/DAa/OHf/jMX/W/nrl169Zrh01/8SznzjkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlxAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYApIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGAKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIEpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBgCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICBKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGduLWrVsv9r8BWAInTpz4SpLzL/zv51/96nzld393sNwf/ek7BvvbL/Se99SikiTzeS/rXfc8W8v6vvfdWcv6xV+sRSVJHn+8l/Vj25+pZZ343l+rZb3tbf9nLStJPvvZb9Wybn3i39eyTvzId9eyfu/3/odaVpI88kgv61c/2Gsbf+HRXtv4T99/XMtKkiefHtey7j3ztVrWZ57q9UEeenP3N3v2au83u/NT/7qW9fpf/0e1rF/rPTqTJI891sv6wIXfqmX9xo131LLaff0nnuhlPfjGRS3rS19eqWW94bt7nytJ9vZ7n21jdq2W9ezsdC3rzu2jWlaS7M1Wa1kb15+pZf0vn/y2qZfBPPxwLSpJcvlyL+vB9d+vZX3m+utrWQ+9sXef3Xi+d48lyalTvayV3d64YrHZG1eszLrtcHVyc0ktpmvVvJXLvXmQG9/Rmwe5/fZaVN14t9dvPFrv9RtXU2yvZrNeVpKv7m7Usq5erUVlMullPXBurxeW5Nn93m/WfHQ+91wv6w3feaUXlmTtwtla1ic/WYuq/mY/svtLvbAkP3vjfbWsd/SmG3PyZC/r/Ha3bfzCxV7beO5cLSqjUS9rbd79zfbS+8021nvzttU522l3re5nP9Rbq3vve2tReeUre1lb/+9/7YUl+dKt76llve51tajqkGkj3bbxaNJrG59/vhZVnQdpPjuT8vxmcaC7SO951va5z/WyHnprrw9yPO/9ZuOrvTnbJPnMpd687YULtaic3iz25YoTPEfprtWt7vfmo7O93csqarf5K4cHtazjSXdNq2V3t5vXvPRv3uxlbZ3s9eOae4WSZH29l3V42Muqzl01v8Qk2d+vRTXXmO480+vvHKc3b5Uk4/lytiHTaS2qum6cJN/xHb2sf987olXdS9nectW8Hi9d6mU1+1bNPRNJMp71+vp7815fv9ktKG8XyuqkN3fVHHtW+6jT7tmRZr/xYNTrNzbb/JWUf7Oi5n3W7Bc07+mkuwZ/bbc3jjk96p1DqI+pi4uDB4e9+6z6jCk+X5Lk968u557lM2d6Wa/f7t3TR9Pe2aK25ljw9XcV9xW0B/DNTRrFgW5z/b39ky3rWLB57vLGrW7b+PKXV+NqNkbLu2483u9djweT3vVY7aOWJ8qu7PbWYs6eWc65ifbek2XdW9DsGHzh6W7b+NRTvayfemf3zGDLlfTOJibdedumpe6DjHrPmOo8WXG/UHNtJEnWRr1nzPGo198ZpzfP/tXL3f1CzW7q69eLz7Pi/M5iu/dukKS7zrSk02T1uatm3ur14rmYnZ1a1NGsOz5bHS3nuZjmO+y+/vVaVJLuXsqtP32ylnV84d5aVvMdK813gyTd51lzL3a1I1def99b7527bI6pm23+8bQ7Fmxe+82xYLMf195ruzEv7rtqNsTFPV7NuaSGN7zhtbl48a981/czt27dem3739OyXL8iAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEuQApIAAAAAAAAAAP8fe/cfI+l934f9/SyHo+Fqb723WvIuhyt7oUiaolSFdiiLFQxDVlRHaanaSuUfbY0GSQM4Fm3Dhg3UTYM6MVqgQhs7ThxXttXCbR3EaRxUBazETV3HLRRJtWlHUEhKlQmVlg5nUjwv18v1crQc7vQPyS1K8rikxOd95NzrBRAE7lnM+5mZ58f31zMfAAAAAAAAAAAAAAAAAAAAAAAAAICRKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDIFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABGpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMgUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmQKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACNTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgZApIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAkSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAyBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDIFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGJkCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGQKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACMTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJEpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMgUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAyBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiZApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBkCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICRDcvl8mrvA7AChmF4MMmdz/73O7/2a/PgRz86Wu4//vj2aK/9bG96Uy0qSTKf97JuvbWX9cEP9rLuvbeXlSR7e72shx/uZX3rtz5Uy/qpn3rOZWRUb31rL+vBB3tZH/lIL+u7v7uXlSTvuHu/lnU026xlPfFELSo33tjLSpK1g9X8zqaT41pW3WJRizrKtJb1oz9ai8qP/EgvK+m2Gw8Oelmf+lQv6+1v72UlyfXX97Imk15W0+Zitxs4m3XzSo5n67Wstb3yd7axUYs6nvTuZ7/yK7WovPOdvayk2gTJU0/1sr74xV7Wzk4va33WbQ8fLdZqWc17Z7Nt1b6VNc/p5ntbmx/Wsg7Tu08nyfqi13+/dNDrv589W4uqjg8n3WO/eU5vbhTvMc0LcZLDSe/Yb44VbG8Vv7NHH+1lJTk+e66WtZbe53icXttq7dFLtawk+W9/tfed/aV7v1DLOtq6qZY1feB3allJ8rmdr69l3bz4bC2r2kEra87FNPtn1bGrdgetmLe717vHbG8c1bKqDeIkv/7xXn/wG7+xFtU9pxfF4yPJY0/0xojPDL02SPV+Vj7P9ue976z51ra2elnNPkySah++2d5pDk00j4+ke+xPD4ptueIcZH2yv/mlNQdTi5/j/qS3pr3drWiONzZPs+b7Wp9026jNdXnNtZTNeeNyE7V62Z8uenOeR5NeH3c67813JulesFbU4bx3Tifda3F1rOB08R7TbqNevlyL2p305mJW+fLRbBc89njvGnLmxuI4yAo3QpptuWZ7p7kWu63ZfV/lIZfmWOqq9plW9ZmYZHWvV83nSZPVXZNan4tpKl5EmvOCq7z+tfrstmvjy+KTj/S+swsXalHV58HO3LCaz1ck3XmmZlZ1Lqbcf28+X1R9RqvZ3mlODCar+8BPUfO57VVWXUtZ7sA355mqz1Ov6DmddPtnzcvwNL3zrPkZJt3Ten2+mmsAP/np1f3O7rxjNdtyjz3Znfc5fbqXVX2eo9nWbz/cX1yQ3Zz3aXaZVnl59OZkNcc2H3+8FpUkeeyxXlZzbLOpfZ5Vf9ei+Uxp0SqPgzR/p6l58B8uut/Zqg43NucF2239M8/0fmflaKf3GyvTy733tb/Re1/t37VtPn/WXJdXvea3H6wrrtE43ujNHTfnEHYPuvfO7VnveNxf9O4xq7xuszoend7xsTvvHR+r9jsCd931xnzqU89bH+mh5XL5xnHTr57uk3YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1yAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABGpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMgUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmQKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACNTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgZApIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAkSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAyBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDIFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGJkCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGQKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACMTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJEpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMgUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAyBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiZApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBkCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICRKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDIFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABGNrnaOwCstsXyujz29PZor3/+/Ggv/RyT8hXz9o1LvbD5Vi3q3nvXa1kbG7WoJMnZs72sRx/tZb3rXXfWst7+9lpUku415LbbelmvfW0v6557ellJcmlvs5Z1tngN+ef/vJd19929rC/pfWfN6/4v/MJaLevbvq0WlSQ5OJjWsn7t12pR+cmf/J9qWVtb76llJd02yHd9Vy+reez/9E/3spJkPu9l/flvO65lfe5i79q42Bivn/l8tma9rLX5YS+s6HDW/c7W975Qy9qb3FTLunChFpUnn+xlJcmZ00e1rM3FQS3r0jPdY79l/6B3zU+SzVnv+Mhe7/jIZDWPjyRZP+hdhw/Tuw73RjaTWbH9kSQpHvqf/nQva2enl9X+zprn2Ucf7p1nb7t7Ucs6nPTGrZJk0Xtr1ePxcN5rF6yXJ37WDvZrWe3jseXJ685V8+66qxj28MO1qOmbiid1c7AxyWuuK4btFN9b80LcHGxMty335vO7tayj4njj9HJxLUiSS+ldi88tPlfLOt66uZa1Vj7P/uE/7GW94+J/3wt717t6Wc0PMclv7NxXy/rONxQXDDU71R/5SC8ryeSed9SyNie9eZ/j6uhVWbF9dVAcJ9va6mU131dSHtdvDro0ld/XY0/01gudPt0bb5xOemsmNotjSek2UTMtjss15yGr16rygwjT9I79pulBb6zgIN253O1Fb96n2QiZpneePXSxO87eXMOznuJ6smLDcbLVaxMkyfGk1945daoWVW03HqX3GSbJZKd3jGwveter5rFYV7yG3HBD8bp/+XIt6nCje21cL/aZmv2zo+I42bw85tKchmx2Y5rHx3G661+b9+rm82DbW6v7nTWH5R56pHe9unOrN099fLa7XmireL1qPtt/bqe4lnLRbaPOZr285vzI5mxFF4mmPLw5Wc15wc3y+tfmb2g0752nT/eyMul9Z+WfxaleQprn2XqzUVCe91kvPnPcXHtytOi19Sez7pqa6nPizeOxmLW3V4tK0v0Ym9fhaXFs82in2xdcn/TG9Q/nvT7MevFYbPcFm03iteK8z37x+GiuR02S4+r9s/1Adceb3tTNa98/a4o3z+ZUf9LtUz/xRC/rzKnyAsei6vPUxfVC0xTXnqzws/1NzWv+Y4/1spLud7b5wEdrWbt3vK2WVewKJkkef7yX9dZ/rXiAFAcLmp9hktxwQy9rc6PXlmuuLWivF2qqDn8Xn92+8cbyc5fFWg/VdVfF9SDN6ffj8u8AbhbHrnJQ7J81f4+hPFe3u+j1Y7ZqSal+Z9vlSfHjSe+6v9irRa209XnvmcHmNaQ5N1L8KbQkye23jtsGGYZRX/4Vq7zKHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAODao4AkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMgUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmQKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACNTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgZApIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAkSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAyBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDIFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGJkCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGQKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACMTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJEpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMgUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAyBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiZApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBkCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICRKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDIFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABGpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMgUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAY2eRq7wCw2ibXLXPm9NFor//FL05He+1nm89rUUmS4wvnallri/G+o2dbLGpRuXy5l9X22tf2sr7/+3tZZ870spJkb6+X9cgjvazbbutlPflkLytJzp097oUVD5Bbb92uZZ09W4tK0r1/PvVUL+vee3tZW1u9rKR7jHzoQ72sd7/7PbWsd76zFpUk2dnpZf2tv9XL+sAHelnnz/eykuTOyWdqWbt7t9eybj7fu0/vH6zVspJk7fIXalnHOzfVspr9s/VZsR2XJNmoJU2Kn2Pzmn/m1GEvLMnhYr2WtZj02t/VPszBQS+reQFJksWsFnW00Ts+NoozNGvz7jmdWe87W5/0xjYz6b2v5phtkhxvbNaybr21FlVVPRaTHG312o133VWLSia9i+P6wW4tK0kOZ717THNM7umne1nrp7rLG45nvTbqenrtxsN5r0994421qCTJ6dPFsPuLWcW21eGk1yZIkhvKXYuaZp+peHwk5bHUjd74znTSuw7vznprQZLk7FYx7KAXtla8dzb7S0l3jUb+79f1spqN1G/+5l5Wku/cutQLa66FevTRXla149m9VR9v9PoVTc1+RZIsFr11os01Gs21a8WmVZJk96D3nW0Xv7Sj9N5Xc9on6fbhu+PfvfGko1m33dg03euNpW4WL1jNc7r94FbzPGt+jtPiOMh2e53LXvEoaTaIi33BOy90x8mamvMVzZZ+e+lJcwxwsSh+krPVfTy4uW7z0qI3/95cT3bUPBaTTIvz/YvicGNzfUb7lD4uXvmb1/3porhWrnifTpJpca3L5XlxLeVG93pVVbw2FqOqbf218kDZpPg8x513NNeZlweJi5rTkOd2mmuWm2MFvaik+501n5U9Ks5nVds7SRbNsdRJr13QXHbVbHsnyfasd4x0x66K987ixWpW7lc0bzHbaa7X3+pFlQc3d+e9Y6Q5PzItDvDsHnTPs+Z53Rwna649KS+Prj4Tdjzpta2aDeL6bEXzNxIW+72wWe9Ea14/2rpr15q/hVb+0prt1OKFv/lbNdUx23Jecx3xenp93Hmx7Z101yxXj8fi7zEcTcpr9YttkOZ7m1bPs1pUkmRz1mzrF4/HFe0LJt3f1srBhWJYzy3nu797csvZ4sWx+BDO0U7vOeBTp2pRSbrjILt7vf5Z83q1PSmOFSTJvHeeHW/11gvtF38HcFJug6wXG+DNdaLNtdjNVe3VOcik2kFrPus2LTb2q+Ps6c9ZrKT2QFlRs5/bPBabdR6SZPPGrW5gycVHellf8zW9rGT8NshyOerLv2Kt8Ip6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgFcGBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDIFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGJkCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGQKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACMTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJEpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMgUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAyBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiZApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBkCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICRKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDIFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABGpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMgUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmQKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACNTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgZApIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAkSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAyBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARja52jsArLbDp4Z89P7paK//iU+M9tLP8Y3f2MtKksWil3Xx4njf0bP91m/VonLbbb2sJHnta3tZ739/L+uRR3pZ997by0qS++7rZZ0/38v65V/uZbWvjQ8+2Kt/ftdd27WsCxdqUZlOjnthSaaTeS/shvVa1I031qKylu53lr29WtR83jvP3vveWlQODnpZSfK2C5dqWX/2z56rZZ06VYvKvHipSpKjN91ey9ouXvcP57379MZGLSpJcjS7qZY1PdivZT3x1GYt6/Tp3vGRJPNFr13wwAO1qMxmvayDg95nmCS331ps8xQHXT77SG/M5ZYLvYvjY493z+kzG0e1rElx1qTY9M5s1j2n12e972z3oHeebW3VorJI730lyROP97JuPts7Po4nxc/xoNuxuFw89s/t9L6z5vT10UZvXCJJ/uW/6GW99S29ttX+QbFdUO7AP/5k7/555obegNKTxb7g+qw7tvnBD/aOx/ftXKxlHd/ztlrW+m/801pWkvz65FtqWe+4pxbV7VhcvtzLSrK10xsny17v2thsF7THNteK443NwavmeHR7DuF1ryuGffqLxbCis2ercbvpXUO2zxcHiZvaF8fied1cA9jMatvcWM05hO2tXrvxON1x/WaTuLlIY1p8Y9sHe7WsJHns6ZtrWWdO16KqjbnqqH71JEv3Xl18b4tyW7+peb2aNtc3Nts77cZVsU99NOmNfS+K89Tt8ehVbYAfpvedtcdcJpNum7jlcNFrhdTPs+Iija3iKb271zsWm+sNk+66zeY1ZDu7vbDyOFnzGtLUPBZn5e5Zc07r3OywlnU4X912Y3NdzWZ684KHaa49Wc22d5IcLXrHR3OsoP1cXXNt735x3WZTe7hxfbKaa1KnzXH9cmN/muLa7+Jo+3Teu3fuLnr3ziR5+ule++qZvVpUzi2K6zbP9+bOms9yJMkNN/SyJrNeH2ZSbDa2WwTbW8V+zKOP1qL2N3q/WdBsMybdNnGzL3hUvJ9124zd589WdV3vWrtjUXS80Tv2m78vVF2Tl1QH9re2is9TNycsyn3B7nxub5ysOdX/1FO9rCR55ple1rnJF2pZR1vF55jKmudZM2tV12ck3bHU6phccY1X8ycpk+6ceHNNarNZsLPTy0q6/dzqGo1iG2R/3h29ms2K4/obvQ+yeR2etrvUxYbBKj83VVXsyKzNe+uFmr+H1v4d7u48de/euV9cL9Qcu2qu6026TZDm/aw5GbO2V1zXm+TyQW/Os1nDotse7q4BXCvmnTvb66A12zvV+ax05yGnB71ryC0XtmpZzd/gSca/xwxZjvr6r1Qr3KsBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeGVQQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgZApIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAkSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAyBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDIFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGJkCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGQKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACMTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJEpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMgUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAyBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiZApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBkCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICRKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDIFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABGpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMgUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmQKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACNTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgZMNyubza+wCsgGEYHkxy57P//Q1vuDP33//gaLl7e6O99HNcd10vK0meeaaXtbPTy1osellPPtnLSpLrr+9l3X9/L6vp1lu7ec1jv+ngoJe1tdXLSpL1xX4vrHjB2p9s17I2J4e1rCQ5mqzXsqbz4vHRNJl082azWtTvfGKtltW8x6zwV5aLF3tZzfv0+uy4F5Z0G8XzeS1qP5u1rPb97NJe7362qv2ztlW9Njbb3+3jY3vWO693571zemOjFtW85Gcz3bb38UbvHtPU/M7abdRVfW/rk6Na1vFkWstKuuNJq3ptbB4fSbI/7x0jze9slduo00mv73mc3phL09q82xdsHpCHk157pzl/dubG7pjL5y72jv2bF5+tZR2evaWWtT7frWUlyW568yPbW8XjcVUbxOW85v1sbVFsy61wB606L7jCbau1FK9XKzrx0zwWk/5p3dI8Fo8Wq9mHSbrXq+bn2HxfSfda3GzKVftnp7tjV0fpjV1ND4r9mOYkZDMr6Q7Mregg4GF6bZD24VFtoxaPj+a1qn3YN4+R5nubLnpjxO1+RXX964pO/DTP6VW2yudZ83q1nt7neDzrfo5NK7rUtnoZro59J9XFJ8dbvTmmprWD8jMxzcHN5vGxc1Mtq9pfSnI4742TNe9nVeVB/cNFr51aHW88VTw+2hMxzX5Mc351hdv6qzx33NJugzTXyjX7FdU17c1n7ZNqR2ZV2zurvI6h+RxC9Vmm4nG/f9C9v2zOVnStXPNgLLdRm2OAq7qWst2OW9X5s+okZPNH5ZLue7t8uZfVHJBe4TXtK/1DXkXN+dzq8/bNtlVZdQ3giq61bWveYs7tFI/9FR2zTbrHfrPv2WxaVdcQJyu77mplFxy2NZ9JL65Zbv+GRnN+tTonvqoPn6Xbbmx+jM31IM25kaR7Xq/qs0VHG921a9Os5u9drew4atK9YK1wn6mlfZuuzq9urOaamva6zZVdL9T8HJsHfrKy8/3V8ehy/31Vn4tZ5d/AHPsYeePdd+ehT33q+TY9tFwu3zhq+FW0mnccAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgFcQBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDIFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGJkCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGQKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACMTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJEpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMgUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAyBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiZApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBkCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICRKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDIFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABGpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMgUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmQKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACNTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgZApIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAkSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAyBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARja52jsArLZnnkn29sZ7/euuG++1n+3M6aNeWJIsFsWsXtTBfL2WdepULSpJMp/3sjY2elnnz/eytrZ6WUmyOTmsZe0Wj/3msTgptyb3F5u1rL2DWlT1nL500DsWk+TcVu88++QjvePjjjtqUbl4sZeVJLdcOK5l/fzP16Ly/vf3su6/v5eVJN/05IdrWR/5w3+rlnXXXbWoLBZrvbAkb965XMs6PnuulrV5sF/LOp71rvlJsrPTy2p2BddnvWv+Ufk8a7r5fO9zzEGvkbo/6Z5nzc7FbFaLqvbPmu8rk2InJsnavNev6H5p27Wo5ttKks2N3rXxOL17zHGmtaziJT9J9ztrms97x8dsq3d8JN1xufY1pKXZ9k6SyUbveFzb261lHRbvZ+vlL20/vTbxrHhOnz7dy2pfQG4+W/wgF2drUdUm6lbvnE6SSbnNU7PKN+rie1u73BtHzdneOZ3m+0qqAwbTvUu1rObigrXqoEuST3+6l/Xww72s4uKTaXMyN8lRenPw00c+U8uqXj+ai5OS6sDL8UavXzGd9MZ3DotjLkl3TivF8cb6mtSi6bw3d7ybXj9mO8X5irLjSW98c63ZZyqOJ62neE43FzcmOdronWfT6vHRi+rey7qa666mxTZq/WG74kLi5vxq85o/Tfk8W9EJtKNJsY/bvHcmWRTn+5vjqM21Bc1nHpLuMTLd6H1n3T51dx3DensstWStuT66OJaUJGuL3nl2vHNTLau5tGDa7Fh8ObFlf9FrF1TXrpXXnjS7uddf38taZYfFeZ/mJWRabDhOdrrPrzZV7zHFeZ9V1myiVr+zVV1zlWR9saLt73azsajalrvcG5PbLf6mRXvMZX/e61dU31vxnF4rj0c3xyYOm8+UrvBc3XS+mmuTmlMj6+0foGo29ptr5cb84b9nqV4/kqxPemOb+7Pe2Obmorc2qTkvmCTTg96zbovis27VNVfNZ+2TTJsPuxVvMovi+N+KTp19SfV3T3rndHu9UPMZ+PZvRbYcl5+FbD67XVW8YB2V1zE0TS8/Wsuab9xcy2r/hkaxS531g95znvtbve+srdj1zM1ni2sOizfP/jrz4tre4tqk5oB0vW110Oszrc33alnT4hjgpb3uOEizP7g9793PJmd7n2Pz/tKeq2vWQ0h6B2N1DqE85tI8HqvTI825kfZAWfGAnM1618bDRa9/tr7CC12a8++z4lxu8zdSk+avMVxbfK4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBkCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICRKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDIFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABGpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMgUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmQKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACNTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgZApIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAkSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAyBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDIFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGJkCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGQKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACMTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJEpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMgUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAyBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiZApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBkCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjGxytXcAWG2T4Zmcm+2O9vqHs+3RXvs5WYtpLStJFsW8zezXsra2alE5OOhlJcn2pPc57uxs1rImK9xaOJ6t17Lme7WonD/fy5pevtQLSzJdLGpZT73m5lrWfF6Lys5OLytJjtI7z5rHfvPaePZsL6vt27+9l7Wx0cu6555eVpJk7y21qLsu16Jy59nx+hHP0W44znoH5FqOa1nNE21tcVTLSpJmb3AyK6Y1GyGTXpsg6R4jx5Ped7a36PUFt7eK148kjz3eHXdpueGGXtZ07wu1rOOdm2pZSXKw6F1DNme1qGq/Yn3WPaf3D9ZqWc22frNttZluG/WoeI+ZTnqf46x4Tq/tFfswSSYbvfmRpmmK7bhm2zvdY6Q5f1bVvOgn2Wz2PZsNg729Xlb5O3vsid55feONvayN4uFRHUv6cmJNcwywOJ91VG4TNNty1WtI8Ts73Oj2qdfnvTbI/sa5WtZmsZ97OC9eq5Iszt9Zy9psTrA2O2jleZ/pVvG9FRde7U5616vtchvkeKM3DtKcrzgqzmjV15M157SK61z258V+Rbd7lsef6r2306drUdV1UPPyMobqnEVxMeXxVq/PVF3HUD6pp4vDWlbzPKsq9juTbrugqtgmWGv2YZIcF8fJmofjtNluLJ9n1ZtnMavb1O+mzapxvbCnnqpF1fsVVcVrSPN5wXr/vRi4dtB7hu9w0htLSnMIJMmsuG6iuWZi2nyAdaXvZz3NuZjmcZ90x3iazzdnUuwztdv6xT71+qS4Vq689ruqOF4wLY4XHC1618ZJce4sSdaLc4PNz7E6n1WeE2/Or6aY1fzKysON3XWAzXt18UcSNprjqMX181/Ka3Y+ewNKzX7Fevmcbl5Emt3O5rG/f9DtC24Wv7PqY+LFA6Q5d5Yka8X7WfOZ9BTXTLTHNpuav813VByPri7JSzItTjQ1x1Gb8xX1cbJmXvHe+eQTtaj6XN25jdUcI26e0+3TbHNRfOZ40msXrPJ6w+Y8ZLWfW7yfNcfZ247P93639OBiLaq+Xmh7ozhWVhxq39xY0bmRdH9jvNmnbo6zt59f7bZTe99Z87ex16prk9KdaCpe+B97vHfst3/Tufp80V5vkKc5nrSd4u94zbsd+KNZ8Xfe5r3+2XrzBjPvduA3Nnp9z7Xid9bUrAOSJGnOxazmMGqSbv+9eeyv6nX4sDxOtj72Aunj9m+gvTJ0e4cAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1yAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABGpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMgUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmQKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACNTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgZApIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAkSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADCyydXeAWgZhuE1SW5Pcj7JqSTrSQ6TPJnkYpL/a7lcHl29PQQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBVKSDJShuG4Z4k35bkzyV5Y5LrXuDPnxmG4cEk/zjJ/7xcLj8+/h4CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwLVi72jvAq88wDKeHYXh0GIbli/jvF67SPn7XMAy/neRjSf6jJG/OCxePzJe3vznJjyb52DAM9w/D8J3j7ikAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADXAgUk+Ur8zSRnrvZOPJ9hGO4YhuF/T/L3k3z9V/lyfzrJLw3D8M+GYfjar37vAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuFYpIMlLMgzDO5L8xau9H89nGIY/n+S3knzTy/zSb09y/zAM73mZXxcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBrhAKSvGjDMNyQ5Oeu9n48n2EY7kvyy0k2RorYSPKPhmF430ivDwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwApTQJKX4m8kef3V3olnG4bhLyT5O0mGsaOS/PQwDP/ByDkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACsGAUkeVGGYfi6JD90tffj2YZh+IYkP58XVzzyo0m+L8nXJ9lOcv2X/393kh9I8n++mMgkPz8Mw1u+oh0GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgmjS52jvAK98wDNcl+W/yCjtehmHYTPJL+VIhyBfyu0m+d7lc/m/Ps+2JJL/95f/+zjAM35LkZ5K8/gVeb5rkHwzDcNdyudx/6XsOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAtWbtau8Arwo/nOTrrrDts80deZYfT/InT/ibX0vylisUj3yO5XL5T5PcneSfnfCnfzLJX38xrwkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKSPKChmF4fa5cKPGjSX6xtzf/n2EY7kxy3wl/9rEk37pcLv/wpbz2crncS/LuJL95wp9+/zAMb3gprw0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMC1SQFJTvKzSW54nn9/Osn3JFl2d+f/9WNJJi+wfTfJdy6Xy8Ov5MWXy+UfJfmOJHsv8GeTJP/pV/L6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXFsUkOSKhmH4S0n+zBU2/83lcvlAc3/+2DAMtyT5d074s7+2XC4//9XkLJfL38uXClW+kG8fhuHCV5MDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADA6lNAkuc1DMOZJP/VFTZ/NsmPF3fn2e5Lct0LbP/dJD/3MmX9TL70fq/kui/vDwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFyRApJcyd9OcvoK2963XC6fau7MHxuG4bok/+4Jf/aTy+XymZcjb7lcLvKlz+KF/HvDMDiXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuCJF73iOYRjeneQ7rrD5HyyXy/+luT/P8o4kf+IFts+T/OLLnPnfJTl6ge3nkrz9Zc4EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABghSggyf/PMAynkvzMFTbvJfnB2s48v3efsP3Dy+XyyZczcLlc7iX5Jyf82Un7BQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwDVscrV3gFec/yLJ+Sts+4+Xy+WjzZ15Hu88YfuHR8r9cJJvfYHt/8ZIua96y7XrcrSxPdrrP3pxtJd+jrNne1ltn9vbrGUtLteiMinf5SY7vc/xAx+oRWVjo5f1rnf1spLkTW/qZf3qr/aybr21mXWuF5bk3PnjWtYzxVbPbNbLWix6We285vVqb6+X1b6f7R+s1bLuuKMWlU98opfVbjeePXtTLet1y1pU9ifj9SOebeN8LytJ5vNe1vrDn6llfSa317JuP1v8EJPsLnpt/e3ZYS3roUfWa1nNa36SXHp0Wstqtne++7t7WR/6UK9NkCS//du9rObx+Pf+Xi/rr/yVXpvg4QdqUUm6/ffHHu9dG8+cPqpl7e71rotJsr2xmu9te6N30T+c9NofSbK+6LVBfueB1WyD7Kbbr9g+2K1lPfZ0772dOdU7z9bagy4P9G6gj+x8Uy3rzjt6Y7bNcask2dzoHSOfu9h7b1tbvXN6Uh6Pfve7e1l/+S/3si5c6GV9y/lP98KS/Ge/cGct64d/uNe+euaZWlTOHXyuF5bkk3s317IuXOhdrxbF4cbtrd69M0ku7fU+x+b8yOG8d+9cn/T6uEnytz/Y6+e+973F9UJ7tajc3AxL8tFP986zt13oNbCeLs4L5nJxQVmS+UZvLPXR4nxFs924lu797HDRG0968slaVE6f7mWtLbr3sx/6od6x/33fV4vKPff0sjYPLvXCkrz/f+itA/ze7+3dO2fFsYlpcbzxMw93x8luv9DLmk5Wc7zx8kF3ru7cxn4ta1pcAHuUXpvgN36tFpUk+VN/qpd16lQva1ocdPnkw73jI+muY6iuNyyOg+zPu9fG5jrzo0XvHnPmVG+uP4v2Q1rFvIODWlRzDnJ3r9tuXC+eZ/vpjW1uPvCbtaxL57+hlpUk53aK1/3iswGbj/b61Ec73efqpvNeW796ns16x+JxVrcNknnvHnM86X2O7TVe68Xx78ce732OzTXLh4vuebZePEaO02tfNcfJmvPvX9LLaz4HfG7vkVrW4YXemqskKT4CX31Ga/3gC7WsX/94b446SS5c6J1nFy/2rvvflP+jlvXohd5a7I2N7r3z8uVeXvN3T9YXvf5SFs0rY3csdXOjuB6keM1vPzpyVOx7Nu+dzd/FqSseJO11Vy2TSbtf0dN8znNWvF5Vr/lJDov3s+Zlf7LROz7W9nrPkybJcfO9Fa+Nf/AHtahcf30vK0m2N4o36w99qBZ18M7vqGU1f+8nSbUxt75XXJNanByZlp/3afZj1ovrrqrX/PKa9qa1ee8asrXVWyvXnK9IksxX9IdLi4sAJ7PuWsrmx9g8z5qTTJcX3bUn99/fy7r77l7Wxkbvc5zv1aKSJJ//fC/rrW/ojbW/5z29Nkjzt0GS5KD4/MgP/P1/v5b1i3/xY7Ws9763t97w4x+pRSVJ/s0nej9MufvnesdH8zc0Pluco06SW2a9PvVDe7372eteV4vKjeU5prWD3v3slz7Uu58159/vuac777P28MO1rH/x1JtrWbfd1uufNZ89S5L1sRvFx6s5p3qS1Z1x5SUbhuFtSb73Cps/luRni7vzHMMw/Ikkbzjhz8Z6TPt/PWH7G4dhWOHyggAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHw1FJAkSTIMwzTJB5MMz7N5keR7lsvlsrtXz/ENJ2z//HK5/PwYwcvl8pEkv3/Cn71ljGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABe/RSQ5I/9J0necIVtP7FcLv9lc2eu4OtP2P47I+fff8L2rxs5HwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgFcpBSTJMAx3JvnRK2x+JMnf6O3NC7rrhO2fHDn/pNdXQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDnpYDkNW4YhrUkH0wyvcKfvG+5XB4Wd+mF3H7C9t8dOf/hE7bfNnI+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAr1IKSHJfkn/9Ctv+x+Vy+U+aO3MlwzAMSS6c8GcnFXj8ap30+hdGzgcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOBVSgHJa9gwDP9Kkv/8Cpv/MMkP9vbmRGeSzE74m0sj78NJr//aYRhuGnkfAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeBVSQPLa9jNJTl1h219dLpe/39yZE5x7EX/z6Mj78GJe/8XsJwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANcYBSSvUcMwfFeSe6+w+eNJPlDcnRfjdSds318ul18ccweWy+VhkoMT/uyk/QQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOAapIDkNWgYhu0kP3WFzYsk37NcLo+Lu/RibJ+wfb+yFyfnnLSfAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXIMmV3sHuCp+IslNV9j2k8vl8pPNnXmRTp+w/cnKXpyc84orIDkMw31J3leIen0hAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4FVJAclrzDAM70zyF66w+feS/PXe3rwksxO2/1FlL5KDE7aftJ9Xw41J7rzaOwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAtW7vaO0DPMAzrSX72Bf7kvuVyedjan5doesL2RWUvTs45aT8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC4BikgeW358SS3XGHbLy+Xyw83d+YlUkASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAVy0FJK8RwzD86SQ/eIXN+0l+oLc3X5GTjtVnKntxcs51lb0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgVUUByWvAMAyTJB/MlYsb/tXlcvn7xV36SixO2D6p7MXJOU9X9gIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBXlVbRPa6uH0ly1xW2/WaS/7q3K1+xoxO2t47l60/YftJ+Xg2PJ3mokPP6JK8p5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALzqKCC54oZhuDXJj11h8yLJ9yyXy+PiLn2lnj5h+7SyF6/CApLL5fLvJvm7Y+cMw/BgkjvHzgEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHg1WrvaO8Dofi7J7Arbfmq5XH6iuC9fjYMTtm9U9iI5dcL2k/YTAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAa5ACkitsGIb/MMk3X2Hz7yX5seLufLV2T9i+WdmLk3NO2k8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACuQQpIrqhhGM4k+S9f4E++b7lc/lFrf14Gf3DC9q3GTiT5mhO2n7SfAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXIMUkFxdP53k9BW2/aPlcvkrzZ15GVw+YftrhmHYGnMHhmHYTjI94c8UkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOA5FJBcQcMw/NtJ3nuFzftJfqC4Oy+Xz72Ivzkz8j68mNd/MfsJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADANUYBydX0Ey+w7a8tl8tLtT15mSyXy4Mkf3DCn/2rI+/GhRO2f2G5XP7RyPsAAAAAAAAAAAAAAAAAAPD/sHd/sZLed3nAnzkeT8bD7GR8etbndFmsrbU4xjXBCYEsqVUhakpAkaqiqqWI/qFCFKkqSFTccdNetXe0EqitaAUtrXqRoqhCbUlzQVtAaaEQtWkbpSa4xrLW9rI+PR5OhpNhphfJVQheE/t91jv+fCTf5GzOc96Z9/29v3/v+wUAAAAAAAAAAAAAAADgHjS+238Agzj6A/73syS/OxqNvu9NzHrvHX7+1a8j7z/udrv/8zqyfjPJH3mtrCQffR2/58t1/Q4//80BswEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALiHKSD59rJI8o/KmR/4wn+v5XuTvJ4Ckv8zyfte4+fver1/1JfpTr//fw6cDwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwD1KAUnuJb+W5K+8xs/fM3D+e+/w818fOP+eNBol4wFbmuVyuN/9xU5Pe1lJcuXoopb12XdMalknJ7Wo3LrVy0qSWc5rWUdHs1rWhz5Uixq0vfhSFrc+U8s6OnqklvUnr/aO63zZO64kySc/WYtaXn93LWu2OatlZTrvZSXJel0M6zUiy2Xv3rnPmv2rZh/kvvt6WUn3Mrv//l7W4vS5Xti0eIIkSYptyNFRLerqtBZVv58tm2Gb3v3s8ce2taxtDmpZSXe+4MMf7mV93/f1sj73uV5Wkjz1VC/rIx/pZf3AD/Symn2Cd1+93QtLcrE5rGUdP9ibk2tOhByOi+POpHo/q47PTle1qPG8d94nye1Vb76xOT5rzje25zZvF9vGS5dqUcm0N7A4W3X7qIsbN2pZ85u1qJyve5/jZlOLSpK8+HLv2B4+6fVBzta9e2fxkk6SPP10L+v7b/z3WtZzy956RTbdL+17vqeXdfxLP9sLK7b51UmQJO8utlfVge602JlrLp0lubIshhXHgrPid7ZtzukneeyxXtaV8Uu1rIujh2pZWffWRpLkA1eLbeMvfqoWdfxU8XMcd7+z2ao3V/bItd6aVnMtpjleSpLjy701rdm4N/hsjs8m8+7k1Qc/2Mv6wPi/1rLO199Yy+rN2H7ej/xIL+vgYx/thTUXIde99uPRq+UJ6eKxZd67dxajslj3+t5Jsp33+t8H6d2nJ8WsGzfKawjT/Vynbs6DvPtaeU38Zm/teNZssIpr4ovi3sYkSfF2ttkU+/rtxZg9dTFd1LImm16bf7gs9xuffb4WNb9WfJbp6tVaVPN50iTVhy8XzftZcXNSs4/attgU94mOl7Wo9t6TpuaKVnMs2H4O4aC4hvDAA70+yHmxj9p81j5JMu71iQ+KfbnmGsIi5TF1s1+wLLYhy2u1qOoz6Ul1T1l1h0Zx31V5i1ceWfb6ctNp8bmHVa+v39y69vC0u4awvF5cQyj2rc7Hvb7VbNV9rm617l1ni/TmiJtzcrNpd/x+sen1QZpdq6aDdXtcsaev4ize0OrrFavesc2K+66a+/IefLA759LUvKSb7dXZuPvMcfMW03w+sbjsk8W8vIbQ3ONVfIjvcFn8HG+e9rKSbmeueK/ejnszPM1xZ5Js571xzEFx49WqNxTMorhXP0nONr0d2fN5cXaz+J1VT5CU9/Asi+OY4gs3N+Pukwj7OqRu3jvb0ztPPNHLevhqsS/X3BBS3pd35ah4bLd67f4P/VCvzf8LX/1rtawkyZNP9rKm31uLaj4vePjhf1zL+o5v/uZaVpJk/E21qOo69TPP1KIeaU7wJMmq+H7gk+46ZM1pN+6i+P7Gb/u2WlSOLxXno4vvpEySRbHBev9jxf36xbbx4vrjtawkyWbgPTx7O9h8bfu7esc+utMo68nRaDRIqZbRaDRO8nV3+GcKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPAlKSDJveRXk6xf4+fzJF8/UPY3JnmtUsfrJP9toGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADucQpIcs/Y7XbrJL90h3/2rQPFP32Hn//nL/x9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8PsoIMm95j/c4effOVDun7vDzz86UC4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB7QAHJPbTb7Za73W7U+C/J377Dn/PTr+P3/NQf4vA+fIefv3c0Gr3rD/H77mg0Gj2R5Gtf45/scue/CwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgLcxBSS5p+x2u99I8vE7/LO/+SbH/uAdfv7Lu93u2Tc5EwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgD2igCT3on96h59/72g0+qNvRtBoNLqa5C/d4Z/91JuRBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwP5SQJJ70T9P8tJr/HyW5O++SVl/L8n0NX7+4hf+HgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPgDKSDJPWe3262T/P07/LO/PBqN/uwbyRmNRn8+yXff4Z/92G63+903kgMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMD+U0CSe9WPJfmtO/ybnx6NRt/45fzy0Wh0I8k/ucM/+7+5cyFLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUECSe9NutztP8sN3+GeXknx0NBp96A/zu0ej0Z9J8vNJ5nf4p39rt9t99g/zuwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHh7UkCSe9Zut/twkn95h3/2ziT/ZjQa/YvRaPTYa/3D0Wj0+Gg0+ldJPpJkcYff+y92u92/ft1/LAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG9r47v9B8Ab9NeTfH2Sd73Gvxkl+e4k3z0ajX49yS8n+c0kqySXkvyxJH8iyde9zsxPJfmBL/cPBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4O1HAUnuabvdbjUajb4tyX9O8lWv4//yni/89+V6Lsm37Xa71Rv4HQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALzNHNztPwDeqN1u93+TfEuS3xg46pkk37Lb7Z4bOAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIA9o4Ake2G32z2T5BuS/PxAEf8+yTfsdruhi1QCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwhxSQZG/sdrtXdrvdB5P81SQvvUm/9qUkf2W32337brc7fZN+JwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG8zCkiyd3a73U8neSTJ30jyv7/MX/O/vvD//2O73e6fvVl/GwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG9P47v9B3DP+4U7/PwThb/h99ntdr+T5CeS/MRoNHo0yQeTvDfJH0/ylUkuJZklOU/yapLn8/mikb+W5N/tdrv/czf+bgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPaTApK8Ibvd7hdy5yKSd9Vut/t0kk/f7b8DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAt6+Du/0HAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOw7BSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGDju/0HAPvvINvBfvdy2auDe7C5qGW1HT/YO7bbq0kt6+SkFpUkOV/Palkf+lAtKtev97I2m15WkmR+rRb1WPPYxr0u3mw6XBv/JV27Vot69dVaVKaXF72wsoP1upZ1Nj6sZTXbq+IlnSSZz3tZv/iLvawPfrCXdetWLytJjn/3uVrWL3zy4VrWd7xvWss63/T6qEkyW71Uy9oePVTL2qxqUdmmNxZMyuPB4k3mbN0799v3s2mvCcmTT/ayVsXr7P77e1ltTz99t/+CYTSvs7P0+t5Jsrj1Qi3rbH6llrXIWS1rO++OOw9u9r6z02lvTu6wOGBqz5PdvNnLevbZXtY3f3Mvqz63WdT8zq5f7/X1699ZccJgve7dz2Y5r2Wl2OYnyeG4d68+W/fu1Yt5b17/YtMdv3/XdxXDnniiFrUsjgWzWRbDkndfLc65PFZcYN3njkHRC6te23h0VIvKZNxdX/30M722+NGT4r0zvfOjPbf5cz/Xy/rTL/+HWtbkL/7FWlY++cleVpL/ct8Halnv/8Qnall56qleVnPgmVT3nqS4Z+Kg2GAdP1iL+rx1sX9VXGRq7s9oj89u3CiGLa/Vombj4himvAG2OYyZFCduL1LcD1LsN07S3dN+tunNyy2K+zPWxf1Cs+bAM8nBaj/HZ00f+1g37zuPPt4La/b1ixtd/tet3j65JHl882wt6+Kot+7T3ElZvU+nOy9XnU7a503tRd152+Ln2NxwmFTnXKr7epfLWlRzX2+SLIr91O24d2wH694+hvN09zFk3Ot/z4p7C5raY+rmud+8xzTnG4vT7EmSRbHP0+xdNZ9julh2x2eTW/t5bM195ufF+0uSjPd1W01xfNZ+NqDZFjffW3C+7t3PvvIra1GfV1yIvLIs9huf763lvvMdtajuwnHK64LFY5sVx4LbZfe5uqPid/biK717zOXiqd9+Jr0533i26h1bc4p41nxIPN1x7qTYXlW/tPb++eb9s3hsx5f3dy0mxba4OYaZFp91WzTbjyQXxf1CzecTt/PivH67bWye/Pt6jymPz6qfYzGruVZ3Me3Ok01Ob/fCin3iZg9kW35OvHlVN9+x8tn7iu/FebA7PpusitdZsx0uXtPt51erL91s9gv29Nmitua8XHMGsP4OzGJ7tT3p3WO+6qtqUTl/7L29sCSz5v7G4rMBxa2UOf+e769llaejq/tfD4pjmBfmj9ayNuV3fi+XvXFMdy2m12+sr9UVr7Mf//HeHtG/8+eeqWUtHnuslpUk+chHalH/9voP1rK+Y15ssIq1hJIMX1jid35n2N//FtVtLQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADehhSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBgCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICBKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYApIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGAKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIEpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxvf7T8A2G+7XXKxGa5W7eT0pcF+9xe7WD5Uy0qSya0XemFHR7Wow+l5LSvrXlSSzIpZ83kvbbY5q2U9d7qoZSXJdNqrpT2f16KSTS9qyDb+S5lMp7WsB3tRVQebi27gclmLWqyL95h58QRZl29o6R3b1au9NuRw9Vwv6/rVWlaS5LR3k3niiVpU8uyztajZ1eLNM6m2jU3N/k77fnaRSS1rsum1+8WuVSab4n06ybY6Qut53/t6We0uSPN8/Oxne1mzm5+pZV1cfaSWNVndrmUlyfbkSi1rkW0ta5vePMjBafc7a/Z35s2VrtWqlzU97GUlGRc/xxs3elnN42p38z/1qV7W49d7/e/tuNf3Phz35r6T5Gzeu5+9875aVLbTXt+7PmW7ac4B9qKy6c2DTJoNcZJr14prFqenvahVr1+wOCpfacXzsTnwbN7P6us+xQmD6bQ4J5fe53i+7h1Xkjx6rXdsL77SG+ce398b516Ux2f/4Md6cxP58P29rOK6T3MfVJK8/+Z/6oVdv97Lev75XlZ7UF2d4yn2r5r97/IiQnPs2Ty06lpdsb+TJNeuFfs8694HeVbsyzXPj6S7H3t71NuPPSmOmZr7Cqrj6STj4ji3+Tk290dX5xqT7iaeYtdqMe7tPXn66fK+k1u9PYfb9OZRD4rn4uOb4vM3STI+qUU1912dj3vzO1NPtd57yn2QfV1DqB5Xea2ueWzNtZgUs8btR0eK31n16bPiNT0rr9U1z/3zde9bazaNi+qGw7Li5OakObfZ/s42vbzqkTX3C5X3mTfb/epzMcW+3Czl533G+/m8zz6/vqm4VS7Tk/3sg1y61Mtqa75rYlLcW1B9z8RpcaI9yaT53pNx8YMs9gnaz2g1z/3j+09rWcmyF9XcK5RU1+oW0z1dE+dN0dznUn2vVpKD4nPATWerXt+qvYQwG/faq0nz2JrLZ+UNZd1TpJfW3SPavXdu5t3nHlom4+K7H+bdd2A2nwlr3mMWxXfz3bpZi0qSXFkWn0/c52e399VJbz/Zg+UtPFXtjuoeqr8fuPkcX3Niv/o+hu4Y93BZjeNN0Nz73bzMrhZf2Vt9diTpro8UP8jqs5DNvSfj7uRm9V0kxcX++VFvXqL+3GXz2dzmBo11r+/dfLYoSXKzN2Hwoz/6cC0rv1CcCLl2rZeVVF9M+R1Xi8+f/fqrtaj2uCJPPz3s72+3G28R3RE9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwNuQApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBgCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICBKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYApIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGAKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIEpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxvf7T8A4I3YHj1Uy2o3mOfLK7Ws2Xhby7q9mtSyDpe940qS83WvLvOv/EotKuNvWtSy1utaVJJksrpdy/qt3zqsZV35hqu1rPWqFpUkGc97bcimeD5uNr2s2XSPhwDj3rE12/xZLekLiifk9eu9a/r29OFa1rjcNs6XvXvM1WUtKjl6oha1nXavtFXxHFmk1yc+W/XaxqTXfiTJfN7LOkuv/70ojgVfuNW9zk5Oelkf/3gv6/i4l/Xbv93LSpLHr1/Usp59tteGHL+nOD4rjmHGxf5H0h0zTYoD3YPiGCbTaS8rqX5pk5zXsppm4167mCTz4pzL4fislnW+6fWtJuvecSXJ448VO6mr4k2meC5WO/pJFqe9+ejT3+3dqw82vfbqbN0dCy7GxU5IcZx7UcxqryH85E/2sn74u3pt4zveUYtKPvnJYljy0dNvrGX96Ru9e/V63OuDzMoX2ouf691jjh8s9omL47PmGmSSnBfb/cuXa1HJujfObc7pJ8mzz/bm2t97dFTLal5n1awkeeqpXtbpaS+rPZ/UVDy226e9a7o559IeUx8U1zxnxVP/YtM7Pzab7pj6E5/oZX1g/au1rMWNG7Ws6pxckl97vrcf+73r52pZudpbq2v29Sfl+/RsVZzXL+6ZyLS4hrApr2cV1+rG495+kPPibsrFtLtW1/zOmvP6ze9sdrS/+6O3415frrk00twLkiST1Wktq7qvZt37INt7bdfFcUzz3B8Xr+nmrt6ku567GBf7V8U5uelJ73nSJNn2n1apaPZ3mvfppHtszfaqqTknlyST4n795rzttn6X6TkobsiezIvjmOYDFu0F1ubaYPHYmu/QaD/bP1v3+nKT9uCzpLl2liTzea/dbx7bptgvaDeN05NeX25y66VaVnXue95bQzib9tr8JFlsinsLmjeZZptf3jPR7H8fFI+tOT5rr69Wv7M93f86KW+2nRQ/x+Zce7e1KivO295Ob93ncL6f++e/EFhLevHlXjt8fKm4XlEewDefi2nOR9+6VYtqbl1LUn7GuXg+vrjrjZmOL3fnXJrjmEWa47Ne//voqLyeNe4d255ObXbXzlIeexa7V6+80su6dKl7nTX3Cx1Oi3254kXdbz6K11mzcSyOmbrvbuzeYw7Te8dK8ztbl/fUNIeDy2Uv62Mf62X9tSef6YUl3cXB//E/alEf/9q/Ucv6k71XEXcnC5Ic3LzZCytOTlT39Zafu6y+Y+Vy8d0PTc3zPsnZsvcO+uaUy+T69V5YeaPL+RO9909V3+/5rd9ai2rvj64vM71N7O/ubAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIC3CAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBgCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICBKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYApIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGAKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIEpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAY2vtt/AMAbsdn0sl55pZeVJJcudfP2UvMESTIr3lW/9msntayHl2e1rBc/u6hlJameI+95Ty0q22KN8M9+thaVJFnMt7Ws2bQWlYvN/tZ1bx7bZL2uZc3mxUb/1qqXlSTT3sl/ctK7nx2sz2tZzc8w6bb7B5uLWlb7c2xq3s+a58d8XovKzZu9rCRZjHttyHg8q2U1z4/lshaVpDscfOyxXtbx/bd7WY8ta1lJkuJ3du1aL2s77vV3FtPifbo75ZJx8XO8venNTcyL3Z3yNFlmxfPxfNM7P2bj3gfZPK6kfa/ujaln017fOyl2iJNk1ZsvOB/32sZZet9Ze06ueVWfnPSymu3VuL27oTg3Me5NbWaS3n16U+zHJckHP1iNq3nggWJYc5Cb5H3FfurFtHg/2+zvfPTxvDn2LJ4gxazFurzuU+zsXxT7BZPiuX84Lp73SXKtef98spZ0MT+sZU3GzbFg1+30PsflHs9dTZprx+mt+zQX687X3TF1s8tT3HqS2aa3L2887+7Le/LJYtjNa72s5uREua//xBPFsPWyl3V6WovajHv36eZaf5IcFO8xs+bepGIn5KK4FyTp9q+aazHVc39V7BQk2V5/tJZVXGKq3jqb+zOS7ufY7BY0v7PqftRkf/ekFhv95nmfdL+yyaq3L6+62basuT86m2KDdXRUiyoOYZJ09wsdFPeDVPeTNdcFk2ynvbFFc4tGtQ9SPBeT5GzVG8cs0ptv3BTX3+vrPsVOSHOuvTl+b+7PSMrnSPH8aI6ZZtP6xrxaUvX55ma/oLmglWQ+L85vFse5h8Xh2Vl57upg1esXXCwfqmVN1r3jevnlWlQuX+5lJck2vXt1c5xb3WfebYarcy7NMXVz/u+Fm912+Mqy1y9ozhXMsr/7o5v9q+Zqf3P9rL3us1329mjMi+vvt1e97+yw+VxAkovik3XNZ3DOi3tEx+Wmcban+7FPTvb0HU1Jt1NcXD97oLhOXX/muNnnKS74N/sg7Ue0Jnu63N99nqN7nXUfT+wd2/3316Lqz/tUh4N7+mzAptw2Np+LqZ4g1c22vTFu0h0PbovHdnDzhVpWlt018cPNS7Wsi01v3af6bpDT8qC6uTGv+ELFJ5r94Vu3alEvvrP3LEeSHD/ZeynU7dNeH7X5PobmOwuS5HKx27ivNQomxbmkJFkU5zab39n5ySO1rPZSXfO9g8336DbXfdoOpwOvHe92w/7+t6j9vAsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAvIUoIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBgCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICBKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYApIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGAKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIEpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwsPHd/gOA/bfZ3Ju/+4vdf38vK0nW62bantYTvnmzm3dyso9RyXRaizqeXtSyPm9ZS5qMt7WsbfGaPr7cO64k1Yb/bD2pZRUvs5ytum3+onldz+e1qOZ1dlA8riTVE/L0tBaVw/Q6V9vprJaVJAfr81rWxbh4bMW+ftukOBtzcHq7lnU2PqxlNe+dSXKe3rnfPLbmmLr9nTXvMdev97K2y9511p2XSF59tdf/vny5FlX9HGfT3g3mfN0dV8yKY+rDZS2qOq6YpDznUrzJzJorXcV752zanXNpno95/lYtanv14VpW20Gxg9Vsh5vG7ZXy4nfWPLZ9nfvea6tVLWo8741hku74LL3bWXVMfZFFLyzJcm93LfUObDvujaeT7nxScx61+Tke1DshPfvaL1gV142T5HBZ7H//zM/VoiY3btSyslz2spJcLB+qZR3e+nQta7t8tJY1OX2plpUkZ9Ped9bsyzXbxvbtrDnX3uzvNPe5NPcVJMmsefLva/+qfFzN66zZu7oozk2Mi+1Hta3KHo/Pakn9tbpN8Uq7fdr7JJtbKSflTRPN+YJpcX9j83bW3CeXJNPmPWZPuzu5VZxoT3JxdKWWNdn02v3tvDevPy7vJ6tq79cvaa8h7OteueaG1Om0u756sDqrZZ0V1yEX6R1Xu/1ozvE098/P1vv5zENS3kM/7p2PzS5qe8/ydNq7f1a7+sX72bj4zEOS6l6o83Hvftbs71xsutdZc29B8fTI4dx+oTdHsR3e1zmXpPqlNa/p5nE98EAtqj632dxX03xGq3k/a7cfzT5xcwxzkF77sVyWn0MotlfdObneCdLuo46L62fNc785/9dcr0iSg+JazCuv9Pqox5eK744pzv/ts1ma+/LKnZDiWLA9zt1bzYmQYqd4XDw/6nMFzRfjFPtyzbmk+lJ/8TrbFOejq2PB8p725j7A5juh9lm1fzUunvzFc3HR3FOTJKs9fVlkcR51URzjJsn5pte/mjWfGSx2DGbj8nu8jo5qUc39r0dHzbHgspiV7jPOxf3Y1X1QV6/Woi6X35Ha7Bc0nx1pzu+0h+8vv9zLOn5gP/f1TorvhE+Sz9zqHdsj13rrPpNN8XO8VZxrTLI96r37obkKeTgvPlvUnmff5+eL7iJvWAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYApIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGAKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIEpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBgCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICBKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYOO7/QcA+288YEszm26H++Vf5DPPdmvunpz0sqbTXlbVvPghJslmU4sajye1rPNNL+v0tBaVJLkyvd0NLNnMD3tZm27bOJv2uq+Lee8esy3WdW+3+RfptSGTWy/VsjbLh2pZkyE7U19KtTHutVdn417WeF2LSpLMilmTca9tvCjeYyab81pWkpxvet/abLmsZU173eFBx5l328HqrJY1qXYMul/actlrQ4pDwRyk1w6v192+/vEDvXN/m0Uta7bujTu3015/Z7bpfV9J9zs72FzUsjbN8dK63EltanYM9nYiNTkojqlz9Wovq6jZJ0jK1/V83ssqHtdm3BxRJ5P2SVLSnNts386m0z2dty1+ju3Tfjbu9eWabWPzc5ylO0+Wce/kb7ZXzbWRtPsgKV5nxb5+8zqrr/sUD655nR2c9uZcFs3+cJLcOu1l3bjRyzo66mWVv7PJzedqWdvrj9ayms6mvfX3pLsf5Lw4196c20yzv5PuPtHm/axpO+3OgzQdNO8xxb5cc89EkizSXftpaXa/m3NX1TmQpDr2rJ75xS/tYtpb70y6czzNufbmHq/b424f9bDY35kU955U+1blsaClujdu1uzHtTUnHIvPFtXXEIof41lxX2+zjzor7vtOkllxIfKi+J1Ninuxx+1tBevis5DVLcv7uQaZJKviuV/tXk2Xtajyqk9173dWq1rUpjjObc4PJ+VnmZr36uJFfbAu9xuLxzZrHltxfDYuryE0r7PDZfE6K/at2qtZm+K7Jprt/u3TPd0jmiTTXtvYvKbHy+I7NE5rUfW5zRdu9r6z5hRgc25zMe2u1TXfL1Qdw1QfDuj2d7bz4pip+J012/z2cwjVNqTZ7O/pMw+f12sbjy8311eb6+/lvSdFk3lxMWZT3E9W3rfZnLtqPt88afa/28+O7GkHfDot9ofbc5vFdci7cLOuqI5hku4z8MW1mOa7rtrzIE3NNqQ6yi1Pblb3gxSfT7wovh+4/T7FbXHetvpenOa5324bm92CPe2jtvv61We3i/3GSfNjbC/WNfOaRSya7UdxH9TLr3bXEC5fLubt6WsH2++fOr7U61+dF9+32WyGX3y1+1zdtWu9rOZ7BJqjwfGy/Ex6deqqN9/4yiu1qLrjywP3d0ajYX//W9R+vuUCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4C1EAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGAKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIEpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBgCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICBKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYApIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgY3v9h8A7Lff+73k1q3hfv9y2auD+xVfUYtKkkynvaz1upfVtB1PuoHFvGc+UYvK9eu9rKOjXlaSZN3rCt3eLGpZ81rSXbDZ1KJeuFVuQ0qKH2GS5OGTi1rWp08fqmXltBc1Lt/PHjnpdUJ+5idrUTk97WW96129rCT59m+f1bKafZBPfaqX9cQTvc8w6fZ5Xr2vN2b6f/+vFpV3vrOXlSQPPNDLWox7fdSL9O4x61Utqm5VPLZnn+1d09eu1aKSJOfL3phpXOwT31wd1rKOinNJ42nv+0qSFL+zzabXNs5yXsu6KH9nxdtZbt7sZV052fbCys6mvTH1z/zDWlSeeqqXtVz2spLk4aPehfazH+n1QT70od747JVXalFJkuPLvZnb5jzI4bw3/zebdrc3nK97537z3jle9vqozb530h3nTooH1zw/LtKdJ9sU16mb/e/mrP7FuPudvfhK7+iORy/Vsibz5gpr935W/c4u9a6zage8vMDaXPN8tLno2fzOhtys9iW8+I6Ha1nH6c1NNPvDi83tWlaSfObZXp/45KQW1e0Pr89qWUmynffmN5vrPknxOhsX79NJbq97/dTD9Wktq7vBsbtfqLm/8XDT6+sfFPty03nv/tLs5yfJ8YO9OcCq4qRLc34nSXV9tfnMw/mmd3+pf2fNzXLN8dnJlVrU7VW3bTxcPdcLW/cutFnx/Dgv7s9Iktm4eD8r9kEONr3j2k6789FN4+Z6RfVc7EUlqd5AJ+PiHp7iZMGk2blKkuL6yKz4nW2LY+qD4pxtkiymxQv7tDhR1t541dTcxLOv49zupG1S3G97tmquxRQ/x/b9rNj/Pi/uq2nuc2m/Z6J5ilxsetfZpNheNfd9J93v7PZp7ztrHlfzmYckOTrq9YmbWzQemffWmObL3nW2r++0aFvMe+Ozs/J8dLP/PXn+2V5Y8QHWcg+1OoxZbE5rWc+fFp9DKK/VNe9n750/U8u6uPZoLas9rmhOubzjHb0+6vHl4h7R9lrdtDlH3PvODpprI+X56OqYujhAa+5tbN/PmnmzYkP88n297+zBB8tr4sVln+Y77KqnfrsTUlxfbT5OfV7cQzwr7nNJ0m0ci+sVn7nZa6/ayz7V7frF+9kqvTH1tL3Hq7nvap/3FhTV90jvoeZzl0l3z2Fzn2h731VVc5K4eFG/+mpvXDG93Furaz63nXTnrpp7T7LpnYvTaXl9tXhszdt0cy/2rNlpTJJVb3x2uirWHSm+Fmf2/Kd7YUl1TH375PFaVvNd5u26I4PPy+12w/7+t6juSAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgbUgBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICBKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYApIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGAKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIEpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBgCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICBje/2HwDst+02Wa2G+/1XTrbD/fIvsl53a+4e3HyhlvXqfVdqWU3j8l1usjmvZR0dzWpZi3nvOstm08sqO1z2PseLTa+9mk2L50eSbSa1rJOTWlT11G+2VUlykV57dXRUi8p63ctq9neS5GLT+86Oj2tRef/7e1lf8zW9rCSZz3tZn/tcL+tP/ale1v3397KS5HB8Vss6Hy9qWQ8+WIuqtsNJskjvO2tO1w05Xv9i02kvK+mOB5t9uWvXellXji56YUn1SzsvzvE079NNk3F7LNj7zm7dqkVldtJrHCfr7lgw617jeN99vf5Os/1o3zub5/6TT/aymvfO9nf24iu98fsTT9Siqo4f7PZ3Lja9uc3m+XhRnLNt38+m0951drDpnY/Nefb2Wt1B8xwpXmiT7O9a3aR4jmzH+3lNt8dnxw80J5SWvazmhGO5cbx0qRrXU2yvtuPevTNJ3vnOYtgDxUXx4oT0xfKhWlaSFJdHuvtBUuxbldvG5n6Q5visun427c3JJd0+8WJa7BM3+9/lvv7hvDjvMu9tGGr2CybFcUWSHKbY1y9u8mreO5uOL3fHgmk2IcV+wdm6OE9W3ucy29O5q/G4d01X5xqT7gbY4vnRnCc7bF9oV6/Wopp7Jg5WvX1y42l3zqXZlzsojgWrx1Xuo95e9Y5tuaxFpfpId3uzbbEvV20bm5sAT097WUm1X1DdW5Bee9U8riSZFK/r7fKwltU89dv7esfFz7E5BbjPLyhptiEp9om349652O43Ntvi6pLWuHefHpcf7T8ozidtinPEk+JNZrrHDXHz+dXmetbRUbffuJj2jm2z7B3bxby3H6T53GW7j1p9f0xR83mf+mfY7OwX576ba7ntVxk1z5Hzda+v/xVfUYuqv/uhOkc87l1n7Snipub9s/nOsObcd/tZyOq8fnluoqb9vE/zJCle1IfFeYn23rXm3Ob5svfe0geL8yB7/SzkaXGgW+xcbYvPACflZwbXxT08896zAc1n7ZPudX1QDCsO3/tt462XemHF9qo5hmk/c1xd8C/2Udv3mKbqdV0cx5wV36HbbhubkzwH8z1diCwvxpyX+zwtDzxwt/+CYdw+7Y7fm/ON1UnAYpvfXveZFBePV+mt+xwua1F7PX5fF9/dWF3Pag48k+qFvTqtRVW/s+pz/Un2eyfx3bOfT8QDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAvIUoIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBgCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICBKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYApIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADU0ASAAAAAAAAAPj/7N1PiKT5fR7wZ2vL5XKptlXT7tlpD8MwGQ1ivFpkIa+szSKUxQjHhGCEDzkJRxcHE0xQQCQQcvAp4JsJJtjBBx1EEHFsHOFDMMEIsZgVFvKC1qtB2ayHZTye0Ta9rZlyu9yq7clBuWQt8CH6PSNKn89xF/qZqvet3//3/QIAAAAAAAAAAAAAAAAAAAAAAAAAMJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDTR/3PwDYbU8+mRwcPO5/xffH/vKsGzhd1qIuzGtR2W57WbP1cS8syflqv5Z19cp5Leu8WW96OutlJdkU8xbrB7WszPd6WWWbTS/rlVd6WTdv9rK+851FLyzJpadOa1mvvtr7bM89V4vKG7eL7XCS68tv1bJ++7efrmX98eferGV9+ZWrtawk+fjJF2tZX/rGL9Sy/u2/7o2/37jTHYPsb+7Ush7++DO1rEsXetdsve1esyyLk6Zpb7luucMrg8WvMScnvazr13pzwbPy72y26Y0bk964cb6bzUd3cpbk1u3eNbt2rRaV45PeWH9/WlyUS/KVb/TWJi5erEVVLdJsF5PPfrb3O/vsZ2tRefXVXtYLN7vr0b/3e7316J/+6VpUte88POyOd27f7mXduNHLau77VG+QJOt1L2u57N2Pk+bYuzpITY43vf6sObzaWxbnginPBbe9+3G96X22veINUr9my945hurcs9nHVDvPZD4v3iPr4mcrfo+T8kLqpSeOemH/86Ve1mpVi5o1N3OTpNk2NicWzc9Vbhuz6q1dTY56++/TVW//vTmOS5JMe311c3w12+F1/ebv+nzePQtV075mzXa/uOgya471i5/rdN5bH06Sxaa6UFaL2tsWP9e8+BtLclpcB9nRn1n2Xn2lF5ZU50zNrLvr3tj7corz6aTaV0+KD2WdFZ9DKG8h7Oz+yCS9PYQHxf4lSfbnvWt2XjxPVh/rF50Xn9Fq3vtn294Zr1lzTJBU5+/d8429z7Vpn2kv9tWzbe/ZgP15c4+pF5Ukp9vdPLM8OSmelSsPHJv92az5PRY1n7VPUv9d1xTHjdV11HTfW7CYFt8Psqv3YrrTmKee6mU1x8PNM6LfVXw+sbv8XdMcgrTXyR6se+1ws4t5+LCXtUh3fae5Jz659VotKzd6z7+3n9E6Pulds/117x0aX/+r3js0PvqTxXc0JTneFt/T9Af/rRZ157lfqmU1n2NKklu3eln7m3u1rM3qci2rfWyz+VxMdYBVnDC1z8k192J2df9s2j7beNI7WDNd9tYAZ+mt77TfsZJp8R5ZFZ+73M1mOEmyLd4jzefBmksTs013rF9dvCrekG8/7P2mm+8RTZIcFc8BFl8w1H1nQfe9pdPi3mDzDGB1PLzDmvvve/PiuLH8bP958bzQpHheqLk4cdYce6c7Tm0Odxbz3ayHUN/vbC7M7ej7OmbTcj9dvEn2m89uF98NMmkOiJOcHfTW2q9cqUVldtJ7Z0G1OEeSvPhiN69kL8V1kG358Mno3/X5D+ecrDujBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPghpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwGAKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwGAKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwGAKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwGAKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwGAKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwGAKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwGAKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwGAKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwGAKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwGAKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwGAKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwGAKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwGAKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMNn3c/wBgtz35ZLJaDQxYrwf+8XdZLntZ5bxZzotZ21pWpt1ublL8HrPZ9LLmi15W2XxeDDvqXbPpcq+Wdbbt1iNv/qyfe66X1fxJt51Ne23Ixz+2m+3we95TboeHDt7+X5/4RC0q2fbGIOUhSPLss7Wof7iqRSW3b9eirt+4UctKkqyv1KIuLYttY3Govz8/7YUlOd322uLFybdqWVk9XYuarY9rWUlyttyvZV27VovKeXrj73Z/9mDT+53tzc9qWU3n01ktq9kuJtUh6k7Pz5p+4id6WVd6Q6vcudPLOrvQ/Z198pO9rOef72W99VYvq9pYJXnxxV7WM4fFsVxzELLtDnje+97e73qyflDL2k5769GzTXFfMMlecxNhXRyENPc8y4Or5bI3Jp5Ne2suxye9uWB7S7y5WTcvrl0157jL5n5nynuDxT2mZnO1V75mJye9rP15b3zV3IOcbbrr0dW5RXNxs70XU9Rct50cHNSyqodqyuPGxbS4RlwcYDWn1Gfprl3Nts11/d68onmOoT/Y303VY5vFM4BJMmn+zuoHa0qK47hpsflIkvNVb/+9aVK8Zg/W3bO2e8XzQs3x8N60OD9rzpeSpDnWPzqqRTU/VtbdRZf73+m1jZeaz/sU177bbeO8+FxMc6i/2PbaxuWyfKa9OP5uPp64V1xHbZ4nS7r3/ra4X1F99qyseY9U74/i2lXzc7XzZs19n+KaXPtM+6I5iW8eq9nh9cbq/mpznazYoU1Our+zFJ8dmRXH3+fFOUx1fTjJpHjvn26bY+JeVnuVfVfXG8+L48b2cyrNMchmU7z3izd/c7hTfU9NUp1YNOedFy7UopJpd7Fg0jy/dnhYi9rlcy77q+LvetV7sO6pHZ53rpphH/pQLerHf7wWVV9zuXmzeI5hu+plFbWftT8vzpma89zTYh+zKJ9pb3625l5uc372sPl8c5JLF1e1rG3xe+y+t7S7v9ocE1fbxuJaQVtznazZYJ0Xn9E6L5+Pru6v9qJy8WIxrPw+huoLZIoNcfPsyaz5/rqk+yxk8Zo1n6Vu7yE0+7NqO1y8P9p7dc17ZFocEzfPJjWnFUm53U9xjWfT+yKb5wpm7UOAzUPLTc1Jbrvz3NWzcru6AZ9uzZ2q5r1fLRqQ6mc7PCzO4O/0nuE7v3a9lpVk/AmvSfeZsx8UP5yfGgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKBIAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwRSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwRSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwRSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwRSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwRSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwRSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwRSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwRSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwRSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwRSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwRSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwRSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwaaP+x8A7Lh33snk5HjYn7//nf1hf/vdniq3mK+/3sv64OrNWtYb26u1rMPDWS0rSW7f6mWtVota1slJLSqHh72stv3lspZ1504tqn7N1ute1mbTyzo66mVdudLLSpK33+5lXbw4qWW9/EqvHX7f+2pRSZJv3u71n6+8UovKf1xer2UdHNSikiQvPH+tlnWtOCb+Ly+9v5b18+Vrdu/eXi3r5s1aVL70Uq/9ePHF7lj/63/ay/roU72BwetHT9eynrnSnVQ3x1e3b/eymmPUdn927VoxbNq7H7/8Um+M+txztajqWkGSXD48r2W9dqt3zZr3/f2HvfFHklw9OK1lfa04P/vwzd7nuv9273Ml3d/1r/1aL+uTn+xl/ciP9NqPJHnmZq9t/E+/1duL+ZVfqUXl1Vd7WUnywSvj9sve7f7f9K7ZpQtntayzabc/m6X42ea9zzZbP6hlNcfeSXc9+tJTvQnadNobF8y2vfFOkmTbi5rOe9/jfF6Lqq4VJMm2eM32pr37cTYvtlfNLzHJ0VFvLXW/uA/ZvPdnm+ImdZIv3+qt23784V/VsqoLIc1DV0luH/xMLev6td7Zk9NNb5672HZ/Z8frYtu46vUxk/TWCmbb8iCkOLdo7jEdHnbXAHfV5PYbtaxFdUOr6yy9tnG2PqllVSdoxTOibc0+pjpnKh5Inc57a7ZJqpOm6u5I8xBxeW0zX/pSL+vGjVpUdZ192f2dXTq62wtbF/uYZt9ZHH8k3Z91M+t0U1z7riV912l6n605BDnd9u79xaa4L5hkve3u57Ys5sXxcFlzrf3hw17WxYu9rPZeXbOrrq4RT3vjxtPy/Gyx7bXFp8VzNYvi2YLz4l5/kuyviu3+pjhwbC5+l9fJZtPeNTsvnuGZbHq/s7Pi50pSPS/UHINUz1KW59THJ71xQXN8tVr1sprNcJJMp717pPlc3Qs3e2exM+31Z/ff7v6mv/3tXt5731uLqs4Fz7bdZ0feftjrqy89VYuqtvntbZ+793r3SLM/a46tmuOPJLl3r5f1THPP81Iv6jjdNZc7xfe8XbpUbIeL84p249ht94t7McU9hPPi3lmSTIvz9+bZpEXxgz0sz9+b49Tq/tm21161x41NzfWk5vfYXB/m+2OyLY53kszKz/G17OrYKklmKX645ktWlr3nBc8PellJ8tZbvaxLP9bbf9+Ux3JNb97pjRuvTntnbc8OLtey2prNVfM9b82Dm7PyYL/67OW6l3W+6q0BNs9MtM8mTXb0UPuDda9/aT/Ct6v3Y3Ve0Yuqa047F82b/6WXellJtWjGetWrUbC61stq7ncmyeXt4MNQO7qm8/fp7pIDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/BBSQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgsCcePXr0uP8NwA544okn/jzJM+/+78/cvJk//8pXhuUeb/eG/e3HbbXqZU22Z7WsN+/NalnN7zBJ9ua97zFHR7Wo4/nlWtZ0Wouq2zt6o5Z1fu16LWu9rkUlSebzXlbzfmx+j83vsG22Pq5lvXGyX8u6fqXYvyQ53fb66tdfr0Xlb/6ml/WTP9nLSpLlspc1yXkt67Vbk1rWMzd7nytJzra9zzY7+VYt6/6jp2tZFy/WopIk220va3b7m72wGzd6WZtNLyvZ2UHP8Umv/WjPz5p5i/Vuto2XLhb7s2bDWHa87o2H91fdMUjVyUkt6u6mNz87OKhF1d2+/bj/BWNcufK4/wXjNPvOV1/tZX34Q7228XTTG1slyeLkbi3r7MC6/vfD5KS33ljd1CrOzx5sF7WsJNmbnlbzaopz3Oa6VZLM0lv/PktvrD/bPKhlnc27ZyZ2td1vTnPbU+pmXvPMRHM/q73UeO9eL+vystdeVRuQ8g/tdNpri5tL7dW1q/Iewml649RdXUrdS7H9SKptSHMe0+w7z6e9vnOXNc94Nc+CJOUxyEHxLNSOTmJ2ef6+q5pzmKQ7j5lsimtyuzq4SqrtVXM8vJju7nineTs2u7PJujfWb86nk+73WO07ix/sPN0xyFtv9bKq567aZymLzufdvcGW6ninvSC9o/dj814sHpNLUn7muHjvN69Ze1qxq9sjuzreSVL9Ind13bb5zoIkebDZzb3j6lyweU4uyYNp7+x3s23cnxfHje1xXHHTormWupjv7pnlZhty504v6/Cwl7VI7zd9Nu3Op5tjuWY/3dxf3eV3rMy2xf6s+EWerXrPeCbJbNrrY5p7x82xVXuZrPm73lv3ni3yzrDvj+q8Yrmbz1cku/ser+r7fsprLs21q+Zae/V8dHlBunnNmu+f2ukHfpqNY3E96XzZOw9SvReTPFh313hadvV5sGR31wCbc6ZdfhayuQZYbfPLE7Tq+xSLz243zzc2z9om3XXb5jpIdROhrTiWa+5ZNNejm+fnk+4YpPleyuaeePM82eSo907KJDld9vYsdnXdtrqf1Va8aM33bbZrxTTXUu+/3fseL13Y4XObzZo701473Nz3aY7zk/HrSR/40Ify2je+8b3+12uPHj36wNDwx2g3Vx8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfoAoIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIMpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIMpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIMpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIMpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIMpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIMpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIMpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIMpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIMpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIMpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIMpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIMpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAw2PRx/wOA3fboiUlOp3vD/v5yPuxPP3bbbS9rdnJSyzo4eLqWtZie1bKSJNNit7pc1qL286CWNbK9+F7mzTZkeliLmmxOa1nb7aKW9d28XtYf/mEv6+d/vpd161YvK0k+eK3Xhrxxsl/Lajb5f/LVWS8syQvPn9eyfvM3J7Ws//yJ/1rL+qNv/7NaVpL83Pr3a1n/4dYv1rL+3Wd6/dlrt7r92TN5rZZ1d/VMLeuwN9zJ7du9rCS5cqUYtloVw3pO0/2dLba9+eA3b/f66vevvlXLOk5v/p4ke9Neu3//Ue+zXbhQi8p5emOrXtJ3NcfEzfHw/bd63+SlC911stfu9eZnzTHInTu9rGvXellJ8tnP9rK++Jk/rmV9bf2ztawPH/1RLStJfv3Pfq6W9cu/XIvKa7d6beMz8zdqWUmqY/3ZtNefnW5616y5JpckzVW5B+ve97hX3GDt7WZ913lx7jlZ99a+s9nUombNjZikullX3X8vfq7ZtjefTpLcudfLavadzWtWS/q/Nute1rbXWVdXG3vNcJLk8r3bvbBXXullPf98L6u6qF/tqrN/9M1e2KY4mmsP9pe9VmSveO6qObY63XbPeC3mvXnuvDkkLg5S15vuKGRvXlyTLn6Py2L70exfkuqR1KR4ZjkHB7Wos217B62oeM3Oi+fMm+s782V9NlhzPt/NtnHxP3pn8pJU50zzw941u3uvd+9f3nT3fWbFPqZ68xc/1yK9cX7S7avPp717v72s33TpYvEeKX6Rzb6z+WxRkqyLy9F72+Na1um8dw5qUb5m1XW55jpI8V5sL202Vduro9756O2yez56lt462XrdG4Psp/hDqy5cpfrDbt77zbF+u3HcWxbHjc21zea9X/6dTYvzmOpHa67rt9vGouq7H4pj1MW8PHAstlfXr61qWdXBftFsXRwTJDlb9cbEzX66eha7uR+e5P7bvbH+pf/9Si3r/vteqGVdKj5fkSTHJ737sXme7N78/bWsq0dfq2UlyV7zAcXPf74W9b/+0b+pZX30H3T7s7vbXn/W3Ic8X12vZc3Ke3XN56kvXqxFVZ1uu2dPFtX+s3ju6uioFtUceyfJrPiOlV3V3BtJusdBmufXmufydvm9pc3nxLPu3YzT+e6epWw+89Bc/5uV931mxcax3Ve3tMcEzfeZN9eIp1d6fcxZ+anj6rNuzd908Yxo+3mf5vtBqq3+tPe5Hr5Vi0qSLIrjxuZrS6vvc2n2Z+0zEzt65rB5Tq7eEDcP7BfPeO0ve9fsrLy2eXRUfJZp+2YtK7eL937zPSRJvnzYe5d/c1twv9jF7K3v9sKSZDn4i3ziibF//wfUDj+lDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPCDQQFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMEUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMEUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMEUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMEUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMEUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMEUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMEUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMEUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMEUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMEUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMEUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMEUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMEUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAY7IlHjx497n8DsAOeeOKJP0/yzLv/+82bz+QrX/nzYbnr9bA//XdcPjzvhbVtNrWo8/miltU2OfrW4/4nDPFg/vTj/icMszc97YVNp7Wo0+2slrXLjo56WdttL+vKlV5Wksw2D2pZp9O9WtadO7Wo3LjRy0qSyclxLev3v7Rfy/rFT/TuxQfp3YtJsnf0Ri3rK29dr2V99CPF8XdxPJwkp+mNiYtDkOr8bH951gtLd3y1SG+Muqv3YpLMTnrzs7vb3pzp8kHv3r//dndecelir91/sJ7UspbLWlR1XtFs85NuG3Jy0ss6POxlzabdtc2zbe93dutWLSrXrvWy9jbdtcYvvtzrz37h+d5nOz/ofa7JnTdrWUlyvLxay6qOv5vzs/m8l5XkfNobXzX76r3l7s7fm+6e9OZnBwe1qPoY5PikNwbZ3+5of7Yp7p0luf+wd+/v6ryz2g4nOU/vszXnuc2s8hBkZ7/HpsW8fF6oOeZ5/fVeVnOjerXqZSU7uzB3tuzt5bbbj+bvelfHBc31vySZbXvj1Ob87PKyd47hbN49x9CeD/L/r/m7bp4na57hae4LNvezkmR/tZt9zGzdOyf35ro3tkqSq4e9df3qmZriOK4+3rlX3GcqLhI3nx1pnn1N0l3kKWbt6vpf0p1XNM/lLaa9Nr+535kkk23vs51lN5/B2dU126R71vZs2vtNz9I9H93UbEMmKa5L7PAPrdk2Vu/99tmT4oLB6aY3lms/G9D09tu9rOY5huqaS7k/29U+pjk/a2t2n+aC3yfFhr957zfP2rbPCzWfqztb7ea7SKr9WXlecbzZzXf+NPfq2tOK6ntxdnQ9+vbtWlSS5PqV3XwO+G//thZVfy9Ocz26ueH/2lGvn755sxaVpHv8tTmW+9Ef7WU11yXqdvR9iu0xSPOMRnNts7nHVJ8MNs+ZF8+k7vJ6dHM62Pwem2Or9vs2q+tyO/qSlQfT7lnKvfnurvHUtA8tN1/EU7xm1f33o7u1rCTVa9bc86z2nc1zLkn13t/Vd6w016OT3R03Vt+LU3xfb5LuM87Nvdxlby44WfeePatrrhc0f2jN+7489m6O5ZofbVfft5kk9+71sprPiVdfuFl+X8fxwftrWc219svT3vmdN9bd8zvvec/Yv//xj38g3/zma9/rf7326NGjD4xNf3x299QoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwA8IBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABlNAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABlNAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABlNAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABlNAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABlNAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABlNAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABlNAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABlNAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABlNAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABlNAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABlNAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABlNAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABps+7n8AsNueeCKZDmxpLh+cjfvj73K2ndWykrHf27tN5vNe1vpBLSvLZS+rnHc2XdSy9o7u1rJyeNjLSpJNMav4o14Ur9np6nItK0kW0167v1r12v296Wkt67zYfiRJttta1GJ5Xss6PJzUsqp9Z5L739mvZV27VotK1uta1N5Bb2zVVr1mJye1qLNl775PkvSaxuatX82az7vzs+LtmJP0+uonn6xF5Z13ellJcnj4dC3rD36rFpVPfap37//lX9aikiSXLvayXnqpl/Xii72shw97WZcu9sbeSXL/rd74e1edbrrf4Z07vazmEmBxGTUP0uvLkuQLX+hlfexjvc926+VaVF740EEvLMkXPtfL+vSne2OQo5Ne1kH3kuXh272sp57qZTX7mO22u7ZZXNrMatXLau5BZtPciEn2l8UPd6/32Zr34qx6gyQ/9mPFsOIX2V67appsenta602v3d9f9ea57fnZYt77bNNpcf8sxbWJZkOcdPvP27d7Wc3zIM0Ni6S7OFHcsJiuevtn5SFIjk967VV3/6z3uWbT7hrx3aPd3D87ne7Vshab7tmT423vs+3f/lot6/Tmh2tZi/W3allJ8vaj3rrtpW/fq2XNr/Xuxcm2d7Yx6c47H6x7fUxzaHVeHO9cLc47kyS3Xq9FzW8+U8tqjuP2p92+M5/5TC/rt3oHXSbNOW57/v47v9PL+tSnalHb4lnKWZp9Z6pz6vlhcU+reOu3f2bNPYttsblqroM0z5MlycXiGcCc9C7adNX7TZ+Xx/pNzT2m6g+t3Dg+KJ6baM7Pms9uz8qP++zqnLq59r2X7vzs0oXiTXLS+yKb+z7NMWrSf/ayZVLsz06LzzEl3efEc6+3Hr0ojgvOrr2/lpUks+IZjclRb39kr/g7e/Ne9/nVq8XubHbvzV7Y672173zsY72s8jmX+bLX7i/ufLOWdbbstY178/LaZvMVgcXf2eTGjVrW9SvlQWpxXHDpQi0qZ8W1q8mdYv/SVnzwcnWtdxZkcq/4frIkV6703ndVPcPTfNit/LxP9eHcYjvcHMq1X6eYo6Na1Pyg+Dx18dY/23afHZkVf9fTZfFcXnOPqay5M1h/72BJ85mpJN317+I5l9N5b+1qWd6ra+7BT5p7x81BSPmFDOfp9Z+vvNq7Pz58s9if1d/p3BuDHJ3s5rNF77zTHTc237PcfDf2nZPeWkH1faypTs9ydd5bB5kui3PB5peY9A/clpwcFJ8XPCles/aiS/Ecw93i/tnlXZ6/v/pKLWtz82dqWZdXxWu27b5IoPrOny99qZf1uc/1sv7iL3pZSb76639Wy/q5a71zDLl1qxZ1vdi/JMkbn/gXQ//+o0dD//wPLG9dBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwRSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwRSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwRSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwRSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwRSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwRSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwRSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwRSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwRSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwRSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwRSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwRSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwaaP+x8A7LYn8iiL6dm4gJOTcX/7XWZ37tSykuTs2Q/XsqbTXj3hyXJZy8rRUS8rydnq6VrWtNmDHx72srbbXlaS482ilrWf01pW85pNu5cs59NZLWs+r0XlfNq7F9frWlSSZK/YYJ1uev1Z9/7Y64UluVD8bO+808uqdp7lMcjp4fVa1qVmf3ayqUXNlgPnLN/DerOb/VlzqD9L95rND3vXrDjNzX7x3n9QvO+TZJLzWtaNG70xyN76bi3rxo3Ltawk1YHqs8/2xleLk941y6p4zZqNVZILF/ZrWbNpr/042+7mHCZJ3n+j9z02nad3zZpjqyT51Kd6Wfu3/qSW9b73vVDLareN//JXij/sl1+uRV19/vlaVu7d62UlWTQb421xHaTYYDXb4aQ7rzg+6X225jLZZttb+06SvXlxDLJa1aKaY9TT8vx9b95d42lp/s6a7UeSTIt7Wk3NPabylnh17tn8bM1zLrPqAY10J/HXrtWizg96Z2rqe+J33uyFFc+DbHpbdd1zUOW8K1d6Wc1rNku3Q3vyyd449eLFWlT1mp0vu2dP9jfFswUHB7WoRXPeOV31spJcau7BP9VrHKtnC4odTHvfp3kUqrlWcLrt9S+b4rwzSaZXnqll7W1712w+L65dvfzVXlaS/Oqv9rKK7dX5qrfXP/nDL9aykuT8V/9VLWtSHFs12/zLvWFckuR43jtXs1/cY2r+pjflNZfMd3P/rKl6Vj/JZP2gF1bcq2tq7yE09yHP5709puZef3Ne0dZcu2ralK9Zs49p7o/sLYvjnW15IaTYGJ/Oe3OmxY6OUZPkbN5b/2721UPfz/Eu23qbX/wim5t1xTOp7efqsiles+K+T9PVVfn5itvFgUGz3X/uuV5W8/1C5TnuYnPcCyueTWrOceuv7Gs+q9LsO4uTmPaZiW12c71gti62H23NB/mefbYWdbl5Vv+k2zY250zNd8rNivuCzTXbJJkcfauW1bxmy+KtPymez0hSHac211yavXR9/r6jc+rqYbn25kjxszXPnjTXCprPgyXJojnkKbbDzZ2Y9p5406zZXhV/Z/ff7s5x//qve1nN1yw/KD5vPy//zprvErh80BtfNe/95udK0n/4sqTZDC+2xXNySa6uimHL4jNazXlus9FPqvOz5hpP9XnBXX2JblK9P1bNaW71vVrlAU9x/6z50d486bUfV690z0xUn718/fVe1uc/38t66aVeVsqvAtzcqkX90fwXalnP/tNaVJLk9uCv8Ww3X0n29+qudgIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD8EFJAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABlNAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABlNAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABlNAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABlNAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABlNAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABlNAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABlNAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABlNAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABlNAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABlNAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABlNAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABlNAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGCw6eP+BwA77tGjZLMZ9udPl08P+9vvtr3Ry0qSZbGFfuutXtZTTxVrFxfvjyRZTM9rWefNGtDbbS3qfDqrZSXJalUMG9cU/h1n2979MS2PJou3Y9Vkc1rL2lvOa1lJknUvqnk/zra9a5byfd9siS/Pi43j0Ukv69q1XlaSRc56Yc3vsdhRn267Y5D9ZfGaFRvH5hj1rHzNZtveNdtf1qKqg6tpeazf/GzPPlv8bAcHtai94hw3SbLptVdXrtSikhzWkjYntagsqhPq5M/+tJf1kY/0+rOjo1pUDnu3YpLkjdu97/H68lu1rDub3nrj1SvddvjrX+9ds3/yl1+oZf3tZ1+oZeWrL/eykvzx6hdrWT975/Va1tlzvWs2azbESU5vfLCWtdg+qGU1x97rTXdesS2utVfXCopmzQ3PdNcmJsviBH7dW2ifzvdqWUl3b3CS3viqmbVcFveNM/T4x9/R3Pdp73k2zTa9ccF22mtDqnt17SOWt271ssprPC3z8pb4rjZYzTt/1tzvTLIu7jPtat/ZPuN14UIv6+Skl9WcVjTvxSRZFNcL3szVWtbV4lj/rHqCpzr1TPN0UvN3NiveH1//ei0qSfLRj/Q+22lxDbC5jrooTyvOyms8LYt5cf/s05/uZSXJb/xGL6s4F2w+p3Lpq1/thSWZfOxjvbDiNasuFdy5UwxL9ptne4sD8PP5opa1N+/O3x8UxwV7y+JYv7gHeXnVXEdNMm8egN1N3bXv5Hzaa0OaaxOL4hpxe49pMd3NswVN5/Pumktz77j6zHFzIbX8QOn5Qe+c6KJ4fzxY9+6PvfXdWlaSbFeXa1nNtYnmOll7rH+W3hhktj6uZVUfVClv/JwWr1nzfQzNLqZ9jmFWfP6s+vxqcR1kssMHyprfY/N3dud2L+v6YXnNpflFFp+xOD3o7fU3x95JMluf9MKa44LmMzjtdvjl4jNhzz3Xy2pu/LQHPK/3nnVrjq3OVsX3KbbPkxV/182us9pctV+81nwXybK3DtJcl2hfskVxn6k5Z2qeWd4W986S7pnDXX15Y/1dRs3DtsWxXHM/azrtPgvZvGSz5gs3iwek33mnFpWkOtTPT/1UL6u5F3O87raN1eWCK73PdvFiLar+rtnqRKY4p77efD5x2127Ot70xqn7694zFs1nHjar3np0khzd62VdX/X2xM+W+7Ws2UHvd9Z+F3Fzz6LZT19dFcfDzUFjUp1Tr57rnYPa0ddMJEkePuxlLX73d3thn/xkL6t57iTJP//Hb9eyfum/16Ly3vf2si4vi+8cTPLvPz92LPftbw/98z+wuitnAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD+EFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDBFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDBFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDBFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDBFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDBFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDBFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDBFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDBFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDBFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDBFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDBFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD+D3t3H6ZZWtcH/ntqnilqipqiptNDN5127AwDDuMEJiwiGtCRgIqCMQYNeXE1Qlxj1BCvbDRXjIu53CQmcWV1dbk0JibmzWiy4sZdQ4gS39Ygb5IBxmHEBjtDD9P2FDVFTVFTU2f/6LkS5aWf6pfzbab687mu/gPOM+d7nnrOy33u+z7nBwAATEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICJKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMLHZld4A4GAbh4VszVav9GZcFqtLO9W8e+5drGWdOFGLymJ6f8et3d7fMEmyu1uLWtjermU1v9fm7FAtK0lWVqpxNc3dY2mpl5UkDz7Yy7r++l7WYvEPubPbrSG/OOvdchSjUr2Vah7USf/Abjl8+EpvwWR20mvzLBbbBc2DernYRk3Kv1n2alkHWvMis77eyyqe85ezVctKksx636166Tx1qpd1/HgvKynfyCz3sorH9NJS7556L937iqc8pZfVbO6srfWy2m4+3mxfrdWSbmq2G7eLO2OSr/7q4rnx//qMWtRNR4u/Wfna+cK8uRd29GgtanHzbC1r65Zn1rKScpu42Ejdm/XucdvdVouz3j31XrGvoNn0Xi7+DZNkodkP0vxDFge06n1JB7S/cWu7d8+0vLtRy0qSxeL+2Lz3XNjttRtnS+V5DOn9ZrPmbUwzqzsImdxySy+r/d1K6l+rOd5fHWMq3lM32wRJ1tZ6f8fmNaare6AtFuMOrXT3x5aD3AZ5wsO1qOq8q8Xd7vjqI4/0+ohvvLEWlc3NXtbiUu/8ccMN5WO6+Idcbjbmiu24+850f7NriufGI9f1+sn2VnrPpSx893fXspLk3bd+RS3rlmJz56Mf7WXlm76pGJb8i5/rzdF46UtrUdWpazeVx1ffd7LXlrv5eO961mzvzIrjgkn5eZ9q30Tv77gzK84FSbJd3B9XZ717poWD+nxFuueQ5rO5G5u942x1pT1Xv3jPdOZMLWrv8JNrWQub3fHV5tyChebFs3luLJ+Hm82CZt938zy8s3SslpWkOna8sdm7r6j+ZsU2atLt/95Z6d2/V+ddlQfFm89eNuekloepu5r7SPMdKwd1/L3c3mn+HZvvmThxovis2/oBfvdD8b6iejlrn/SLX27vaK/9Xe0na/fJFfeRvRM317Ka/SDtdwwu33prLav7bEDvfql5nU7SHfgpnvarbdT2b1Y8F1f75LaLfcRL7fev9vaR6pz24vWs+R7ApDym5dmRy6O4j1TbIMXn3xfKP9pScw79bu+7nV3v7R/t9+I0H6s7cl3vGnP/g712wZHru88hzI725ictb36olrWV3jyG7e32vLwD+nxicyJU2aw5D7B4g9Z8v/gNN/SykvKrjzd7YxZnisMjx3ZP17KWi+/VSpLce7IWNVt5ei2rOd+wXlSimHf33bWo3Hai127c2O3Oab/uumLY619fi/qJX+i1UV/wglpUkuTv/t1e1n3P+bJa1j8vfq+PvrzbH/0P/sG06//VX+0+4/apovuWZwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICrkAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABNTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYgpIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAExMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAiSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDEFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmNjsSm8ANA3DMEvy1CQnklyfZCXJdpKNJB9M8pvjOG5dsQ0EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgQFJAkn0ZhuG2JC9McnuSp+e/F2C8PslCko8k2UxyNsn7kvxWkt9M8uYkd43j+Gh/q88ZhuEPJ/mKJF+S5I4ki+f5+DgMw3uT/FySn0ny8+M4jpNvJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeaApJ8UsMwPCPJq5K8IsmxOR9fe+zf8STP/JhlHxmG4c05V5TxZ8dxfNfl3dJPbBiGL0ry7UnuvJD/LOcKZD49ybckuWcYhu9L8iNXsggmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAj28LV3oD+NQzDMOzh2F4Q5J3J/nWzC8eOc8Tk3xBku9JctcwDHdd4vrOaxiGPzgMw7/NuYKVd17i6p6e5P9M8tZhGD77UrcNAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAq5MCkvw3wzA8aRiGH0vyliQvnjDq+FQrHobhBUneluRPXOZVPyvJLw3D8Bcv83oBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC4CiggSZJkGIbnJ/mNJF+TZLjCm3NRhmH440n+Y5InTxRxbZIfGobh7060fgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4oBSTJMAx/OucKL376ld6WizUMw4uT/ETOFXmc2rcNw/A3CzkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcELMrvQFcWcMw/KUkP5Bk2Od/spnkzUnem+T9j/3vR5KsPfbvxiTPTHJ7kqXLu7Wf2DAMJ5L86yRP2MfH/0uSH0/ySzn3HT6c5IlJPi3J85L8qSR/LPP/Hn9rGIZ3juP4+ovcbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK4iCkhexYZh+FPZX/HIh5P8yyT/NMmvjOO4u491X5PktiQvSfLHc64448IlbfAnzpkl+YmcK155Pvcn+eZxHH/yEyz78GP/7kryD4dh+Kwkr0vy7Dnr/MfDMNwxjuMHLmyrAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuNpc9oJ+PD4Mw/D8nCsIOa945D9M8tRxHF85juN/2k/xyCQZx/HRcRz/yziOf28cxz+a5ClJvj3J+y9pwz/eNyV57pzP/EaSZ3+S4pEfZxzHX0/yuTlXNPN8bkjy2v2sEwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgKubApJXoWEYbsi54oiL5/nYg0leMo7jXxjH8YOXmjmO44fGcfyeJE9N8opLXV+SDMNwY5LXzPnYvUlePI7jfRey7nEcP5rkq5O8fs5H/8QwDC+6kHUDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABw9VFA8ur0w0mOn2f5fUmeP47jz13u4HEcH72M6/2rSZ50nuU7Sb5qHMcHLmbl4zg+muRrkpyc89G/dTHrBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4OqhgORVZhiGL03y8vN85KEkXzKO47tLm3RRhmFYTfI/zfnYa8dxfPul5Izj+OEkf3nOxz5nGIYXXEoOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5sCkleRYRiuTfK9cz72DeM4/kZjey7R1yR50nmWryf5Xy9H0DiOP5Pkl+Z87FsuRxYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHkwKSV5dXJvmM8yz/mXEc/0VrYy7RV89Z/sPjOG5cxrx5hTdfNgzD+QpaAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcBVTQPIqMQzDQpJvPc9HHk3ybaXNuSTDMDwtyWfN+diPXObY/zvJB8+z/AlJ/uRlzgQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOCAUEDy6vFlSZ52nuX/ZhzHu1sbc4leNmf5W8dxvPdyBo7juJfkX8/52LztAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4Co1u9IbQM2fn7P8dZWtuDxeNGf5z06U+7NJ/vJ5ln/BMAzXjOP46ET5j0vDkCwv7U22/p9/U68O7uHDi7WsJLn11l7W9nYvK0u9v+Pp07WoJMnNa5u1rPu2D9Wyjq1s1LJWZ1u1rCRJcd/f2F3uhRUtrn+omnfkxsO1rPtO964xS0d7WYu75eNsaakW1byezWa969nibu/6kiQb273vtpve9ezQyk4tq9u4ShbPnKpl7Ry/uZZVPV8Vz1VJsnjyfbWsd272frOm48e7eSsrvWv1yTO9c2PTysqV3oLpfMd39LJe/ereMb3Su7wkSW4+2jsXv/GNtaicONE7pk+cqEXVffCDV3oLpjErjtAcPdrLSpL3nerdVzS/20G970y617N/9E2fU8t65929v+Mzy/cVP/xrz6xlff3Lz9ayNma9a+fqZrdv8wPbT65lNa8x11zTy7rhhl5W2+5uL2t51uwnK36xJPc/1BuLue66XtZqphtv/1gbm70+kCRZXemdsLa2e99tyjkSH2tjc7WWlSSzapu4mdVrN5aHELJcHBTfLo6JLy71dpC9dM+NC+vr1bya4zfVopptqyRZLAY2z43N6cV75X6QU8X+783N3ndr9hG3J583j+v19d5vdrg3DSq75TbIqVO96+fTD/f6rtKcwtNuEzyxNw65sN2bD7K6Uuy3PbNeizpxotfXmCSZ9Qb82+3vlmO7H+gGLhV/s5Vev36zTbBYfhDhttd9Sy/sNa+pRd3UnC90sjvR5c+M/6GY9rJa0uqs2ODZ7I6v3ny42B+92+u3bQ5T159DOKDP+6yu9MYQ2habN03lPsCWvaXus2dLzb9jsTG32jyBpDtBujrmWey8qrb1y3O8dpZ67YLF2cGcW9Aco25b3C5eO4uDTM2x3CRZLMZV59UU+4i3l7r9jc19f3GtuIOc6vUnbR3ujb8n3blQC8W5covrZ2pZ96x3j7Onp9hX1pwMdffdtaj7P/+rallHynPaqx1K995bi9q85dm1rNWD/LDsyZO1qMXiRJeddOcmbRfzDuze2J4zUewHWThTPO+vrdWils/cV8tKUn1xwfJm7x5ma+1YLWs5xWeLkmzt9s6Ny6d773NpPuC8M+uOITS7rlZ3i3MAi+fGxeI9bpLq+Nni6d5cqL3icwjNfomkPHa8WdxBivedxct0kmS12P+93J6jUdJsE7TtpnetPrTbu6/Y2O32bTbHjn/xHb2x3M+7o/dO562UnzkuDsW883Rvf6w+71OeB9Xs1j+23usj3jh+Wy3r4YdrUUmSR4u/2erJ3ljMR49/bi1rcbN435ny/KTi+Nnd6fVdHbuj1//XbqMuF0/8xW6QZFZ8QXDzIfGkerG+7XCvrb8zK74LrZZ0TvWdLsVntP7UF39xLSu/3J24+da39uZofNvtU5Uy+3jf/7VPqWXlPe/pZSX5+d0/O+n62+9m+lRxMJ+u5vcZhmEtyfnO6B9M8qbKxlyiYRhmST5vzsemegX8L+X8jx4+KclnTZQNAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADA45gCkleHP5HkfCXM/904jmNrYy7RZyZ54nmWP5LkzVMEj+O4neTtcz6mgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfRwHJq8OL5yz/+cpWXB7PnrP83eM4fnTC/LfMWf5HJswGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgcUoByavDnXOW/+fGRlwmd8xZ/s6J8+etXwFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPs7sSm8A0xqG4ZYkTznPR9bHcfztfaxnluRpSf5QkicleUKSrSQPJfmdJCfHcdy89C2e6+lzlr934vx75yx/2sT5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPA4pIHnw3TFn+SctiDgMw+EkfzbJy5K8IMniedYzDsPwniS/nOT1Sd44juPOhW3qvvyhOcvnFXi8VPPW/8RhGG4cx/GBibcDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAxxEFJA++2+cs/62P/T+GYXhyku9K8jVJrttnzpDktsf+fX2SB4Zh+MEk3z+O44P739zzBAzDkOTT53zsvsuRdR6nk+wlWTjPZ/5QEgUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+G/OVwSPg+G2Ocvv/73/YxiGVyb5zSTfkP0Xj/xEbkzymiT3DMPwFy5hPb/XDUmW5nzm9GXK+oTGcdxN8rtzPnZsym0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADg8UcByYPv0+YsfyBJhmG4dhiGH03yD5OsXcb8w0l+eBiGfzMMw+olrusP7OMzH7rEjP24f87y/WwnAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVxEFJA++p8xZvjEMwyzJv0zydRNux1ckedMwDDdewjoO7eMzG5ew/v2al7Gf7QQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOAqMrvSG8Dkjs5ZvpPkh5L8ycK2/JEkPz8Mwx8dx/FiCj3eMGf5w+M4PnoR671QD81Z/ilVQHIYhr+U5BsLUU8tZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwuKSB5gA3DsJTkCXM+9lVJvuA8yx9O8h+TvD7J25Lcn+SBJE/KueKUn5HkZUm+NMkf2Mdm3Z7kXw3D8KXjOI77+PzvtTRn+UcucH0Xa3PO8nnb2XZjktuu9EYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABczRSQPNiu28dnPlnxyDHJjyf5tnEcT3+C5Q889u+/JPmpYRiuS/JtSf7aPnJfkuSbk3z/Prbv91qcs3z3Atd3seblzNtOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArjILV3oDmNTSRf53W0leMo7j13yS4pEfZxzHh8dxfE2SZyU5uY//5O8Mw3DsArdLAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAelxSQPNiuvYj/5qEkXziO47+/mMBxHN+b5AVJ7pnz0eUk33mBq5+3vz56geu7WPNyrqlsBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI8bCkgebBdTUPGbx3H8lUsJHcfxVJKvTLIz56NfOwzD4QtY9e6c5bMLWNelmJfzSGUrAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeNxoFdzjyphXwPFj/cw4jv/kcgSP4/jOYRj+VpLvPs/HnpDkzyf5+/tc7bzv09qfr52z/EL/7lN7IMm7CzlPzbnfFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgI+hgOTBdqGFDP/GZc7/3iR/JckfOM9n/mT2X0DykTnLF/e5nkv1uCogOY7jDyb5walzhmF4V5Lbps4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4PFq40hvApLYu4LO/NI7jXZczfBzH7ST/eM7HPmsYhsP7XOXmnOUr+1zPpbp+zvJ52wkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBVRgHJA2wcx0eSPLTPj//YRJsxr4DkQpLn7nNdZ+csv3YYhqV9rutSrM5ZPm87AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuMooIHnw/e4+P/crE+W/J8n6nM88e5/r2s93Wdvnui7FvIz9/s0BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC4SiggefCd2cdnHkxyzxTh4ziOSd4852NP3efq9vNdju5zXZdiXoYCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPw+CkgefB/Yx2fe81ihx6m8e87yT9vPSsZx3Mr84oxH9rVFF2kYhuUk18/52Pun3AYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAefxSQPPh+ex+fWZ94Gx6cs/zQBazr5Jzln34B67oY+1n/yYm3AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMcZBSQPvvft4zPrE2/DvPUvX8C65hXEfNoFrOti3DJn+f3jOG5NvA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8ziggefDdtY/PPDzxNsxb/+wC1vWuOcs/4wLWdTHmrX/e9gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAVupDCfTw+vT3JXs5fLPRJE2/DvPVfSAHLt81Z/kcuYF0X49lzlr994nw+xguft9ULu/feXlaSs5vPrGUtLdWisrvbyzp8uJeVJHsrh2pZa9u1qGRppZe13fxiyd7Sci1rdXenlrWTxVrW1uzJtawkWd7unfcPH+7tHwvZq2Vtpfe9kmS5uO/v7vb2/ari9SVJVme9/XFn93y3KZdZsxHSzEqS48drUYvbG7WszHpdFlvbxX0xyXLxNzvyYC0q11/fyyo3G5u7Y1aKze/mPVPzb5gkp0/3sl7xil5W8fSRQ2u9NkGS7BXbqSdO1KKqx9nibrGf7PSZXlaSG2+8qZbVPF81++QWNovtuCQnTqzWsprtgoPaj5okr351MezkqVrU8efPG9a5jGYnellJXlRsNzYbV6u39L7Y3kq3b7PYlKv2N+6ddxj68mrfCy4e1NkUm5u9rLW1XlaSI7Nef3S3v7G3M66sdPvZm+eQ5aXiWEyxv3F1pXv/fna9990OrfSO6bPrvX2/fGqs9rmsFtsgKZ6G2/fU9c7UA6jebiwGLhTH37O+XotaKJ8cjx/vnfebzcbF4lh/+0BbLJ4bl9eaHXO977W41L2+HD5cHINvDrAe4Amw11Z3/eL+2DxfFffF9hjCmTO9Y7p5SK8uFdtWR4/2spJsNedSFg+z5Wb/X/k3y513dvNKtpZ681+XDxf7vpPkxS/uZRUHqrdmvbH+9vWsOd6/XLw/a/az3/9g9zmEIzf2/o5Lxf2xOX++3U+2ekAnXjXHRtq63XK9/WNj92A+L5gky80+njO9eaKL1X6Qbj/ZYnP8rHjiX91t9rms9bKS/gW0pdkAb/8Ni+2C5n1FVnrnxuZ01HOBxfN+cd/fOdp75qF535kc4PlCxXcktLsbs148YTUfdrvlllrUtc3LWbmfbG+l1we4cMcdtayHH6hFZbXZJkiyN+uN+yw0+6OL41nNOcRJsjvrXTsXTt9Xy6pPgG1qNvYP6pyJ9v5xQJ+LaZ6vNja7z46szorPwNcb4AdT9Tdr9tsW+wo2ttvvQuvlrRbPjc1nZdsTGZrvipw17wWLv1lzvmGSbBWP61nxXrDZRJ2V+0Gah3X13rPYHG7P8WrmfcZn9LKaB1p7qO6RR3pZzVvPg/qYSl3x/qz5bED7fQzNZ5z3nve5tawnFPv1u4P95bxbb61FHW9O1y9e0Nbb01xuva2Wtb1ei8pycTL22bWba1lJcihna1nVZ3CKc08efLA7F7v5buy8/OW1qK3nvbCWtbz5oVpWkry0eS7+tE+rRd13uFdr6lgt6ZzjE98zXXvttOv/VHVwn1whSTKO40NJ7pnzsbWJN+OGOcsvpNk/r4Dk8WEYppyl+T/MWa6AJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB9HAcmrwy/PWT5lwcX9rP+/7ndF4zieSvL+OR+7c7/ruxDDMBxL8vQ5H5v3twYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOAqpIDk1eHfz1l+2zAMyxPmP2fO8nkFIT/WG+csf/EFrm+/XjRn+XvHcbzQ7wIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBVQAHJq8Mbkzx6nuWzzC/yeFEeK0z5h+d87DcucLX/Yc7yLxuG4ZoLXOd+vHzO8jdMkAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMABoIDkVWAcx/XML274hRPF/7Ek84o5/ucLXOfPJtk6z/InJ3nRBa7zvIZhOJTki+Z87CcvZyYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHhwKSV49/Mmf5K4dhuHaC3L84Z/nJcRx/80JWOI7jZpKfmfOxb76Qde7DNyRZPM/y30nyi5c5EwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgANCAcmrx+uTnDnP8qNJvvJyBg7D8LQkXzTnYz99kav/R3OWf8kwDHdc5Lp/n2EYVjK/IOU/HcdxvBx5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHDwKSF4lxnHcTvK/z/nYPxiG4YbLkTcMw5DkhzN/H/uRi1n/OI7/Ick7z7cJSV57Mev+BP56zhXY/GQ+muQHLlMWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5ACkleX/yPJh8+z/ClJfugyZf3lJHfO+cwbxnF89yVkfM+c5Z8/DMNfuYT1ZxiGz03y1+Z87MfGcbz/UnIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA42BSQvIqM47ie5DvnfOwVwzD80DAMw8XmDMPwyiTfO29zknz7xWY85l8m+fU5n/meYRhedjErH4bhaUl+KsnsPB97KMlrLmb9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXD0UkLz6/GCSt835zF9M8q+GYbjxQlY8DMMThmF4TZIfyfx963XjOL79Qtb/scZxHJN8U84Vo/xkrk3yk8MwvOpC1j0Mwx9N8p+SPGXOR79rHMfTF7JuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArj4KSF5lxnF8NMmfS7I556NfleSeYRj+6jAMR8/3wWEYVoZh+NNJ3pXkf0kyzFn3byb5q/vc5PMax/HNSf7OnI89IcmPDMPw/w7D8Fnn++AwDJ8+DMMPJXlT5heP/E9JXrvPTQUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOAqNrvSG0DfOI7vGYbh65L8RM5f7HEtyd9P8veGYfi1JG9Lcn+S302ymuRIkluTfEHOFWncjzNJXjaO49bFbf0n9J1Jnp/k8+Z87ouTfPEwDHcn+aUk702ykeSJST4tyWcneV7mF8BMkg8l+TOPFeQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA81JA8io1juNPDsNwY5If3MfHhySf89i/S/Fgki8dx/G9l7ie32ccx0eHYfjyJL+Q5Fn7+E9ufezfxVpP8kXjON53CesAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgKrJwpTeAK2ccxx9K8vVJHinE/U6SzxvH8c1TrHwcxweTvDjJW6ZY/+/xoZwrHvmOiXMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4QBSQvMqN4/gjSe5McmrCmNcnuWMcx7smzMg4jg8keUGSfzpRxK8nec5URTABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4uBSQJOM4/mqSZyT5niQ7l3HV9yT54+M4fvk4jmcv43o/qXEct8dx/JokL03yvsu02oeSfGuSzxnH8Xcu0zoBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC4iiggSZJkHMfNcRy/PcmJJN+V5NRFrmonyf+T5MuTPGMcx5+5LBt4gcZx/Nkktyb56iS/fpGreX+Sv57kxDiO3zeO46OXa/sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC4usyu9AbwqWUcxw8meU2S1wzD8KwkL07yrJwrxvgHk1yfZDnJI0k+kuR0kt9OcleS/y/Jm8Zx/HB/yz/eOI6PJPlnSf7ZMAyfluQlST4ryW1JPj3Jas59l48meSjJB5O8J8k7kvz7cRx/4wpsNgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeQApJ8Uo8VUDwQRRTHcfydJD/82D8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACoWrjSGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABw0CkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDEFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATm13pDQAOuEceSU6dmm79hw9Pt+6PdeJELyvJ2kova2Fzoxc26116tmbLtawk2d3tZZ0+3cu6eeVML2yluOMnWdjdqWXd/+BiLevI9Vu1rN63OmdvqXhcF4/pbG/Xoh56qHtuzPW9vWR1qXdMN3+zndlqLStJ7n9goZZ15KMfqGXlTPF6dsstvawkG9vF42xWPDkW243Ls71aVpLs7PZ+s+uvr0VledY7Dy+vlbu0iuf9w4d71+ri1+pep5McO9rbR665pnftPLRWPF81b3KTLBR3yJWVbvuqZWO32NZfu6mXleT0Xb2sO+7oZVUPs6WlYliyvt7LOpSztaytpUO1rPa188iRYi/Pq19bi9p+zpfVsvJzP9XLSrL9vK/rhf1U8bt9x3fUohbe8uZaVpLk1lt7WcW+9uZ9xfJS9/49m5u1qAcf7rVRj9zQ2z/20rtfSrr3FVvFfttmL8hu8ZhOuv1JO8VRreX0xuo2NrvjPmtrvaxmP+qhld6+uFXs00+618+Nzd55/6COVySZdp7Vx9i547m1rLuL/TvNpneS6snx7GbvHPLI+ORa1pHd3rUzSbaL15hmH+DurHceXmrO30n19iy7xf2jeYlp9zduFs9X6+u9rOPHe1mLxfulJNkuTqu5/5He3/HGG9szHDvuLbatku5UqGrzu3ih3kr32vmWt/SyPu+O4nMI28XG1fd9Xy8rydt+9O21rGcX+0HWi9eX5R//8V5Ykvtf9TdqWdd3p/DUrK50x32afVeLs15n+27xuakbbqhFJUm2tnu/WbMNstjsBynfv+8V98dmn0tzDKGvuPMXD7TmMb1V7EtKkuUU98fi3JPmOf+hh2pRSbrPee4Uz8OLa705qTu73bkni835ts2JV83v1ZxEnHT/jiu9ecRN5UdHslh9eJvHm+aYeHMeVN2s+B6eA3qNObTSvF8q/l5pN0GK7yy4oXi/1JzEkGShOJ/soJ4c23Pal88U36Fx9Ggv6957e1nN75Ukv/ALtaj7n/Oltawjw3otq/38avX9McV3HJ5d752v6qf8zd694M5S73mfxea7atq3083juti+aj5bVH6dYhZS3B/v7rVRzx69rZZ1qPybVc8hxReX7hw+VstqW94tzpVb6u2Q950+uG2Q6jPwu73r2dlZ73mf5t8wSd70pl7WN35D7zz8gVO9sdwnPKEWlSR517t6WXfe2ctqdsnddLQ7N6k5FtO8f7//kd5YbvPdnkmyvdu7zz101ztrWe8688xaVj6zO5fyt97Ry/rc7btrWWeWem39W27pZZ0pP6N1bPOeWtahZk2V4vM+h870/oZJqhNrdo/3rme/+mu9e8GnPrUWlaT8jrL3vKcW9ep/9cJa1tJS774zSX7gBz5Sy/of39o7pn/6p2tRed7znt0LS/La7552/Q88MO36P1V1ZzYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXIUUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABNTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYgpIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAExMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAiSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDEFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGIKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIkpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBiCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICJKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDEFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABObXekNAA64cUy2tydb/cbu8mTr/lgrK7WoJMndd/eybpudrmVtHX96LWtpqRaVJFlYP1vLuvlo8cttF5sL7R9tfb0WdeS64t/xzHov6+jRXlaShexV02o2N2tRR66vRZ1TPa57x9nO0motazE7tawkOXLddG23j/OR3V7Wrbf2stqKf8bMesfZ3myxlvXAA7WoJMl11/Wyqqfh0737iqyt9bLKFnc3ilnFE8iZ4vUlqe4j3fZV816w/JsVT1hHi308zWtM8TJdzUqS48d7Wc1T4+pK8R632WZM+VK93Tt/LC8Vf7Nm/06SI9cXT46vfGUt6vDhWlTynOcUw5LbZvf0wu68sxZ1dr3XJ7d++Lm1rCQ5UTzMmk25hx7qZVX7bJPMin2ANxSb+s0+l4XtrVpWkmpjbrnYltsr7vvttv5eevvjg8X7syM39g7qWfn2/cCO1RXPH7PieThJtrZ7f8dmf/TerDdfaGG3O1bXHNNqnveb/TuLu902SHPsuDl9rTiN4UBbXSqeQ9qNuaKVld71rNneaV6n257whF5We25vTflEfM01h2pZ115bi6r2ky2n1wZZWem1h5NkeVa8njUH64o7yPp29zc7caKXtbfSaw9X+xu/93t7WUlOnepl3XFHt2+i5iu/shr31rf2sp73vF7WoaXicbZZnsiQ3vlqb6l33l9s9l2V7zsXi5NdNrZ758bm91ostlGTVOcnLTY7pLd7X6x5/ki6/SAHdcyzPdX2oL4Vojn3pPksR5LsFMe0mvt+85huP1e3sdm8ZyruH8Xz1dJar68xKZ+Lm+2d7V4f8azYv5OkO6+92Nc+K+/7Tc2xmOZ5f6t4L1h9DiHpTuJpnoiLD6rs7BbbO+W5trNiG7U57PPgg71j+shQ7tssDvw0x33Wi4+kl1+LUw08W7yHWTpxWy+r/c6wF7yglnWk+UzpmV7U1qx7X7F0a29/bM4jPrRUvMacXu9lJdUbi2YbpDruU3xXXl2xc3Nx1jsPN+8rkmRxt3h/Vnw4oDo00nxvUpKNtZtqWavF46x5Hl5ev68XlnRfXFA8768V+zaXTxXfj5DkoSf13n2c071JgLPjvfZw+566Of81Z3o3TdvbT65lNZ/lSLpdxPfe28t6+tHeewB3inMbk+SRR3pZzXfQH2mOxZTbjes51gu7/fZa1OG7alE58tEP9MKS/NelXls/t95Rizrzy7WoLJzutfVPniweY0mOfHbv3PjR4unqpvTC7m+285PccEMv6y3F4+yFt3+olvWLd/faw0nyW7/V65e7/av/Ui3rFc+oRVXfDZIkR48+sRdWvPF8x+tqUfnGW97QC0tyxx1fOOn63/CG5MMfnjTiU9LBffMEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwKcIBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDEFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGIKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIkpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBiCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICJKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDEFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmpoAkAOABg70AAQAASURBVAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABNTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYgpIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAExMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAiSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJjaM43iltwE4AIZheFeS2z72/39akjdOmPtj39U7h33nU/95LStJ/vb7/2wt6xv/xlDLWv5o7zdbfN3317KSZOtV39ILe2LxN/vRH61l5ciRXlaSvOQlvaw/9+d6WS96US/r+PFeVtL9bq99bS1q41XfWsta3f5QLStJ7h+fXMs68iv/tpa189KvqGUtbp6tZSXJ1tKhWtbyd/T2/dx6ay/r+c/vZSXdc/G99/ayzpzpZTX3jyQ5erSX9e/+XS/rzjt7WadP97KS7Nzycbe7k1l80xtqWTlxopd1+HAvK0lWVnpZB/Xc+Lzn9bKSZHOzFrW31mvvLNz97lrWxvHeuWp1aaeWlSSZzbp5JTu7C7Ws4iGWpHsabu4eu7u9rPZvdijFe8/m9eyWW3pZ6+u9rCRZW+tlNXf+op0sVvMWz9xXy/q67zhWy/r2b69F1T391M/Xsv63d7ywlvUN31CLykMP9bKS5Mj731zL+ttvfG4t65WvrEXl2mt7WUlyaPMDtaxfPXVTLes5z6lF5cEHe1lJcsMNvay77+5lPfP2vVrWXnr3gkm3KXfqVC/r5hMH9zdbeMfballvOPPsWtaznlWLyvXX97KSZHm7d09933avb7N529m2POv1b77vVO/esznsUx6qy7Gl3nH2gc3ecdbsR33kkV5Wkhy5oXecfeB07zi76XivDXJQ++SS7rmx2W5sjvsszor7Yltx39/Y7u2LDz9ci0qSHLnx4N4ztSxsblTz7n94tZZ15PqtWlZ1MLc5Bpnk3eu9sZjmdMNDa8VrTHlQ/Oxu7zhbWqpF5S1v6WW1p5M1+7+b1863vaN37Xz2Ld3rWfM4O7T+vlrWOzdvrmU1xyuSZGOztz82n2W6b7f3HNM119SiknT7XJrzappNuYP8mzXb3/ed7p0/mv2oSXmO9MmTtait40+vZW1v16KSdPeR5hzA6s1ge+Cn2V9QnNv7gaXecXbTUvc58eqBdtddtaidO3pzABdP3lPLStId8G8+V9ccFG/+Dct9m9VxyOb5o9kpd4Af0tpZ6vXvNNuN7UcTm7tj81GmQyvF+6X2M1oH9NzYPKbbFneLY57N/aN5cizPTdpY6Y2vFrtc8syV3nhF/T1vxf3x3ad656vbZsX7s+Y9TFK9fv7i3b2xmM+7vfvutarib3Z2rTfmeWipeJ1uKzb2q2O5s+JvVh5E2FnpPRvQtLhe7CMuvzPsfScP5nt4nnm0+Jsd4AfC3n1vbx7DbUu9tv79T+xdp5Pkxht7Wc1njm9K750FZ1d67yxIkkO7B3Pe1bHDvf7GvVn3/UILp3r7432z3v7Y/M2az/us7nbvO5tt1MXTvX1x63BvX1xeOrjP1W1t99rDzfGs9tSk5m1M9TnP4k1M8zm3JPnIR3pZN6/33udy9kTvfS6HTr2zlpUk9x1+5qTr/4Iv+Mzcc88nfJfzu8dx/MxJw6+gg/mkLgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMCnEAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBiCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICJKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDEFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABNTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYgpIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAExMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAiSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDEFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGIKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIkpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACY2u9IbABxs1y4t5aZbb51s/S9/+WSr/nibTyuGJX/sll7W2vr/XMv6z2+vReWzX/rSXliShx7qZR35ru+qZW294utqWcuznVpWktx3uldL+9jXfm0t677bv7CWdexw9zfb2Oz9ZqsnTtSydndrUcnKSjEseXS9GPb859eiHnywFpUjj273wpIsrRXDmtfqo0d7WeXjrJq3tNTLKh7T9z+0XMtKkiMpXj9vKd5YbBfPVxPeZ34ii7vF3+z223tZa2u1qJ1Z9zjb3OxlHTp+vBdWbKN2G6nJ1tKhWtby9lYtq3keXm1eX8r7RzVv1hs2WSxeOw+l/JvN1mpRe+n1FRR3j+Zl+pzN4pdrXjuL9tZ617Kk2/ze3l6sZTVvO9sWDx+uZX3RF9WiUvxa1XZ+kuQ5z+lFFU/Dy0t7tazd3d51Okl27nhuLev5xfPwtdf2stptkK2lm2pZJ4rHWfMW5siNvWO67cSJ3jmkOga51B1f3d3tteWaTf3qb7ZSPs6K/d/PKs5z+chHelnXXdfLSpKNWe9+sDlHY2/WO3/09RoGzXumZl9BXXFMfK3Ybmz2g7T3j41if1JzOkizP7p7R9097zfPjdUOpaXVXlb5oN7Y7Y33Ly319sXmlKv2dLLmPrJZ3D9Ws1HL2lspHtNJjhS/W5aKO2Szo6zcuXlbcw5983pWHDduH2eHUuzjKe77x48f3Pv3Zv/3TnFMqzkFsDrRJcmh5vWs2CF9+Ewtqt7WnzXn9hYbxYeLu/7imft6YUk2to/VspqnkOY90+qsOIc4yV7xOGs2v5t9cgvNdlySbBf/kMXrWXO+ULt3c7E4h37vaO883DymF9sThppfrtghPWs25drPczQHtYoXmWbze7F8f1ZtYBV/s42V3nl4Nb12487R3jzKJFnc7t2/n93t9QEeKrb1m/ti0h0faV5imvdnW+k+39y8j1laas8uKGkPsDav1cVGyAH9WucU+1wWm/fU7bZ+UXMOfXf8bK0X1b6vKN4LVl8fs9m7h9kqPsuRJMvF36z5Wpzmvth+L85i8btVH90uNgx2VrrP9jfPxA8/3MuaXd/b95dXutez5hhCtVHcbDeWG/snTvT2xwceqEVl7/CTa1kLzfdqpdvvUp13td67el5/fS0qSfewbnbx7K31+tpXyrfvO+mdQ5qP+zQtnPlQN7A4H2SteEzvpHef2+xLOrvZva84NCv2NxbnTKyv16Kyu9IdG6k/E1ZSfeyy/E656ruIN0/1wop9xDce7T7vc+ONvay9PLuWdaj5LvPyyWrq957MrhknXf+nqgM6+g8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwqUMBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICJKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDEFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABNTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYgpIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAExMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAiSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDEFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGIKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIkpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBiCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICJza70BgAH3Npa8qpXTbb6u++ebNUf55aXPrcXluTGU8Wwz//8WtR119Wizu1/TY8Us5761FrU8vp9taysrPSykhw7WmwK3btUizp2eKeWVT0RJ1m99dZe2HveU4v6qTO1qHz9l2/2wpKcObNcyzr206+rZb31Od9Zy/qStZO1rCRZXzpWyzr0ylfWst73H3+7lnXz9j21rCS57/RCLevYa19by8rresf0kWZ7J8nerHecLcx67Z29o8Xvlb1aVpLszRZrWQtLvXbjxm7vOr261P3NDi1t98JOne5lFY/pHD3ay0qynK1e2Pp6L6t4TO+tHaplLWx27yuq+37z2rmyWstqWzj5vl7W8eO1rGabYHe3FpUkWbzrrl5Ys3+neM5faF8713ttkF6rMUl6187mdTpJ7jnZ+0s+4xm1qOpQTHvYZ2u7d61unkLuf6DXl3T99bWoJMmZYl/7Lbf0sprDZ+0+l9mstz8ePlyLqtpL72+YJM1mY/NS3Tymd3Z79xVJ8tBDvazf/d1eVvPaubPbPc7uvrfXbnzLW2pRedGLelnNrqSke5ydOtU7hxS7XOr9INvbveO6fR/TUp7ilY3t3r7fPoe0rK502/pbxeOseQ6p7h8HdWdM++/Y7QOsKe8fzfH+jc3e+aN5PWsPry4t9e4rVpqHWfHvuLBbnIud5APrvf7om5rtgub4e3EsN0lOFZ/3WSvOB1nd/lAta3epO2dicXO9lrUx6/1mzWZBfR7DAf5uLc05okmyOivOASz+aEeP9q4xW9vlGRrVW6Ze2GJxzHNrrTd/PunenzX7d6r9jbsHt8+leT178MFe1pEbe1lJsle8p27eezafPStPpcxeetfqZh/Pww/3so7ceED7UZPqybHbtFprpnUVB1irXe0nThTD0m0YFBtzzXZj8/5sedYdy23eDB5Ksa99s/c86cpa9/492wf0Pqa4L9ZbO82G46zY196crN++sSh+t42lJ9eyylO8qhbPHND3oTUnHG4X38WQVNuos+bY8cpaLao9p32x+JudPtP7zdbWetfO5d2NWlaS6o3udrG5szErvhdn1p0v1FQdF5z1rp0Hdaw/SW64oZe1uHm2lrWz0ptTk3T3kaWV4vvJivedW+U3TZwsvtq22W27cOoDtayNtZtqWUn3OGvexiwX+yZ2y/PMV5d6bZ6ltYP5nqZ2G6TZlmvOY2g+L7jafkareMJabr7jsPlei+K4z6F2R+p27yRytjjm2exGbT8r2+yXa15jmm2Cdn/0Rnp9gHvHe+3vkydrUVkqvmK57Vh6Y0wbK7155qvl8dXJn+MbhmnX/ymqOxIEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcBVSQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYgpIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAExMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAiSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDEFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGIKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIkpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBiCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICJKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDEFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABNTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYgpIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAExsdqU3ADjglpeTz/mcyVa/tj7Zqj/OmTO9rCQ5frwYtvu0WtThlVpU9tYO9cKS5IFi1tN6v9ne0WO1rIXdnVpWktz/QK+W9pETJ2pZ95xcrGU9/ejRWlaSnN3sfbdDz3hGLeuWtVpUstYMS9a2i2GveEUt6tbqnVT3ODu0ttcL+5t/sxZ18mQtKjffeUsvLElOF7Ne/epa1K/+Wu86feutvfZOkiwVz43LK70G+OnivnjNNb39I0muvbaXtbRUvI/Z7UXt7HZ/s83t5VrWocOHa1nVttz6ei8ryVZx31/e7XXybMx632v1zIdqWVsrT65lJcny7kY1r2Vhs/i9dosn/aTbuVlshGwfvqmWtZytWlaS5Pbbu3ktzet0+zhrWlrqZRXbOxub3TZqsyu12ZRr9+s3LS31+qObp6tm/99eDu5xtrnZy1qc9X6zre3ub9b0/7N3PzGWnXd+n38sXpYuS8VKdala3Wm0iQbdYGiKQ8uyPCEEeTAIZjGItZhxgmySRRAMsjKy8CZeeOGFF1544YUXAy8CbwYBYgOziBIMoIFt2MJAtgVZGFAcjkAIDbrBdIut7nKrVLwqXlVn4Z1mkiyi8yFx53mWJFDfvve+5z3vv3N+B+vdbPt7E67pz8zhYffZVuFeTHlN1158scv63Oe6rPI3i7dX03HBV7/aZZVTpnIKM9N+ttdvh+tJ4R5TPW78MDzjVd7PynHj47P2NyvnMeWe1v50c+rHZ90cd6bvi3dRvb9a3s/a+VnX9s/Psqg5Pm6v6bJ9hEOQdF5Rfq6Z9jfbhOegtnOUZR3GT9uVa5v1PaZSjodnZm7eDMeNm24ueHUangeJt1fLs0lHq26sf77qxgX1OL/sr8rP9uMfd1n1GORyunOb+9vuXE05bqyvs3KfqVwDLH+zjz7qsmZmDnZ0zaV8DuFWuA8z056rWYXjgmvXsqjc3qa7x1yE9874MeBU+ZtN+JuV6r26cj3pYN0t8pT7glfr3WyLMzPn5Rrgjo6tZmZnD9bs8rp+6SocN5Zn2k/Ctlg/OtLuDO6m+qxt2omU73PZ1c3cafdHVuFvVp6Te+mlLmtm0sO2TzddT3xUznHLSUyctz3LotKBwf4OP79antcvn92+XHdz3Jn2TOrzz2dRc3RYjuXavrGcn5Uuw1lMeR51ZtJ+P20f4X263OufmdkPFyfKd/aWN89dfg93OSS+CN9V81F4NmmmfX61fO6y3D8rz0zMzMzN7h5TLieV54j3t+Wi3MxMuKkV3juPygaybjd+yjFxOYtpz2d0Lrbt3Owg7EPqJUD+/zvadO8SnfVxFnWxatfJyvMgew8+yLI++9lu3vmjH2VRM9POBR9vu+/xLJxTH91pD0ItvZ17FS/7fVrs5lOfAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJ8iCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICFKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMIUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYQpIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAhSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDCFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGEKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIUpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwhSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBhCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALGz1Sf8DgN327DPruXjtS4v9/b/2ucX+9J/wj/9xlzUz89JLXdZ/eWebZf3tv51FzT/4B13WzMwf/3GXdePmcZb11a9mUfP3//5+FzYz63WXdWN1lmX9/jdfzrL+k//q81nWzMxPzrqse3f+epb1b7+RRc2dO+119sqdqyzrcvtqlnX/W1nUvPLVO13YzFxu97Ks/V/91Szr/O0sar7/Xvcdzszcvh2GHXZhd46zqHRMUPvBthsX3L+XRc0Xv9hl1cr2+HbYN772Wpc1M3N8HIZtD7Oo8h5z+/ZJljUT98Xn51lU2DxmDruwg3U3zp+Zef/+UZZ182YWNdtVNz87mKdZVu3hZ7rxzvWwr7rcHnRhM/PgUZcVdldzsur6q6tp54IP5laWdet4N7/Hei74D/9hlxUuuczxcXc/Ozp7P8uamfm3/1d3j7l2LYuazaa7zm7NB1nWzMw/+nrXN771VhY1d+92v9nBWfubff+8+80OD7vvsVyXONicdWEzc/9+t17wK3fL9hgOUu/d67Jm5oPTN7OsW8cXWdbV9W7OtHfvB1nWzMy///CVLOvOnSxqrl/vsvbOHndhM/PRx13feHS9XHDs7E273vijH3XjghsvdO3xYt21xZNwrWAmPscQriddbLo59cnhZZY1M/P4PPxsq279+2q6/Yr9R+38bHWzm5/Va6mVsm+sv8P96fqQqwnXG8P9s8tt13/MzOxvwr3BdffZynX9eoy6/+B+lnV1u1v73tuWY5D2Ecl03LjqrrODsO0/edLez25c7z7bd77b3c9OT7Oo3P55N6d+/7ybU2+7R/jSdj8z6bm8y3AMcn6WRc3Rtl3bLAdYe6vyXt0+N5XabMKwbi+m3GOaVXxgqPzNwjOp6SVdC+9nq+PuOivHILX9skGG32P5nomzsy6r9uBBN/cs99/ra7q8nZXtsfweT9blOG7mYXiO4XrYDX/0UZd1tO7WNp+G+8Yz7Wcr52e7ugc5M+n8/SBc1y/PTNTPjpT3zvQ5z03X6V+t2+fq0t9sG+7lvtSto+bzznXXHtN7Z7h29fDD9t75ox91Wek7eMJJzAfb9j1vzz/fZf30p13Wyze7/uPb386iZqZ9zjN9n0t4o74I90ZmZg5W4bm8cA+hlM8Fw+9x70F4jrh8+UO8yfT0sDsfvSrnFeH3WJ9NKteIy3PEZS+8utaeWS7ng7uaVa9dhVviabe/WnXjgic/bseNL5bt8bide1bSI1fT3s/Ke/Vq1bX9/XC+dBa+d21mZnXa3atXu3o/ixekV+Wculx0CW/U27gfLpvIfjinvhHOYa6/trvzivJ5sPK80FW8trl009/b4SMg/2/+jH5sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgI4CkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGEKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIUpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwhSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBhCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICFKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMIUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYQpIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAhSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDCFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALe+7Zs2ef9L8B2AHPPffc92bm9Z//73/hL7w+3/729xbL/e3fXuxP/wm//utdVu31OxdZ1vfvH2RZN29mUTMzs912WSeHl1nWP/vmfpb1hS9kUTMz8+KLXdbhYZf14EGXdeu0a4szM7PZZFE/eHSUZZ2dZVFz926XNTNzdHiVZT0+28uyyn54Vqsua2aupvsey3tn2Td+5jNd1szMtWtdVtgNp01/ve6yZmb2pusbL7fdNX3vXhY1r95pxyAPn3Rj4vKaLvvh+jorP9v+tptTP/xxN6e+fj2Lmpn4N1vt5hj1+DiL2mnleOdguv7jat31HzO7O94p+4+0Y5yZy+nGO+VHK+cVafuYmafnXdsvx3LxMkjqww+7rJ/+tMu6fbvL2jt/2oXNzNVht0Z8fp5FpdfZwbb9zb7/oPvNyn3Ish+u72cfPOjuZ6enWVS6VlDfPN9/0I0bX74ZrgGWm3VlY5zJ5xaZcgJfbvbPzMVmN8f6e5vdXQcp7T34oAsrG0i8uPnww+46K9fayzW5XDhpevhRN6+4cS0+d1Uqx6m7epChtqvjxnqjOlKOGWdmDlY73F9FrlbdfHomHhfsav/BL0Z573z0qMuamcvjz2dZ5Xrj5Wp359TlXkw5BCm74XiZLL2f7eoZr3ytIJyf7Wp/tb9p91d3dc5Udo5Pt21b3NXh98lx11+Vz0zNtNuQ5fdYrk3k6xLlPOb+/S6rPORVd1a7+mBMOLa6mPZ+Vl5m5VywHOvXl1n5m+1trUf/Ijw+79akd7Xtl2cpy2diauX3WI71676qfN6ntKvDuJndfa5uV9clZuKzlGEf8nSzm/3HTL9nUSnP2tZrm+U6Wenlw8ddWNzw67MulfJ+9uRJlzUz8x/+Q5d1506XlT7rVp5HnUkXXcprOp2/z+7Oz+rnPDPlou3MXK538znxXR0Pz+z23LNSvssoV54Hma7/2GVHmx92YWXnGC84puvf1jZ/Icr91fKzHax39GxSfO8sn4Hf1fPz6ftcZtozPOuTLKtcBqn36sozhxfbbq2gXGd//vkua6Z93r5c39nlR9KX3vP8whe/OO/80R/9af/rnWfPnsXVjDq7e4IIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4FNCAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAhSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDCFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGEKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIUpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwhSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBhCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICFKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMIUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYQpIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAha0+6X8AsNs+/njm/v3l/v4q7MUOD7usmZnT0zDs0aMs6v79l7Os27ezqJmZ2W67rMvZz7KOj7OouXaty5qZ2V9ddWGbTRa13R5kWQ+fdG1xZuall7q8r389i5rXXuuyzs+7rJmZX/ly1/a//e2u7a/XXVu8eTOLyvP+xb/ost5+u8v62te6rJn+/lkp28dbb3VZMzObzV6WVY5R79zpstLJ4MzcuN6NGy/C9lEq2+JM3US6sLIt1gPH7eooy9qfrkGuVt24cW9zkWXNet1lzczT865vLNcALzbdHOZge5llzcxcbLu2Hy65zGrVtcWy/9hl8bAxVXbF5bCgXI8u+4+ZmRde6LJ2da2gtuQe588r2346P4s74nJt82j7uAtbHXdZ8QT+8LAb8+zqWkF9naXnJu7d67LKjjhec3m87dZcTu7/YZaVLkjHv9n9B91v9urZv8my5u7dLGrv7CzLmpl55+xWlvX6neMsq7zH1HsjN14K11IfhX1IeeAwHjc+na5vvPHi0yzrMvxc+9uw3c+0bSQ8/3p1uzv/ujfhvuBMO7co79U7ukh8sI0XN8t5btl/hO1jE+6dzcwctNu5maty//0sXP+b6R9W2UXpAzgz++W9etP1jfubru1fHZ9kWTMzJ8fdb1aeczk63N2zjQercu65m2c0Lrftb7YfHmQoR/rp/Cw+l5eOr8LvsfxcR/G5vFJ5BjA9xLPuzm3OzJwchm0kvHUelGHxcwip8iH4+oGOHVWOr7bT9lel9Nn+6X6z9kx7lzUzs7ejY55yvHOwbvd9yuXGsu2X3+NV2H/sT3uNle+q2VXlvHMmXgcJ+/xy/6ze9ynXv8s+ZLvD/Ud5P9uGbb8cN9bjnfJe3T6D080FD+NzBeVx7HT7/fA4iyrb/Uzb9tMl4rDtv/RSlzXTPr9a3mPKtr9X79WVny3cq9sPzzdexfs+++U62YPufPTlafdMzH58Tq6cU5+suucQLsLnBX/84yxqZtr758H5D7Osh88+n2VtXmj7xnIsVz4GvA47kPp5nw/Ownf2nnZtv5x3nqzivbNwTbo8J3oQnlnerzdY192Y58mT8DebrtPf3RMTMx9+2GXduFaeXdvN58FmJv1s5fj7xgtdP/x40z47crDp5tTrm92cepffzVde1+n6zg6/523xZ/t/9rNl//6n1G6+kR4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgU0QBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICFKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMIUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYQpIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAhSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDCFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGEKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIUpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwhSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBhCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICFKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsLDVJ/0PAHbb/gvP5tXbF4v9/c2vHiz2t3/e7dtZ1MzM7J097sJu3syiTs+yqNzJ9odd2KNtFnXz5q0sa391lWXNzFxsulra63XXXx0eZlFzctz+ZrPZZFG/9mvdb7YKR+Vl+5iZmfU6i7pzJ4ua09MuK/wKZ6ZtjzdudFll2y/b4szM+fluZr31VpdV38+uphuD7E342cL7dL2kdbXaz7K23VB/jtaXWdbFtvsOZ+K5RfmjlVnxwPEg7K8uNl17LK+zp5tw3pkl/Uf1mLhSjr2fhu1+5hOYe0bKtpiO46ZdJztYu0//Ijz5cdfv37je/WaX264t1so+pGyO6dg7vsGswnWQ8qOle5Dx/P1oE+7VlYvEO3w/OzoM20i4uPl4e5Rl7erYe2bSxfbLaedMpZPp1iau3ngzy9pld+92WVfzy1lWOgY5Pu6yZua17tjVXE03FyyHBelawczMdBO0y1X3m+1vuz6/3RecWYV7dRfTjeWmHH6HbXFmZn+73Lnhn3d1++Usa2/Tfa6H4frfzMz1613W+eoky9ru6PrO6nB35zClcrxTP7hVnk2aHT1Tsx8vuuzq2aRN2A+X5zNm2rNQ68NujLr3qFtn3yvnMNOuAaZdSDg/K5+JmWnPeKV7dedPs6xV2H/MTNoe98obWrjZX5+1XYcD1fRs0ra7zi5W7XVWrqWW7aNcs82VB0VL5eeKzzGUn608K7cpz8+vunXUmUnv1ednWdScHIZ7/eG6xEy7dvXxx1nUTp/hefikayMvvphFtetJ5+3+6jYcp5bno3f1mYe6H07PFoQ7JGdnWVT/jpXyw4Xnrtp11N2dd6Z9SHmebNXuITw+777HXZ5Sl9J+f7rzr1fH3Zma2vPPd1npM+np4ZPdfV/H/o7ur9bnNk/W3brcRfhei4MJ1xvjl1qkXcgqPE8Wni2oz56k4+/y/a/h+ej6NOVmR894bc6yqHnppS5rJp7HhIsTPzvLotLnAmZm7t/vsspbdfm+zfLeObO7r0goHym9ip9JL88clvezWR9nUenzFdO2/Z/8pMu6vBY+KxuuSzw9b9vHw4dd1vXrXX+Vfovx4vfF4eezrBvl/simm5+dHNbvEehe/lA+c7wK1xvLtcaZ9h0ae+Ea8eW6G1vth8+Dzcxcni67dvXs+R09f/3/YXffwAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwKaGAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDCFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGEKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIUpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwhSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBhCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICFKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMIUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYQpIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAhSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDCVp/0PwDYcZvNzNtvL/bnv/vuLy/2t3/em29cZVkzMz84O8myXnn0/Szr7OzVLOtgdZllzcw8XX8+yzr67r/Msp7/z25lWXP/fpc1M5vDl7Osg3e/k2Vtbn4py7qK65GfbQ6yrNdey6Lm7KzLWq+7rJmZy23XRm7ezKLS36y22XRZ//lf6u7Vl7OfZe2v2nHjbLdZ1MlZeK8+vtNl1Rf1cTfWn7/zd7qsv/W3uqwHD7qsmdmcduPGo3/6v2RZ87WvZVEHYV81M+2g5+/+3S7rb/yNLqvuG994I4s6+N1/kmXNX/2rWdRR2e7Xx13WzOy/914XdudOFrV/ft5l1ZPB7qPN+vAoywp/sjlat/fOg/OzLuxROPG8fbvLKhvIzNz46aMu7Owwi+pm759A3/jbv51Fvf9f/80s6+V11xavTrt9mJmZW9/837Ksx7/232RZJ2V/dXraZc3MfOMbWdQ/+sl/m2X9j/9dNy64XHX7MDMz+/d+kGX9n+++kmX92q9lUema/szMyepplvWH73Zj/XBZYvam3UO42HQjrB8/yaLmxvXwe6wvtHD9+5/d6/rGL3+52xtZx6di98+7vvGd+13fGC6TzWrVnj3Z+19/J8t695e6cePdu12fv1qXM/iZg3f/MMt6eOPNLOvatSxqVvUTA9/8Vhb1Tz78L7Ks3/zNds5U2jt7nGW9/W43Lvjzfz6LSpeIT7Y/7MJm5uGzbl3uxgtdW1yV53di5RGN/e1Fl1Xe0Mo96pl5b/V6llUu2x52W0xztWrHqOU6SHlNHx0fZ1kX2/Y3K5d4yqzT026MWh4rmGn7kPR447pb3ynXrWZmnk732crt/vKaro8x1MvflcfbsC3Gay4Xm24ttWyPj8/aNeLS4WH32copU9t/tOPG7Y72++XY6uGH7TpqeZSyPJI64Ri1ftznW90WwoTT3PnpT7us8nPNzPzoR13W669150E+eNDdY25t22ch7513Y+LX73RrxA8edPeYV+5kUfkjfCfhAz/ff9Ttxbx6J3xnQby2WaY9Pd/NOcx2245Rw+F3Oj87WHf36fLs68zMyXF4JjU8XFCuk5XrVjPxWuq267DK+Vm9PlzOK158scvaX3U/2l58CLAcF5QOD7txQbnWODOzCcc8RxPuQ+7sxvHMo0fh2sRxN39PxX1jeU60HO/kz9uHyhaSniM+DN+zXD+IkC6WdZ/t1ro7Hz1zHGbNvHwcNv5N95sd/e+/m2W985e6Z89m2sv6d7uvcf7nN/6PLOs7/+lfy7JmZr50t8sKX4szv/Vb3bzz7/29LGpmZr74xS7ro4+6rFfudOuo//KbXfuo18nKae7eo+75sw+23bNnzz/f7iGU50Fevt3dqMtz3+U7KWfavvHatW5N7tvfzqJmvW73V8uliZs3w/eWhseFDg/bd/MtfV1fxeUdPi12c2cGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4FNEAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAhSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDCFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGEKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIUpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwhSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBhCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICFKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMIUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYQpIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAhT337NmzT/rfAOyA55577nsz8/rP//fXX311vvfP//liuX9w79Zif/vnfeWtqyxrZuYH97oav6enWdQ8etRlvXKn/c1SZ2dZ1HfunWRZd+9mUTMzc37eZd06fJplff/BUZZ1504WldufyyzrcvazrPJzzczMapVFPT3v7p2lo8P2flZ+j4eHWdTsTfc9Xm7bthheZun3eLHpvsf1OouamfZ7nLffzqLeP34zy3r59CLLmpl5vDnIsk4efT/L+uDw1Szr1vpxljUz83i6eczJe/8my/qD7S9nWV/5cjtu/OBRNya+ddz1IX/4Xtd/3LiRRc1LL3VZMzMH0/1mV+vuN9tus6h0zDizu+PvXR17z8zMZpNFlddZ+LHmYL2769Hl/KzsG8t1iZmZvfvvZ1mPD1/Oso6Ps6j0mp7Z3THI3nm3X3G57vYrav/u33VZf+WvdFn1dVbmlWO58n5WK++f+5uuv3q87fqr8t45E88t7t/Poq5ud+Od2t62W5d7fN6tyZVtv55Tl3OmXXWw7fr8mUkHIR9sP59llddZvg4SDrB2tW+sx6jlubx33+2yvvjFLqv+zcKhXDqvKM9Hl/ezcg4zE4/lwvFwvoFWKhddwoNX5b5gvU4WPhqQNv2yH65/s/J7LM837j34IMu6PO2eB5vZ3TXinT7HEE4snk43vkqfDYgnFlerbk59714WNbdvd1m1somUWUcTrjfG84qn2+5swdF6R+dn8cDxcrWbZ1LTMeqmfXak/HDlHlN5mdVLLuV6dPnZ0v2z+DBl+fxqueZSrqPW51/L77G8x+zq/H2m/c3K9rir66j1880nh91Y/+mmWyso11zqs0LlGY1d3Yup99/L62xX31Vzse0+10z77EipXJeo7a92c629bPv1GcDHZ909Jj3n8uiHXVi5AT/tb3ay6tZB0n3Bcp19Zh4+6fqQGy9074+5Ou7eHVMrx6nlvXNX5xUz7XVd7r/v8vysXC8o2346Hq6FL6x+vOqe9ynXCsr+Y6Y9czg3b3ZZ3/1uFvXBzS9lWTPt1OJb3+qyfuVu1xZ/sGnPv5ZNv3y26L33uqw33uiyZtIuZH7917us8hm+N9/oxjtlHZCZmVfW4b0z7PTLMUg9r0jP65+F7+ytN6pD5Vnbsj3u8vy9fMf4B2dd+yjfw/101a6jHq2W/c2+8OUvzzt/9Ed/2v9659mzZ19YNPwT5M01AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYQpIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAhSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDCFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGEKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIUpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwhSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBhCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICFKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMIUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYatP+h8A7LjVaubmzcX+/On5Yn/6T9puw7CZO3f2s6zyo332s11W7Sqsy1xWgH7ttTAsdnoahm27YdcqHOGVWbmwb7x/v8t65XaXNTNzue16rPU6i5oHD7qso9WmC5uZ9fogy9o7e5xlPfz4JMu6di2LmpmZvfOnWdbF6ijLevQoi1pyyvL/oOsb98sPF3ZXl6uur8rdDm/WZ13UHB+HYTPr8va56cK++OUsKv1cMzPHx906yJydZVF373b91cG2GxNcrbsxwczMPDjLos4Pu9/saH2ZZV1uw2tsZvbfezfL2tx+Pcs6Wl1kWekkd2bm934vi9p+7a9nWQfnP8yyZnXcZc3MvP12FrX+4peyrL1t1zfmW+XhRHd9+nKWdR7u1dVd45x1H24vHH9frLt1soMpr+lJG+Qv/VL3Pe7NVZZ1sGr3xFeH7Ti1sr8Nx42xp5tuzvTgrJt7lkty5Zr+zMxlOIffD7/IvU14ncXnhf7g7e43Kz/aG290Wet1eapm5pvf7LLu3u2y0jNeL7XrjQfH3eRiG54tKK/px2ftdXZy3M3hT4678Xf5oz150o69r1/vssr1goN11z7q66w8WlBuHZdbnleH3f3sJF1HnbnYdH3IahWenw/bx8G0awXluZpypX0/XG988lF77yzPypXPBuyvunvn6rC9d5b7I+X97CB8wKJ+DqFcT9pO1w+XfWO9TpYO9stx444+ezYz8+GHXVZ/9rtRX2blOPUqPJc3267/uArnMDMzR+HecflcXX1muZTuHYdzwXJs9XTbPjtSPsZX9vvl2mZ9QyvXk0pPJ9w/K9/XMe2culSP5Uoff9xlle2jXJuo5zCHh11W+T1+5jNdVvmceLq+MzNPw32fjz7KouYwXCOu+/zyfR3lfsXzz3dZL7zQZc3MXE53nT15kkXN9eu7uZc7MzOH3XrS0/Pumj4q54L1+s5qN9cA0+2z+Df7+ONw7So8V3Nx+Pksq36sLj13dXNH10Hi6+yll8J1slU38QxfDVK/FidtIvvrbiKz2dF558zM0WF3t07PuYR7MUeH4Rh1Jr3Qyt2Kx+fdb1Y/21/uDJ6sy73c7ossz+/MzNwoF8DLxatwEbCeUoevqknX9dv3udzKsmbaNlJm/eW/3GXVa8Rf/WqXVZ7Xf/P2WZZ1ue3e55KfR12FBRHCDfgPw3d+v/hiFpU7CgfgF+Hoe5fP1HzjG13Wn/tzXVa5Jjcz8/Jb3SDk7Kxr+zdf6/rGe+E4f2bmzTsLX9jPni379z+l6meAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP7MUUASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGEKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIUpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwhSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBhCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICFKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMIUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYQpIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAhSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDCFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGEKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAs7Llnz5590v8GYAc899xz35uZ13/+v7/22uvzr//19xbLPTxc7E9/4vbOn2ZZl+ujLGt/LrOsOT/vsmZmVqudzPr+/YMs6/Q0i5qZmePjLmuz6bLW6y5rbxte0zPtdRa63HZ13fcffZBlzUx7s97Rfni22y5rJu1ErqZr+2U/XNvV5rirl/RM2x4PVt29+uGT/Szr2rUsamba36xsj+XnOjm+6sJm5ul5d4852vwwy3r47PNZ1o1r7Vj/cro+ZFfvneWaS/l7zczsnz/uwspJ9a42xpl0Xe7qtOsby3WQq1V7nZWf7WLbfbbykt5lH37YZZVj/Xqt4Gjb3c8+2JxkWeU6+8G6nVeU67a7Ou+sf7NyvbHsG69f77LyfZ+w8V8ddnvie9O1/bKvmpnZP+vWQdKx/uYiy7qYbv99Zubg0ftZ1tXtl7Os8jerJxYPP+yu63INsJwL1mOQx2fdb3ayCff7b97ssh486LJm5vL0VpZVLsul54XCs40zMxerbiy3q8p945l2H2F/1fX75byznFfMzFxsus92sAn3fUrlosujR13WzFzcfCXLOphwrF+Kz7SXc+pd9d57bd6rd3Z0fhaOQZ5u2v3Vct9nVw9TXq7adbJy3Jif0ajUz2iVzyGEv1nZ9tN2P7O7D06V7WOXz+WFhwvS+ftZPMcNv8ddPTNRnvuemfSB2XKP6cUXs6j8DGA55Cnbfvnsdnp/mWkPsO3og3Xl+vBMu5+b7r+/0LX9p6vujOjMDj/rtur2PJ9Ou995dNhdZ+WZiV19N0i9l1uuEZe3zrLdl/POmX7vuJLuUcd7kE+33RpguYyanjOP19nLs73pGa8d7T9mJr1Zp+v64Zz68bTzipPD+FmVSrm/Gj87UirfkVA+u73LZ23LecyunnOZ2d35Wal+Z1j6rEr4o+3ydVba1fcm5fOKcKxv/v6LUbb9J0+yqLlxvWv75bvyZtq1iXL/fVf3EGbaMUg590yv6Rd3eH62DT/bjr4vr352NZ1XhB3xB+fd9/j881nUzMz89Kdd1sur7j0C5bP29WMI5XinfEXCK8e7+f66mZlb2+69OD/Ydu/FeeXsO1nW07tfyrJmln+u7gtf+cq888d//Kf9r3eePXv2hUXDP0G7uxMEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8CmhgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwhSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBhCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICFKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMIUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYQpIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAhSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDCFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGEKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIUpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwlaf9D8A2G2XlzPvvbfc33/wYLm//fPeeqvLmplZrY66sE0X9e69/SzrzdcOs6yZmcfn3Wc7e5RFpdfZ6WmXNTOz3XZZ9+51Wa+/dtWFrXZ3OPn+/a7W+mHYXZ3EF9rldH3jkydZ1Ny43l1nV6vuO5xp+8YyaxOOd46Pu6yZmb3tZZZ1vunaY/09lg5W3W/2waPuN3v77Sxq/uJf7LJmZq5f77LKcWPZDx8edmOrmZmjdXidnX8+y/pX/yqLmt/8zXYMUk4tzs+7rLOzLuv27e43exSuFczMPP/8SZZ1/TiLSpXjuJmZWR9kUeUK4MW2+x5/HM5xZ2ZeeGE3x/rleGd/Fa7JzczVdOOrcjy8t7nowsK+ambmcrr72dvfzqLS/bPLbTuvKPuQ+/e7rM99rstar9vf7Pd/P43LlNfZ0Sps+DPzeBvuiZ91UWXbP1i3Y5B3HnXrIK8fd+s7V+G44ODscZY1MzO3b2dRe49+mGWlG6zlAs/M3LvXjRuvXYvXCyLlfGmmXW88vn0ry9o7f5plzc2bXdbMvBvuaZXrIC+fhnPq+LxQOWe6c6fLSr/Gdqg/X/96l/Ubv9H1+3vlWG697rJm5tGjbkx8+3Y33inP1JTn5Pbjs7YH225ccLnu1grKfngvvqbTsVz42crrLB6iphOLg3CQehnur+ZH2tfd2kS5T12ebSyfU5mZefm0O0j8wVk3trp12v1mT1fdOG5mprx7bsLr7Chc1y+fiZmZuXmza/vb8NmAg3BSvQ3HOzMzq+Puui6f5yiH34/DsyAzM8dhVvmbHU04h4mfq7vYdH1x+axbun+2befUJ8fhPDc8C5Web6wnaGWHFX62cs/zu9/NomZm5ivhWaif/azLmp+cZVEffbYdg1y71mV9/HGXNYddn38evhvkP+r6kPI3K8/1lutk5XtqZtpbdfmbpWHxux/az9Y1kPJjXR22z460b7vaUeWhvJk5OC47xy6qfldNKjz7Xa5Hb9fdWD9+dCQd85wcdmO5UrkEMhMv8YT9VfmxynNQMzPr8sPd7zb8D8p1/U3bOR4chj/ao25x4uq0e/Zsb3b32f69cEy8DveN6zPtu6p8H0P53OXMzHbV5R09ej/LmnV3KLU8bzjTngN85WbX9t95t2uL9VnK8l2R/9N/350HeXzWjr9Lv/d73RjkN34ji5rf+Z0u62/+Vpc10z4L+eo3/2mW9c5b/0OWVb5b/72wX5yZeXO6wKs33syyboXvfi2fLZqJz12dd7tM+9P9ZiereHEzXON55c5xljX3u7WCW7ePs6yZmXm3+2yv3AyfEz+9m0WV7+CemeXP9u61z8J8WvzZ/NQAAAAAAAAAAAAAAAAAAAAAAADA/83evUfplt51gf8+lbcr1ZXqSnXldPrYtqFJmibTgFxMBMOACGGJooMy6DjjAtEZRS7KoI4Dg7oUl4qOF0YXyACKuHA5iMuZ4bJQVFSIqIAYQ2gjCbEJvdrT6ZPTJ6eLSqX67drzR/e4Qiect06ds78n/dbns9b5I9m7n99+a+/97Oe29w8AAAAAAAAAAIAiCSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZiaBJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDMJJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJkEkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzk0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGYSSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADMTAJJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJlJIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMwkkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGYmgSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAzCSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiZBJIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM5NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBmEkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzEwCSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICZSSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDMJJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABmJoEkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMwkkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmQSSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADOTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgZhJIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMxMAkkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAmUkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAzCSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZjamabrdxwCsgTHGTyd5+IX//8MPP5yf/qmfmi3ulau9PLg7O7VQSZKDg16sra1erMWiF2tzedgLliTLZS3UI4/t1mJdvFgLlWee6cVKknuffbwW63Dvvlqs7cVxLdbhcrMWK0m2t05qsY6XvWdMs25cZ08+2Yt17929++w43ftsM73fdrLo/raWYpOgHq/alitei3XFP2Szz3R0VAuV+y6Ur4/ijXZtuV2Ltbu1vnX+Rnrtxnc+2rvPmnX+Aw/0YiXdZ8zVq71Y+zvF+qr4R2z2l5LuM2Z3p1d/nKT7d1xXG0fFMcDmQGrZtYP1HGtv1h/by2u9YEmupTdGvK5148ZB95w1G3OHW/u1WOs873O86PXPNhe9+6xZ5zfrjyR55G293/bwa3u/7fCo97vW+nl20JsXXOd2Y7Ux11w0sbfXi9X8XUm3UVy89k92evVHc6wx6Y7rr+ulv87VcH0tVEt50cS1o96cxbquy9tYlufq1nRhTXOsvV1/PH6116e+b/HuWqwri1fWYu0vuv2z461e+2rzsXfWYjUXwB6md923Nddtrqv2vOCadgWrayaaY7ZJqietWV9V64/2ws2mNV0k2l4f3bSu61/b52xt+7lrek8nqQ4CXlv05sR30+ufNftmSXe84GRrPftM7TmEZh3SrPerY1frPInQ7Aw2n2ftc7bG67Fb2n3q6rqa9Oqr5tq19jKGdZ2nbrYbm2smknKfqdmPKT47n3i62x5uvgPfnH9f13chq+/EJN01XsX5keb7gu3vT1XbV8W6sfkudfucVe/rZl+w+Zxuz/us629rNr7Lqu+fFdvDVw56bZA1XZKXZH3XbTar/GR914Os81Td5lFxzWHzxxUvxvaYbfWcFRvFzb/jU0/VQiVJ7h29NcuHO701y83vltYrx+Y3w4rjZOvahUnWtw2yzt9ubH6PuLkm9V2Pre+3iJvzZw9dXM/5s/a3aq4se7+tOZz0jnf0Yj209a5esCSHF15Vi7X92M/UYlU/THn5ci3U8YVezoCk2xds1h/Ndly1D5P0F9aUNL9PVn83sTiY2lwfXZ2DXOeP67cnj1vWbBHgx3zcx+WRRx75UJsemabpY2YNfhut56piAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgA8jEkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzEwCSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICZSSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDMJJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABmJoEkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMwkkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmQSSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADOTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgZhJIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMxMAkkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAmUkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAzCSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZiaBJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDMJJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJkEkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzk0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGYSSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADMTAJJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJlJIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMwkkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGYmgSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAzCSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiZBJIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM5NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBmEkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzGxxuw8AWG/PPJO867H5ctUeHc1W9AfZ2+vFSpKtrV6sRfFpcPlyL9Z9e71YSXKys1uLdfFiLVT2905qsY6X3dzWx7mvFmtdG13N+iNJTor5z5v1VfMZs1z2YiXJ7tZxLdadd27WYp0serEOrtZCJUn293o39qOP1kLl1RcPe8EW271Y6dbFly71Yr3q/uIPK1eOh0e959kzz9RC5cKFXqz6A63YQVsU+7nNCmRj2WsTJN1ndVNzrGBzWXx2JjkpPz9bmtfiRnr99+aYXJIcHPRiLRbdsYl11bxG9vd6leOVq73roz3mcvVqL9buTq++SnEs6XirNz6cJFeL/bPdnV6sbp3fPWfNQeLHHuvFavYFF+U24+5Wr7564slefXXPPbVQuXbQbVs9+GAxWHFsYnur2TAoVvpJdov9mGz1Kqx1HZdIus/q3Z3e9dicg9xoDvAk3bHUZmewuD6j+ZxOkve8pxdr/7G31GLtVh/U3U7145d79f59y+JChvvv78Uq6/Y9e7Gav6u5riDpPqubmo/pzfL8arXJU/xpxSZqkm67sXo9Fp8x1456z+l1Xffd1lxT0zxnGwfXesGSbBcvksOj9Zzrb84xJclmcWHe9gMP1GI1HzCHy+6Y3Ha662pqiuM7y/I4arPePyy2QbaXxWfMVvecNddCNduNu4ti47vcFzzZ26/Fas4xHS9749Gbi+aamiSL8pzFOmqvaW/OxTTr/ebgZnmurjoPWYuU6kDZuo4PJ8nmUXe8oKY7kJrtRfFdlTVtyrWXMXTHyorrRNd0zUSSHKfXLmgOf28Ux1Gb6zaT5KR4zqrvBly+WgtVXeO1zm3Uo9446t7eus5XlBUbIc1mY/tdyOrVuK71VXnMpdneaY4BNr/j1V7H0JxDaL4bsK63dFJem5TiWMFB7yGzXR5zab50vNzqzTFV51fX9quD6VciJfW5uqZmo7j4HvDdd9dCPeeod+03x76r38UpjhW0bZXX1bTU5xAuv7sWa7P4Adjm+sbN5oRWytd+sY16dNRro7bvs+a3SB7a6a0HOSjOCzbff0+SS2/rxWp+g/7lLy+uB3m22z+r3tfFgbkrB706f7+YfGFZnkPYLPbPtoprC7aL32g6Lr87stkcAG9+y6j5Tszl4hrRJCcXXlmLVR37bn4oshkr6U4et8faW9btA8EnazxWex3ru2IaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4MOEBJIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM5NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBmEkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzEwCSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICZSSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDMJJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABmJoEkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMwkkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmQSSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADOTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgZhJIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMxMAkkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAmUkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAzCSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZiaBJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDMJJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJkEkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzk0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGYSSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADMTAJJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJlJIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMwkkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGYmgSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAzCSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiZBJIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM5NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBmi9t9AMB6u+OO5P775yt/uZyv7Bc6OurFSpKtrW68lr29230E89m4eqUW6+BgvxarmW+6fZ/dt3OtFuvxg91arAsXNmuxmvVwkmzmuBbrvgu1UDlc9s5Z/fmy6HU5dnZqoarX/v7eSS9Ykly9Wgv1spc1n2c9m4vyOStekM1nTPVGKz/QFove3/Huu2uhusrn7NpBr028u9Vr7zzxZO9avPee7jBks2/R7OceHPRiHWa7FyxJs5navD42jg57wYqN/WIzP0ly8WIvVvP62F72xiWqHaYk28Wb+qQ4dtWs89tjLheK4yDNH7ed5iRC96Tt7PTGG5uNkK2t3u/aXBaf00lOtnrtq5e/vBaqOt64vdUdc7lytfeMueOOWqhspPd33Nrq/Q2Tbp9pf29Nl9uUJ+ueeLpXN957V+9ZvVFs7zSfL21XDnpjV/s7vTG5emO/6HDnlbVY28Xn2T33dJ9n995ZHC+4XBwvaA4olZ9n9+0U411e0/mz8oBjeaisZl1/V9K9HJvz/d0+U/cC2Wk2eY7Wc37kuLieLCmvKSuOpe7u9E7a4VHvnm6uo0yS4/Sux+0Ux22bzcZye+d40Rsv2Cr+tGqboHyfre0C2KLq/HtSfXieFNcbNi3Kl2JzfmS7+uPWdL4iqY7x7OwUx9qXa/rwTHmtXHFicLO5YKi89qT5PKteH03NSeokJxd6czHNZVfrvDBvWexTL4pzx2v8uk91nOykuAaw2R5urutNko1mXVysr7aXvbGJ5vhfkm6bp9llKo7vNO/pJNlcFgdTF8WKuP1iTNHGwZq+q9J8UK/rB39SXg5SbKNuFJ+d1466z87drd5Ju5ZeG7W5iqH9LaNlca6uWQ232yBNzfVCzT5T872p4/I76c02avPdgO3mHGS5L9icg2/2czfX9F3qJMle75tQ2805hGZfsD242WwYtBtYJe13tDbWdO3JZrF/Vl9TUzxnzb7n7qK5brNbf5wUn2fV+dWi+lz/mo7LbS+aa1LX9ztv28VgDz24nmMFSfn9s629XqxmPVxu67/2tev5/dc77yz+rp3iB+xSHkudM/nHC1Q/sVJcC7IofusqKa8BLD6nq2Pf7fd9mt+PKfZhqnVVeX1Gc83EZrNB3IxV/Shl1vejzs3Gd/mczZ1TZRrlOZEPE+fzVwMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUSSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDMJJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABmJoEkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMwkkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmQSSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADOTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgZhJIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMxMAkkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAmS1u9wHw4WuMcUeSB5L8siT3JLkzyR1JjpO8L8nlJP85yaPTND1zmw7zhowxFklek+d+111JdpIcJbmW537Lf5ym6fC2HSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABrSQJJ/osxxsuS/MYkn5XkU5N8dJ5LGLnKM2OMtyV5U5J/muQHPpySMI4xPi7J5+e53/YJSTavs/s0xnh7kn+Y5HuS/NA0TdPsBwkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBak0CSjDE+NskfTvLbkrzsDEXckeTjnv/3pUkOxhjfleQvTtP0tlt2oDdojPHrk3x1ks+4kf8syUPP//uDSX5mjPFXknzrNE3P3vKDBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4FzYuN0HwO0zxrg4xviOJG9J8sU5W/LID2Unyf+Y5JExxreNMS7conJPZYzxy8cY/yDJP8yNJY/8UB5K8teT/Nsxxiff7LEBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwPkkgeU6NMX5jkp9K8kVJxlxh8lwiyZ8aY3zWTDF+ccAxPi3JTyb5rbe46I9P8iNjjC+9xeUCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwDkggeQ49nwTxe5NcKIW8mOQfjjG+aM4gY4zPS/JPk7xyphB3JPmmMcbXz1Q+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAa0oCyXNmjPG7k3xT+ud+keRvjTF++xyFjzE+O8l35bkkj3P7X8cYf7wQBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgDUhgeQ5MsZ4XZL/8wb+k59I8qeTfE6SB5Ps57kEja94/n//piR/NslbTnsISb5jjPExN3AMqwsd44Ekfy/JS0+x+08l+aNJfk2SC3nu9+wl+bgkvzfJP0kynaKcrxtjfN4ZDhcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBzaHG7D4COMcYiyXfkuYSJq7wpyddM0/SmX2L7lef//WyS70/ytWOMz0ry9Ulet6LsrSR/a4zxq6dpOk2ixut6/nd9V55LAnk9TyT5A9M0ffeH2Pbe5/+9Ncm3jTFen+Sbk3zSijK/fYzxCdM0vevGjhoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDzZuN2HwA1X5Tk4VPs96eTfMZ1kkd+SNM0/dMkb0jyl0+x++uS/Hc3Uv51fEWSX71in3+f5JN+ieSRH2Saph/Pc7/l767Y9e4k33CaMgEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADjfJJA8P77yFPv8uWma/sQ0Tc+eJcA0Tc9M0/SHk/zVU+z+P58lxgcaY9yT5E+u2O0dST57mqbHb6TsaZren+QLk/y/K3b9rWOMN95I2QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJw/EkieA2OMj03yK1fs9qYkX3uLQn5Vkh9bsc8njzFec5Nx/kiSl19n+3GS3z5N05NnKfz5RJq/K8mjK3b9urOUDwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwPkhgeT58Fmn2OdrpmmabkWwaZpOknz1KXZ941ljjDF2k3zJit2+YZqmf3fWGEkyTdN7k3zlit1+zRjj024mDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOtNAsnz4ZNWbP+P0zS96VYGnKbpnyV5x4rdXncTIX5XkpdfZ/vVJH/mJsr/L6Zp+p4kP7Jitz94K2IBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwniSQPB9es2L7D84U9x+t2P7gTZT9hSu2f8s0TdduovwX+ksrtv/mMcb1EloCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwjkkgeT7cvWL7W2aKu6rcC2cpdIzxUUlev2K3bz1L2dfxvUn+83W2vzTJf3uLYwIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAmJJA8H166YvvlmeI+uWL7nWcs9zev2P5vp2l6xxnL/pCmaTpJ8vdW7LbquAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADinFrf7AKh474rtvzBT3FXlXjtjuW9csf37z1juKt+f5Cuvs/3XjTFeMk3TszPFf3F69tlsXL0yW/FPPbM/W9kvdO89J7VYSXLlai/H7/7irLfjjVtmtxar/ZQ73Opdjxd3aqGyefnxWqzjC/fVYiVJFr0/5F7xetw86t3T2Sre00myXPZivfnNtVBPv+YNtVh33VULlSRZLHrPs41H31mLtXn//bVYx8vNWqwk2dzbq8W691//aC1WiuesGivJcXrXyPbRfG37D7JTbPAsug3HzRz3gj36aC/WAw/UQp3sdNsgxasxuXS5FureixdrsY6XvTZB0r2t95fv7sXa26rFOim39TfSG3e5r3fpJ5eu9mIV7+ntre44Wd761lqo7WZbrtjeaY41JkmxWzHr+PMLPX7UG/9r/g2TZPtSr0/d/HEne71z1nyWJcn+QXEM8OCgFmqz2ZDb6rWtkmTj6LAW6447tmuxtpfFa7HbO8v+Xu++Pkn3Wd2yuSjXjVtHxWjF/lnx+tgo1433FMMdL3t1Y3M6K83LPt0xl2ITpPqIOdnqXYtJqk+Y5vVx7aD3y3Z3yuMgxT/k4cVX12I9/VQtVO65pzu/urEszvsUx65OFt2/Y1NzGrI5Vffq+4vX4lGzwZNsFtupzbHU6hjgUbfh2KxBHj/ozWk11222NceujhfFNnGxutpO72+YRbf//tSTvVh33bWeY5vtdS7Na7/Zf2+249ovIhzvvbIar6U5RnzcXtNedLSm91l7DqG5fu3oqNci3trqxSovta32PZtdpu3i37E+Hl3sV+TChV6spvaNVmzMXVn2ntXNKc/FXvc+2yyuTzo6Ks4yFZ9nbc02z7quPam+x5TkeNFbc9is9g+L9/T2ojhfkbQHDHqKF8jmpd53BJLkcK/3LYH3PV0LldzZaxfsNueok9vQIeyofs8l3edZdSKy2K9ojrU331Npvzyy2fxta7rgcKv9XZyiZp+6ueZqb6+8nqw4TnbtoNgGObhUi1Uf/7t6tRcqvX7n/qI3zr7Z7guu70R1TXVMP931Qs3vuVwrzgvubnXvs+Y64uacVvM94OY7D0n3zcv2+2ct1feYkuzu9PpM1Xcein3B6jt8SZ56qlc33nNPLVT3vcvyOoajq71YzaqxORfzxNPdc1b9TurarjPvjulXwxXHC5ptufY0TDVesXLcbb4Tk27d2KyvFsW+4JoOuTynuCj1ylHvetzfKfYrivVH9dvA6X5jvDrvUxxzOSx/p31ZXE/WrBqr6w3L3yw4KsbbLn705/j+3rdB2prjcvvNdS7Fb2C2x8mennld3rPnNOPbeq4E54Xes2L7K2aKu6rcVcf1QcYYiySfvmK3f3Kj5Z7Sj+T6n957eZLXzxQbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAFzEJJM+HR1ZsvzhT3FXlvvMMZX5MkpddZ/szSX7sDOWuNE3TUZJ/t2I3CSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD4IBJIng8/smL7p80U99NXbH/TGcr8pBXbH5mm6f1nKPe0fmLF9k+cMTYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAvUhJIng8/lOToOts/c4zx0lsZcIxxZ5LPvM4uJ0n+2RmK/oQV299yhjJvxKryJZAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgg0ggeQ5M0/RUkr9znV32knzpLQ77B5LsXmf7907T9NgZyn1oxfa3n6HMG/GOFds/aub4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAvAhJIHl+/MUkx9fZ/r+NMX75rQg0xviIJF+9Yre/fMbiP3LF9lUJHm/WqvJfNsa4Z+ZjAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4EVGAslzYpqmtyX5uuvsck+S7xtj3HUzccYY+0l+IMnd19nt26dp+uEzlD2SfMSK3R6/0XJv0KUkJyv2WZXkEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgHNGAsnz5euT/OB1tn9Ckh8fY3z8WQofY3xykp9I8l9dZ7efTfJVZyk/zyWl3Fqxz6Uzln0q0zQtk7xnxW73zXkMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAvPhIIHmOTNP0bJLfkuRfXGe3j07yY2OMv3naRJJjjNePMf5Okjcl+cjr7PpYkjdO0/TeUx7yC73iFPu8+4xl34gnVmw/zXECAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwjixu9wHQNU3T+8YYn5PkLyX5sl9it80kvzvJ7x5jPJ7kXyZ5e5KnkhwkuSvJ3Xku2eSnJrn3FKF/Mslvm6bp0Zs4/P1T7HPtJso/rVUxTnOcNWOML88vfa5vpdcUYgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALwoSSB5Dk3TdJTky8cY35fkzyf5uOvsfl+S33YT4Y6T/NUkXztN0/FNlJM8l7Tyet43TdOzNxnjNJ5esf3DKoFkknuSPHy7DwIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOA827jdB8DtM03TDyT5+CSfn+T7khzdwuKvJfnmJA9O0/S/3ILkkUmytWL7L9yCGKdxsGL7quMEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgnFnc7gPg9pqmaUryf48x/kOS35nkj+TmEiA+k+QvJPkz0zS97xYc4gfaXLF9eYvjnTXOquMEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgnNm43QfA7TPGWIwxvmiM8dYk/yHJH8vNJY9MkjuSfG2S/zTG+OYxxkff7HF+AAkkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeFGSQPKcGmN8bpK3J/mOJB8zQ4h7k3xJkkfGGN89xnjNLShz1fX67C2IcRqr4rykchQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC8aCxu9wHQNca4M8lfSvKlpZAbSb4gyeeMMb5ymqa/eRNlLVdsb13Pq+I8UzmK03syySOFOK9J8tJCHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgBcdCSTPkeeTR35fks88xe7PJvmhJD+c5F8meSzJe5JcS/LyJPtJfkWST03y6c+XuXGd8naS/I0xxq+apunLz/gTjldsb13Pd6zYvuo4q6Zp+sYk3zh3nDHGTyd5eO44AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAL0YSSJ4TY4zNJN+T1ckjn0nyLUn+8jRN7/wl9nnP8//enueSTGaM8ZokfyjJ78v1r6svG2NM0zR9xQ0c/gce2/VsnqHMs3hRJZAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADg9tu43QdAzZ9K8sYV+/xckk+bpukrrpM88kOapulnp2n68iS/NsnPr9j9y8cYv/9Gyn/ewYrtO2co8yzuWrF91XECAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwzkggeQ6MMd6Q5I+u2O3tSV43TdO/uZlY0zT9aJJfleRnV+z6F8cYr7nB4q+s2H7HGGPrBss8i90V21cdJwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOeMBJLnw9fn+uf6SpLPnabp8q0INk3Tk0k+N8nV6+z2siT/+w0W/Z5T7LN3g2WexaoYpzlOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzhEJJNfcGOP1ST5txW5/cpqmt9/KuNM0/cckX7dit88bY7zmBoo9TYLLizdQ3lmtiiGBJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAL+IBJLr7/es2P7zSb5lptjflOSx62zfSPIlpy1smqbDrE7OeO9pyzuLMcZ2krtW7PZzcx4DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALz4SSK6/X7di+3dN0/T+OQI/X+7fW7HbZ91gsY+u2P4RN1jejTpN+Y/OfAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC8yEggucbGGK9M8tErdvvBmQ9jVfkfP8bYvYHy/tOK7R91A2WdxYMrtj8xTdPhzMcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAi4wEkuvtI0+xz4/NfAz/ZsX2l+TGkj7+9IrtqxJm3qxV5a86PgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM6hxe0+AGb1ihXbj6dpeu+cBzBN09UxxjNJ7rjObquO8wP95Irtn3gDZZ3FJ63Y/u9mjv/is7GR7OzMVvw9zVrs6KgYLFkstnvBtrZqoRbLWqi6RfF6bMbKhQu1UJuLk1qsJDk86uXS3s5hLVb1nm63Jhe935b776+FuvvuWqhsLovXYpKT9J5nx/e/uhZrM8e9WO1zVmyDbBTrq+bzrN1uPDjqnbP9WqTkZLFZjNa1cXCtF2xvrxereO1vpHufVe/rGfvQL1RtDy96z84kycFBL1bzGVNUfpxluzhgcO2o94zZuXhfLdalS7VQ9ct+88EHe8GK9UezvbO/1x1zuXbQe8bsFgcnmtd+e5ys2QZpDihtXH53LVa17Z10z1mz/94ccFyWJyyKv61a7x8Vz1m5kXpcHCdrjgGebPV+V/s2S3N+tfjbusMSvXZcW/Pv2Hx0tjXnR7YvNp8xvZt6ozlulVTbqZtHvefZ5laz3dgL9Vy8XsCn31cLlXvv6bVRT7K+z7Nqn3pZHNevLz7puf/+4vVY/Du253Kb1+P+othwvNyLdXLhlbVYSfecveQltVBV9THi4msla1vtN9c2lt11Vy9WdW3BVm+cvT1O1oy3uyiObRbXo9YXTRTHNpvXx2a1U91tozaf1YviuG330u/237e3eudsc3m1Futw2VvZ2393pBdw++hKLdbxTu+cbabcryies+b612rbaqd7zo63dmuxiqtcuu2dcv/9ytXetb+/0+ufHS57bbn2XO7xsnfOms/q5rXffHa2Xb16u49gJlvd/ln13f5eqPLzrNvYb4ZrvrtdHQNsd9CKP645319tFyyaLeJ036srrmlv3meLvV4bZKO45ipJ9z2EZoOn+Lvqc7lrumZ5sbO+3xFoVljV59lyTd8tSqprbbeaczHFdQzH5bm65U5vLVTzPquu2ywPlJV7nrVI6/zuSLNbsbu1nmuW2/M+TzzZ61Pfffd6rmNo39PNOc/muprtg978+2b53f577+619Q+L38VprtvcLDf1t4vvBpwU59+b7Z177y5/M2xNHRfXv67z2FWz79lsy3XbBN3fVv3+VPGd4/Yy8+Y5a/Yrmu8ctzW/VdOc9mnWw+v8+anqepCj4nePi53q7eZ3JpI8fmk91wCu89hmVfN7LsXvkzWfZUmyv9X7bdcWr6rF2i2uB2nmJ0jmHy9YvGSatfwPV2v8pRySrFrO+p7KUayOcysTSN4/xphzZv9XrdgugSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfRALJ9fbsiu0vrRxFsiqH9KnTt07T9FiSn1ux22ectrwbMca4L8lDK3Z70xyxAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeHGTQHK9/cKK7XePMV4y5wGMMe5Isrdit8MbLPafrNj+2TdY3mm9ccX2t0/TtCq5JQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOeQBJLr7dKK7SPJL5/5GO4/xT5P3GCZ/3jF9v9mpsSYX7Bi+w/OEBMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIA1IIHkevtPp9jnM2c+hs86xT6nOc4P9P1JDq+z/ZVJ3niDZV7XGGM/ya9fsdt338qYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArA8JJNfYNE2Xkzy2YrfPmfkwfsOK7ZemaXr3jRQ4TdNBku9ZsdsfuJEyT+H3J9m8zvafT/LDtzgmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAa0ICyfX3oyu2f/4Y4yPnCDzGeG2Sz1ux2786Y/F/c8X23zjG+IQzlv2LjDF2sjoh5d+epmm6FfEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYPxJIrr/vWbH9jiR/eqbYfybJS1bs871nKXiapn+c5C3X2WUk+YazlP0hfE2Si9fZ/v4kf+0WxQIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGANSSC5/r4nycGKfX7nGOP33cqgY4w/nOTzV+x2lOT/uYkwf37F9l87xviqmyg/Y4w3JPmjK3b7W9M0PXEzcQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFhvEkiuuWmank7yrafY9RvHGL/jVsQcY/yeJH/hFLt++zRNT91EqL+b5MdX7PPnxxi/+SyFjzE+KsnfT7K4zm5PJ/mTZykfAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA80MCyfPhLyR574p9Fkn+7hjjG8cY22cJMsa4a4zx7Un+RlZfW7+Q5M+dJc7/b5qmKclXJJmus9sdSb57jPE/3UjZY4xPTfIvkvyyFbv+qWmaLt1I2QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJw/EkieA88nOPzqU+7+ZUneNcb4ujHGq07zH4wxPnKM8eeSvCvJF58yzh+bpunnT7nvL2maph/L6kSUL03yrWOMHxhjvP56O44xPmKM8U1J/nlWJ4/8F0m+4ZSHCgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwDm2uN0HQMc0Td88xvj0JP/9KXZ/RZI/nuSPjzEeTfKmJI8luZLk6SS7SfaT/Iok/3WSUyWa/AD/IMn/cYP/zfX8ieeP49NX7Pc5ST5njPG2JD+S5O1JriV5WZ77LZ+c5FOSjFPEfHeS/2GapmfPetAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACcHxJIni+/J8ndeS6R4mk98Py/W+WHknzhNE3TrSpwmqZnxxi/Jck/S/Lxp/hPXvv8v7O6muTXT9P0+E2UAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwDmycbsPgJ5pmo6S/JYkf/s2HcJ3JflN0zQd3uqCp2l6KslnJ/mJW132C7w7zyWPfPPMcQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFgjEkieM9M0vX+apt+V5PcmuVoKey3Jl03T9DumaXrfXEGmaXoyyadlvgSZP57kddM0/dhM5QMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCmJJA8p6Zp+rYkH53kryaZK6njUZJvSvLR0zT99Zli/CLTNB09nyDzNyV55y0q9ukkfyjJr5mm6edvUZkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACcIxJInmPTNL17mqavTPKqJH8wyb9K8uxNFnuS5N8k+aokr5qm6cunabp0k2XesGmavj/Ja5N8YZIfP2MxP5fka5I8ME3TX5mm6Wb/NgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJxTi9t9ANx+0zRdTvLXkvy1McbLk3x6kk9M8jFJPiLJxSR3J9lKckeSZ5IcJXkqyaU8l2jxkSRvTvLD0zQ9Vf4JH9I0Tc8k+c4k3znG+BVJfkOS1yd5OM/9rt0k20nen+TpJP85yX/Ic7/jH03T9O9vw2EDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwhiSQ5BeZpum9Sb73+X9rY5qmn0/yLc//AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgKqN230AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOtOAkkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAmUkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAzCSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZiaBJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDMJJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmNnidh8AsN6mjBwuN+cLsJyv6BdaLLZ7wZLsbp3UYh0ezXiObqdF9zG3ueids1y+3It1cNCL9cADvVhJtpfXesGWxQpra6sWaqN5fSTda79Yh/zzf14LlU/5lO7z7H1P9mLd+wvvrMV6y8Gra7F+5cd2n2fN23q3eJ+981Lv2i8/zrJfbDfmqPeMedvbaqHy2tf2YiXptlOLN/UT0ytrse66qxYqSbLY263F2sxxLdbTT9VCZfue7vPscGu/Fmv7oNevuJbetbi7U3y+JLl20BubaP62k2zUYt23U+zjXj3qxUqSq1droR7feagWa6/4Z1wue9dikuxe+plarCde3jtn9271ntM5Ko4lJck73lEL9fgDb6jFum+nFioni+44+8Y7evfZ4f29+6zZajwqz43sLg6r8dbRYbpjm9VeTHGsYOOoeC2W51erc3VFm4tew/HaQXlOvFg3bm31fltz+K85BZkkV4r99729WqikeH1UY6V7jSyLz+plsU9dnH5PkhzMuc7qBe6+uxaqezGW+2fH6cXbTK+9c63YZyov8araXhTHk4q9mI3itZiU77NivX+8VZyDvHqlFitJ3nXQm6vbKY4BdtfUdOdimuMu28U58See6tUf997VO2c/81i3X9FcCzXrewcvsF0cSzoqT682XVn2rsdm9+zoqHufNfue28X1hifFdtxReUn7ZrENUu1Sr3H/rPmHPNnrtYebdWN1jimpXpDHO71z1uxX7G91GyEnxfHv7WXvejxujuuXJ36aI6nN8Z3qmFx5rm5np/d3bPbPmm2Q9thmc+1mt93Y+13tPnXzetzfaq7hWd/GfnPtZvM+2yy2d9ZZsw5pzle0243N9ULruu5qe6vecOzFKnZ0D5a9+dX9nV6/4ri91vao9/7ZyYXeO8fNtv67Huu+o3XxYq8ebn7OZXfZW8fwM5d7439J8tCDvXr40d7rYHnowb1arPZ9duFCL9ajj/ZiPXzhai3WcqdX5yfd+dUnm99NWtd1vUk21vTba9U/Y3l9dPM+W9e12Mfld/ub7wY0x1yaYwXN7/0kyeZW8ccVv9fRHJdo32fL5vrGNV3j1X4XcnNnTd/dLj6om+PDSbcNsq7PmOY9nZTXQu2tZ1tuO915wcPiGund4nea1nWdS5JcO+hdj/feXTxnxfdXu+94dtuN67ocpDnv0/42X/OcHS+K768e9OZ9ri268z7V754UbSzX8x3PJHn/+5vRer/twoVerOa3qpPkrruKbdTit4ib3/F65plaqCTz39fLZ8es5X+46rZKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM4hCSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZiaBJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDMJJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJkEkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzk0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGYSSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADMTAJJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJlJIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMwkkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGYmgSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAzCSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiZBJIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM5NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBmEkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzEwCSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICZSSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDMJJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABmJoEkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMwkkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmQSSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADOTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgZhJIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMxMAkkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAmUkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAzCSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZiaBJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDMFrf7AID1Nk6ezfbRldt9GLfG1lY13MliuxZrO4e1WFkue7G2dnqxkupvO7nwylqsFGNtLI9rsdbZyVav/thYlJuTe3u9WI8+Wgt18WItVNqn7P3vLwYrXh/3vqwWqvvsTLKzs9kL9trX1kJdfWstVI6OerGSZGtroxZrWWyjvuIVtVB1h+n9HZcXXl2LdVfxGbO96LYbTxa9uvF42Yt19921UMmlS8VgyXaz3VgcLzi4XAuV3XKXenerd18fHvXus+qYy07vpJ3s7NZiJclGsYH1kpfUQlWvj8NiOy5JcuFCLdSdzX7uY4/VQp080GvHJclGcXCiOtR+cFALtVGsh5Pk5MGHarGWvT9jtW5s9nGTVC/+k/TGClLsL20fFdtWSQ6XvWtkM90xwJbNtOd9ig2D5iBgsf4odwWT5XouW2qPETc1h1yaf8fm/Fl7rq4Zr9j8zv5WsV2w6K4X2tvrteWuXq2Fyn79IdPTbPNcudprfzfvsytH3f7Z/t5JLda1g945a46zXyuOsyflZ/VW77dtNvu55fWvF4v1fvP6aK5vPC6uK0iSreLfcW3nxIvtxuZ6w6S7fK15T1876LW9233B6rqaYmfweLFfi9VsM9Y158+aY5vNta9JtXLcLFYih0frWzceFtsg28v17FPv73X7FcfL3vW4uejV+8113+2+4Maa9nM3L7+7Fqu55ipJdTLmqFgPb+70HjLV9RlJNotjE8sUz1mxHm7bXl6rxbqW3tredZ5fbWq+W7R91LsW2+9CVt9x3urdZ8fF9Y3LnfJayuIlUl7aW3NcfE4n3bp4d6fXLmj2O9vzPs3H57JYN+43243Fuqr86MxmsXLcSO+ctftnTc1Xc1/W/IZGcUHqTnld75WrveuxOZzUnENoa9bF99/fi3Wy0/tmWPPds7bm2pNmW7/dBlkU3z9rtuXWeZxsXdcLdV9U6fYFm2Ptm1u9C6Q5198ec6nWV3u9dVfNeePmfFbSnYJvjl01tecFm+MFzbVyzf5Z833SpPt+YvO7Fk883WsX3HNPLVSS8lxMsS232fy+ePk7Xttr+t3vtf22ftlxce3J9lazXdDtVG+v8VqolmZ7p31LN+PtHhXXvxbbw+t8zprjZMfFMdt2G7WpeX00Y1VzSqT8HnDxD9mcG7nrrlqoJPPXV81vAn84Wc8RQQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAPIxJIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMxMAkkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAmUkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAzCSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZiaBJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDMJJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJkEkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzk0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGYSSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADMTAJJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJlJIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMwkkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGYmgSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAzCSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiZBJIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM5NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBmEkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzEwCSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICZSSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDMJJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABmJoEkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMwkkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmQSSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADOTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgZhJIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMxscbsPAFhzy2Vy6dJsxf/k0cOzlf1CH/uxtVBJkoOrvVj7b/7XtViHn/KZtVjbV6/UYiXJ4dZ+Ldb25cdrsU4u3leLleWyFyvJ4WK3Fms712qxNpbHtVg5OurFSpJFr/n6+Nara7He2quGs7PTi5UkW1vFYMXr8WcfrYXK3a/b7AVLcnTQi7Wb3jl705t6f8cHHqiFStKtivevvrMW6z1HvXr43ntOarGS5OmnN2qx7ryzFirf+Z29WF/wBd268ZlnerHu/dkfrcV6y84barF+5QPdRsi15XYt1u5Wrw5529tqobK316urkmR7q9fW37767lqsw51X1mJtHx3WYnWvjuT44qtqsf7R/1ULlc/4jF5d1e6+P7S4Wov11ku9Mbk3vO7+Wqwnn6yFSpLcW+zA//2/XwuVL/7i3thmc0w/SfYf/clarMe2PqkW6+HX9q7Fq/NNX31I2xd7sWacmvsg910s9qmL48NJsn3Qm2eqzjEV+zDteZ9mo+dkq9eW20h37Kqq2VDd6o0nNedG2tfHI2/r9QgffqDXz60uoTvodtCuLHtz4s1H9TrXw29+cy9We06rZeOgtz4j6a49ad5nzXH29jqG6vPsYnP9Wu8PuVtcB5Uk77rcu8/29mqhslj07rPtNNtWyeXLvVj3bXXXibZsNi/GpNo/2yyP8bScpNfvPCiu70qS+5bv6gUrNgyaK0+eeF9v/C9Jtu9sjrn0BkI2j3ptkGY7P0m2L/XW5eXChV6soqtXu/H2U6yMi3XjdrPfedRdA7i76LWJD9Nr6+9vNdv6zRcDuuMgV672xgr293rjjSflVV4b7bnBlmJ7p37OirF2d4pj7dU5yF6dv9aK56w59p0ku80B8PJ4QUt1nUuS42WvduwOk/WuxfrzrLiGvvmI2d3qvSf+6GPd/tnLX96L9eijvVgPP9g7Z+1x9oNi3fj4pV6sZhfmYnENcdJdR9xcK7ez07s+NosTnkdbxe+5JNnaWs/77KmnerHamnODr7pY/FZN8fpYLsvf6yi2G5uxms+z9rxP8+/YHCpozo0sy2MuzXcvn322F6s5lbu97K4BPNnqzcGv7Ts45RfFN4vxrqS3rmZ/r9iJWdOpsyQ5Lq68qr6jVX4Pofnjjott4kVx/qz5jZXnFNfKFYcAm3Mj7edZdcaieE8368b2d0/uuacYrHg53jt637pKumtEl8U6ZFlcl7dVftet6Ymneu2Ce+8ujjcW58+aa0ST8lKoYj/m4KBXf7Rf0WrOj2ymd5+dLHr1R3O9ULU9nO49fbzX+wZm832f/ZTfJy2etCde0ps7bvYr2t/A3F706sZLl3p14/29T2DW17lsvuORWqzjB3u5rZrXfvu17bnvs5Fp1vI/XLW/8wwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABw7kggCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAzCSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZiaBJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDMJJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJkEkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzk0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGYSSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADMTAJJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJlJIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMwkkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGYmgSQAAAAAAAAAAPD/sXc/PZKd2WGnT6Wio4PZwUQyldWVKJQIgiIaFPvPNAQZNgShYcAaw8B4NRsv5ksM5gPMypgPMOtZzG4W9kIwvPBCMLRoDNqDhu2R1RRBEwRB0ESxWSomkqFkKDuY5YV3VANeqO+PjejnWVYBcTLivve95/13DwAAAAAAAAAAAAAAAAAAAAAAAAALU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGEKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIUpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwhSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBhCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICFKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMIevHjx4uv+G4Aj8ODBg5/NzFtf/fe3Xn99fvYv/sVice++9/uLffZXrecuizUzc79aZ7FOPng/i3X35PUs1uGQhZqZmdPNfRdst+tihe42Z1/3n7CY9f6mC7bZZKHupuurZmZWqy7Wyf42i/XuR6dZrMvLLNTMtNfs7PA8i3W3vchi1daHru2Xz7P3d9/OYl1dZaFmps15zlZd+7idrm+shY/qOTl045h3P+jygidPslAzE+f6H32Uhbp/8moWq3ayC/Pv7TYL9fz6JIt1fp6Fmpk2/04fnmH7KL9XOW81M3MyXT/8//6ku89+93ezULlHX36cxbq7fJzFqueIU9fXWahPXnTjs5dfzkLl0nFF2A+X+U75mJ6ZWe+Oc+6qTK3Kdj/TjivK9ZHympXzwzPtfXa7Oc77rL5mxzpPltrv23jlAzTMUe/Pu3s6nQOZmftNN9d+ct31w+Xk1f10OepM2vRTF9uwH44faHeHro2sV+F6RSne5PXJZ9385qOXu37/5tD1+WebOLeqE9VI2X/UeylL5bjiSLdtzszR3mbpWv/Nrrunv/giCzUzM48edr/j7b7Nvyv5PFmZN4YPmdtDl8ed7sMx7szRjnPLNaZaPV9QKa/Zsfb5M8ebW6V7zCce54b7o4+2gUx8FrJ8xhzxvrxymel0jnOerN57kl6zQ7dn4ma6PRNn2zZHTfPvcE28PFN6tGsjM+kz5mbfXbN6j1fZRo52XfCIFxGe77q2X57BSc9MzbQ39rFuSo0Xme63XX5V5iDpuPPZz7NYN5vufMVMOw9Sjs+O+HGW7id7/bUjfW9SnKSWa1rHus+8Hlcc636Q8nesp77LOeJyLJi+V6s+X1HOtZf758uzAXXneKznOcoxdX3Nwk7kWOe+67W6Upk3lmc8b1btewDLZ3W5Lnix+zCLdXvZvuuqXKe+W3U5SPnek/pds6V0LeZIc6uZ493Dc6zzOzPtWYRHD7q59jQfdp/9apTJVXyjpecejvTcVLkvL19/D9t++U7ncgxTz0fXew4r5Xve6mtWxivXch+fH+cYd2ZmfR3mjeUmrzIHqd8/tfDv+N3vf3/efvvtX/Zfb7948eK7iwb/Gh3vSTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAXxMKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIUpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwhSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBhCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICFKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMIUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYQpIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAhSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDCFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGEKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsbPV1/wHAcXvxzc3cvvn7i33+558t9tF/yyuvrLtgM7Oe+yzW/WuvZ7F211mo2W67WDMzz6+7uswX5+GX2++zUIdDFmpm0q82F9tNFut+1fVXh/A3nJlZhdnr//l/nWax3nwzCzVPn3axZmZ+9L3nWax3n11ksd77SRZqfvu3u1gzM9//ftf2/+RPu1j/6B9loXJnc5PF+vj6LItV5gVXV12smZmTMNd/vuvygjfeyELNbtfFmpmZ6+su1pMnWagyHy7zuJmZcgR/dwjHgtu7LNZcxzfa+XkW6n66a3ayv81izaYbd54cwrY4M//7P+/u6j/+4yzU/NVfdbHeetLljDMz//anj7NYZd74xhtdWwxTgpmZ+b//5NtZrPI+Kz162OX5MzNvv9M9zyZ8dtbzIKX7827uqlxjKttHnYPcrsJ5kCMdn60PYT48ky4Onq66+6wcd9ZrdeUcz9m2a/zpuHPVXrTbfffdTsM5uZOyc4xvtN2hW4vZbLt8Z8KfsZ7bDKfJ5uTpx12wVbjPJb5ou313n11swsQxnG9MFyxm5tE3wiTkg3CTxpO3slDl3qSZdn21fFavw/5qtSrnktprdrPrvludF5TKbr8cC5bt42zbtfvttr2n5513ulivdc+z0+nmru6myxlnpr3Rwjm5TdkPv/dRGKx1Enb695uu7af7MyaeTwrnye4vu3Xj01W87nPoxjFlN1zuJyvv6ZmZVThdUH63cop4Ha5n1cr1s124F7t2sQr3lIU5SJk31uurqTDXP9uV+xvbQ8flPFmZ75wewmtWHxQ/0kMWZ4fujOfNPlw3npn14TqLddiEewDD51m97nOsz8/yex3CvY0z7V658nlWbrsq1wVnZk7K/CrM9csjnheXl1mss3hu86bcTxauQf6H/9DF+nt/r4s1E78f5Mc/zkK9e/WjLFZ4S8/MzH/+z12sv/873R7AP3/WnRf8wffauc2nT7v5xu/Mu1msm6vvZLHq4fuHH3XX7NWrcE2rHC/F+zbvt9045uS6mwe5C/fPt+cFJ72x6zODmXgSpHy/0MV5eK4ufHvMOuw/ZmZuVl0fUr6frDxLfRb3jeWZwXJfzf35q1ms07jPv1918yDrcI7nLvxex7x/vryn9+EaUzglNzMzH4dj6qurcE0rTOXONm3f+MUX3e9Y7kkt9xEf7Rhmpu34w822d5t2ffXzz8tYXT/86JUwRw3HgjfTto/0GbPq+sbTKfdcxRnPoesbyz0T5R7iuh9e77o5ntPLcIHkvQ+yUOsj3rd5uw3PTZUvlas35T17tuznf/nlsp//ayo+OQ4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwm0cBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICFKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMIUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYQpIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAhSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDCFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGEKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIUpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwhSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBhCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICFKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsLAHL168+Lr/BuAIPHjw4Gcz89ZX//2t3/u9+dlPf7pY3Of708U++6s2myzUzMzs912sX/yii/Xyy12s1aqLVcc72d1ksW5XZ1ms09VdFmtm5vawzmKV3+1+1X2vsi3WPt51bf+dd7JQ88MfdrFmZi42t1ms2+nygg8+yELNW0/i+yxMet5+r+uvfvu3s1Dz6OWu3c/M3K26tv/sWRZqLi+7WIdDF2tm5vPPu1jf+EYX62Lb5TtlHjczczrdfV2Ocy/O77NYd4eTLNbMzPr651ms2+23s1jHOq6Yafvi8nl2ddXFKueS6mfn06ddrI8+6mL9wR90sbbbLtZM2x7T8dmb3bMz/RFn5u0PuhzkzTezUKmTfTsWLPPG8/MsVP6MKZU5SNnvl7FODse7hlB2+8d8Tx9rrn/MfWP53U43YS4Xup92zuVY2+N62mdM6WbfPc/KfTVp/2Efw69GvYnnWIWNP22L9XO6TMDLWMfaEdfKge71dRcrdn9+kcUqm+N61fVXN7s21y8f1WWs9aGbt705dHO2dTdc7gEsn2e3+/Y+K5X7XMp9m6XTZx+2AcuJ2zDfKeeuTq6fZ7Fmpn2ghdes7BvrM1rH6mSOc+57pt1zeKxTV3n7MA/yd5bvjz7S9bPymtV7bUvlLV2OYSQhvyLus1+J9GxumfAc832222Wh7jbd+eZjVjb9ctmnvs2OdQ3hWNeYZibtr8p3kZQ5annusl74Odb9IOX6aj2XVJ5Jf/Tlx1ms+6vHWazybOJMu+xTKtti+X6ymePNd451ynZm5tNPu1jl+zrK3zGdk5s52nn9cu4qTPNnpj+XXknPAdebvI50Xu5oz1fUjnRRvN5re7YK+5AjTVLrs5DHuhZT7tus9xWU+9fKfr8843m2cRbyV+JYX4Y2M/PkSRfrWM+f1QO08hlTvoO+fMbUZ/jCSeJj3Wub7n+N3/NWKt9VXZ7hK7/XzMx6340rPvmi64cfPsxC5SnBsZ4DPjt056Y+3HVnxGdmXr3qcv3nu24Mc3Ho3ov9/q57L/bM8sOKH/7wu/OXf/n2L/uvt1+8ePHdZaN/fY73xDMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADArwkFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMIUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYQpIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAhSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDCFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGEKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIUpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwhSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBhCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICFKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWtvq6/wDguL2YB3M7p4t9/sXmdrHP/qr7zXLf45c5Xd1lsT75bJ3FOp3umuWPuf2hi7XbZaFON+H3Oj/vYk3cQsJrdrLZZLHut2dZrNrhuov1xhtdrLB55A5hd/Xaa12s2WzDYDO3+5Ms1ltv3mex0gZS5gQzswrv68fbmyzWJ591z5hHL3Xfa2bm8FL33c4++PMs1p/PD7JYP7j6eRZrZtI89eLZu1msj/ffyWI9Pi/HgjNzeZmFOn3n7SzWvPlmF+uIPV6VfUjYFnfPsljlPTYzc7b6IIu1v3w9i3U2YQ5yaAeDp9dde9xuH2ex5vo6C3V/fpHFmpl56+p5Fuvd97rvVs651JMuF/vumj2/7q7ZxfY410Zm4pz4SCcB71ftNduEiwjp+tm+C7WK11fTXP9w3oU6dG1/FS+vnm6OdI64jBXfZ6VweXUuyqWY+Ear7+tKuaem/hE//yyMNd0z5tEr3TW7C7/XzMzTp12sy8sj3eO1a9dXS5/8ohtTP1qF8431AyYc5374Ubdn4tXzI31Qx56FyyOPL7v+6mzbto/n113b35b5976bCDkrp+S27fzfx0+7sefjTTf3fRrvWS7d7rtrdnoIc5AwJ3j/8GoWa2bm+r0u1g9/2MU62Xfjio/37fpq+Tw7C3/H0zLXvw4nAGfmbtu1kXTIVE6kponc8c5tHrMlz5B+1WnYN5aNMZ37npkpp+XKmzqMdTLheufM3Oy68XvaD+v0fyXK82Cn4SU7ObR9Y7nOtArP5pbjs7tD1xZnZtarri++XXXX7PTQXbPn4VzSTNvtl0Omx1ddWyzn9GvlNSuniPfTXrPDoeuv9uE1K7flXZx3sW727T6X8j6b8+Ptr47Wka6flc/pmTYnLvPhfTjurI/EhFsL0mu2WnXXrPwNZ2YePuxilTnI+pjHguk20Ta/4u8uPLo95+dd2y/7j5n2GVPmO/n6WSl8gJZzm2UuF29jmLtD14eU86hpvrNv3/OWNpJw0qV85+B9PLfZnrfvGv92W+ao7fp7uaZVXrO7TffsfOc63rP8QRfrR39QnrcP95mH7+CZac+vlq84LOcbz+P3eH36aRfr0cPjXKfebrtYn33ezpOV5+3L/uPVJ10/vLvOQs3MzEX4Aqq/+ZssVDoWLNvizMyrl92cy5/+adeH/M9/1F20b34zC/Xf/PSnWai/OPxhFutH3+v6j299Kws1MzPr//j/Lfr5D/ZfLPr5v67ssgEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYQpIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAhSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDCFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGEKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIUpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwhSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBhCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICFKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMIUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtbfd1/AHDcHjyYOd3cL/b5N7vTxT77qw7XWaiZmdlu11msRy/fZrHuVt01Wx+67zUTf7erTRbrZtfVmz6b5fqLX+Zw6GKtzi+yWCeHuy7W7iaLNTMzm67tP3nS9cNPn2ahFn0u/zJ3h65vPFt1bT/tQA7tsG2z6dp+6W6677UPY83MbMtgYT/8aNv1V598epbFmpl5+DAM9sYbWahHn2eh0rY4MzOrri++e+07WazLLNJMPQ1ZjmNWr72VxSpbfjmumJk5HLrn52717SzWZp+FmtV5973qhYWTMgf5VhZq7jZdDlLPk82+a/xPXstCzey7tlgOO2dm1mG+sw0HMWFTnNMJg82kP+Qq/Go3++NcG5lp1xAOZQ4SJgbr3fMu2Ex6n92E86jlkLpsizNtTlwqr9nJdXyfnZ93scoOK4x1Eq+vrsOf8WLbJcXlGsJ63+Ygp9fXXbDLbsbxftVds3p89tJLbTz+7l69CudSy+dZOCN9d+jm9Gdm1qvu+Vmuec4hvGbxmvg6zHmurrJQczfdHHHafczMp592sR6fh/nVKhyg7XZdrJnZlGsW+3DP4ZGOBdMNhzNzfv44jHacOUg+t7np9iyX86jlNSvXmGbaabLyOf3opXhQHTqb7nl2Hz6nS4dt2FfF0nnbcgG+nGucmSnP4ITnYsr9QjPtnEt6VmUXPmPKxKBMCmbasWc42X5f9h/xWl2pvKfvw/nGfF/edGsIp0f61pDnu/iMVphele2x3CMaT23OxXkXq9zDc7vv9pP94hdZqJlpU54vvuhiHbOybyzb49mqW2O6ne6enjne/fr1kdJj9fiqHL93icHtqptzqdcQvvGNLtb9puuvyjH1fTxPVraRXbh+Vj5fauUzJl2nDvdn1G+puT/WfVfh3qTzOLdKX9N0pLHqfPhYv1uZg5Tnb2Zm5tmzLNQ6nOAp9yzXawin266RnJZr4ofj3Ocy0+b6Z+E5hF34jqaLTds5luPBk/LdD1mkfh7ktFxoCq9Z+s7eegAfPkDLOcCyuwqP5c7MzGuvdbHK+cZyf3R9zcqzbse6FlPv8Xr0Srm/sYu1Ce/pck7u0Svt+zbLcW7Zf3z4UZd71+P3Oe/a/qtPuv7q/Q+6a1bvJzsPr9k/+SdZqJnwd6z7xjIJ+dFr4TnPsPE/uowTuaUHFuvjrJHx39PubAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD4DaSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDCFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGEKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIUpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwhSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBhCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICFKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMIUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYQpIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAhSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDCVl/3HwAcufv7md1usY8/W/Czv3bbyyzU3eo0i7WeuyzWrNrH3H4fxgprQJ9tumt2s1tnsWba7/bx0+67Pb4K2/5m08WamftV9zteX2eh6p8xVT6qN5uufZSxDocs1MzMrOc+i3W7755nZVpQ39Mn+9ss1iefd3njN76RhZqXXupizcychPfZ/aa7Zn/9NAs183Kb63/8tOuvLruh4FEr+/3T3c+zWDeHb2exzrbxmDrMGy8O3TW733TX7OTQjXHvpx2/310+zmL9/3+WhZp//MddTnA3XU4wM7M+P89i/fjHWaj5oz/qfsfddRZqZmYuzrdZrKfvZaHm8VV3n820g8GbXZejlvM7V1ddrJtd2zeebbr2uFp17aOcl7jbXmSxauV6RTnPXq6dzcycTtgew/XVk91NFut2095nq3D+e33o2kfp5tA+z8o1i+2266/WqyMen111eerdoctBJmyL9VpdmX+nY6Zn11modTzRXu51OTs8z2KVjX912c2jzsx88mnXX73yShZq1uXiSNw3lsr9jeX4rFyjnpl56aUwLyg3aYQbyu7P2/HZadhG7g5nWaxyLFje05/+Vrd2NjPzSviIudl3Y6Zt2H3Ucy5l11jmVg8fZqHyuc23nnRzgM/Dfrj07Fkb7/GmS4rLtZiy8e8mno8On2frbvk9vWb18+wQzpOdbbuLVu7Vf/+DcGw2M0+edPHS3WvhPqhc2PbTye9S/L222y6Xuw/Pr5b7X9d1WwyTkPuwfZQ5arluPNOuHafStf4u1kzbX5Vrx8d85rjs9196KexDwjWEizhHLe+z8kxp+ZyuX+5V3mflCK1898PFpptzOSsXLKY9h1DOuXzwThZq3nqt3Y/69gfd+tnF/uMs1s22W/M8W7XX7BDu7b1YdWtMn3zWjTsfPWzHZh9+1PWN5bmpu013zer11cN1F+tic5zvc6nvs12Yg5R9Y3mfrffd95qZdJJnHQ6aynddlefcZuZoX1ZTjqnTd6TOTPrtjnTCMX7V7NG62IZtf3/EBxHCpPgkXPM8PdL+Y2baTqSc3KwX60Lpsakj7q6++KKLdbbr5hsfhetnz8MzDzNte0zHMeUZrav2DE66czNsIKflXPvheJP9cvtaGevJky5Wux4+M0+7Fy1/uHs1i/X6VXdP18/Os6fvdsHKPTx/8iddrDfe6GLNHG+y/5/+Uxerfrn+0h3/l18u+/m/ptoTQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC/gRSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBhCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICFKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMIUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYQpIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAhSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDCFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGEKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIUpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwhSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC1t93X8AcNxePDiZ29XZYp9/utov9tlfdXf+7SzWzMz66YdZrNWTV7NYc+hC3R7WXbCZ2Wy6WIfwd7xfdb9j+RvOzMz1dRbq6irsQ8oGUsaamQnb4yrMlMuf8e7Q1pC/OPw8i3Vz6O6zk91NFms/y+VSv8w6zK8+//w0i/Xolbss1t20Ocjsu2v28svdNSv7YX41zs+7WLfTtcWZme22ixXe0nO26frGYx6f3W+6HOTs0F2zeuq47EPm0AU7Ca9ZOX6vh4Lr6X7Hy8vud7yfbnxWX7PZXmShnjzJQs3J3Gexdrt2/P7sWRcvfU6H91mZx83M7HZdrMdXXdsvr1ntJryvzw7Ps1jlTb3ehd9rZm433fOsnPveh/3HF190sWZmtg/D+YIyvwqTudPVbRZrZuYunOMp55PKuc1tvL56su/ayO2hu2brsHNcl5ONM2miejjS+6zex5Dvm4jcbrt51NN0HnXmrLxm+67x34XzO+v4mj16pYtVztuWY+r1qpsrmJn0eXa3KnOQNv8unW3C/ipch1yHD+pyPnqm3VP22WdZqHnllfCeDp9nX37Zrr8/e9bFurzsYpXqtbpyzeKVMLcqfe97ccCn11mo8yfhntRwDPOD78U56ntd53j/xneyWCdhvnMRjwXL/Wvpmuemy3dOjzhH7TfWNF4P99TMTLxAEs61lwlxupFy0rZ/E56LOQv7q/tte96nnC94ft31w+fn3XP6pL7PwvOr5VhwFc6j1vvyynN16bMzneB53MWamZNn3fnV1WV4fjXs8w/xmePyqMrZNhzH7I73MGTZF19s2/mCSr2+Wq6fldpUrpsnq9/9kJ7dDsedm03X7st9BTPtNEjZQNK2GG/KS6Ptu/vs4cMsVHtoamYuL7s5nvW+e1dNeaOt0wMWM7ebcF4ufJ69/HIWqp0rmJlt+f7GVffwLB9n+Xz0ke5vPE1fFBnPFYQD+PtwnTrdSxm/7Op2340HT8N9vUc67JyZtom08wXhXuxVe9HKNlLOyKVntCbOCerFwcrVVRfriDctr+KcuFKfJ01Tnm3Y9kMXdd9YNpJd2IeEjTF/X175PAvbR3lWthwLlu+DmmnXPMspwPI+2+/b9fCzcA/gs0NXK+bqqpvf+cUvslD/Tdn4y8Xcf/pPu1jxWl3aOT59moW6+x//pyxWugY5Mx/vlh2fHU6Oc+/Tf8/xvoETAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4NeEApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBhCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICFKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMIUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYQpIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAhSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDCFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGEKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIUpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwhSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC1t93X8AcNwezIs5Xd0t9vnv77692Gd/1dU2CzUzM/vzV7NYm0MWag6HdRbrdPfzLNbMzP1l1x7XH72fxbq5fD2Ldba9z2LNzNxsumt29tGHWay7q67/mFV3T8/M7HdpuMzFedf27+sa8ptNFmpbPqvDtlj3jTPdNXvYhZoJ85314bYLNjP35xdZrEPY9sPuY0727TW7m9Ms1o9/nIWav/iLLtY/+2ddrJmZL7/sYv3Wb3Wx/vIvu1zud34nCzUzM/t9F+vp0y7WTHfNfvd3s1C5b3yj+x2vr7NQc3XVxVrFKwv/6t9016wcV3z6aRfr0cttvvPv/6LLd87Ps1Bzu+/G1OU9PTPzr/91F+vysot1CMeCp5t2/P7s0LXH59ddrPKerp9npY933VzB1XkWak7KyYKZOX3WrTPdnYfrFasuL9g+7HKCmZmTw3Lr0l/19GmXo756Gbb98uE5M+sF9xL8LeGaVvkz1s+zdz/q7uvvvBa2j004GNy1C553m7Ms1umqXtOKxNdst+uu2cXhWRbrtMzl2sdZep+tV92XW++eZ7HK9c6ZmT/7szRc5h/+wzBYnDd+8nmXg3zwQRZqfu/3uu91tglzq5n5sBwzbbv+qpy8qvd4leurj15p22Pl+a5r92VfNTPzh2+G91mZfpcT0vE9ne6hLxd+QvtwXXBmZv0v/2UX7H/937pYpfJhNpNuGDp58iSLdbfqctR1PK5YxeceKuXPuK4Pc4RzLqnyosXrq6W7cM/EKjwveHId5t7TzsudzXGem6rPIRztGa1Qfq4uvM/CJYTUMZ+ru9l17fEs3JS6Dvv8mUk7rHLoeRre1NfX7XjpLNwjXe79Pg0P1t187w+zWDNtXvBxuMb0ePduFuv91XeyWDMzr191eepHT7v5pNdXx/m+jvX+Jos1M7M7hPvJwpcZfetbXf+xftq1xZmZV8s1rZ/8xyzU6T/4B1msOdTzZGF+FSap6Xx0PLf59KMu1uvh8ur9pntOx8s+6funVtvu2Xkolzzjtf5n4fsYHu8/yGKdvPZaFqu+0W4O4f7G6XLi8qzsxXl74Kfcv3ZxCMcxYV5ws2/nydrbOpwnm3D9LNznMtOe41vPce61Lfcm1dJn5+F4z/uU7xJ494Ou30/PytaHjsN45Xu8fvrTLtYbb3SxZtr3Xf399/6fLNaff/9/yWJdXrbPs/fe62L96LKbKHt+9VYW6yJei3kersVcXHdnRz4Ia4G8fn6dxVpt4nwn3Fez3XZjwfWzj7tYZcc4k74M8LVw2rYcdz765J0s1sy0CdZPftLFKg+Vti9Znvt//n9ksU7C77b+8b/NYtVrCL/1P/zjNN5viniXOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBvHgUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwhSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBhCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICFKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMIUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYQpIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAhSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDCFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGEKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIUpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABb24MWLF1/33wAcgQcPHvxsZt766r+/+eZb8+/+3c8Wi7taLfbRf8vp5r4LNjP3YY3f6+ss1Gw2XayyfczMfPZZF+vhwy7WyYRt/3DoYtXCBln2H7tdFmpmZs5Wt12w8JrdHtZZrNPdz7NYMzOz3Wah7jenWayy7Z9t7rpgM3M3XXtcH7p7umwfJ7ubLNbMzP32LIslL/gVCZ8xn3za5QX/5b9koeaHP+xizbT9fjmOKceC5+ddrJl27Pnpp12s0ksvtfHCtPFo7+nTCcdLsU8+73K5v/qrLNS89Uab66eOdB6kzIdvdt33mpl59qyL9fpr4biinrwKffJFNxZ89CCcTyoTuXrcGX63u1X37FxP+DyrF35Cx/o8y/vhso2Usfb744w1M7fbb2exTlddf3Wz7+bZ6zWEdE0rvGbl96qV6VX5jLk7dM/OOgVJ1yG37V6oyvPrdkxdzn+fHI5zPul+1fbD5bz+X/91F+vqqot1emjXxG9X3TxIKX1OP2v3C92dd7n+0c5NxOOzm0M3n1SuC5Y56u2+y0GePs1CzczMt77VxXr08Dhz1HL+b6btQk73z7NYN6uLLNbZs/ezWDPTXrRwEHN7/jiLVeeo6TW7vMxClXMutTKVS8fv5ZpnOYiZaSfKyiQ1vGbluYCZdnxWzydVjnX+b2bSjrjcd1Wv1ZVt/1jH1LX6XHol3ecS943Heq6u3E9WK3P9Mv0uc6tyn8tMu05dPmOOdZ5sph0ylcpzwM8P7Xrnxflxnnso+4/yXO6jl9vzYM/3x7ku+NFHXazXL+P56CM9eHm3Oc69IDPtGa2yeXjP269GupYb7sXOhT/ksb7PpT6/Wkr3JpVzV/Gm9nQOMByflftR63c/pO/Wuu7mQe623TxIfXbkaPOCI33PxEx8zcKcuJxHPeb3A7/yShdrveraR32flc+Yj/fdM+bxKjzPEe43nJl0Aa08B1zO73zzm12smZm/+Zsu1qurj7NYN9tuz3K9X+hYF8Wf77p7+mIbX7MycQzbR7nGdLE64rXcTTdf8PF1d83Ks/b1uGL9zp9nsW7f+EEWq3wXce3xeTgv95OfdLHeeKOLFZ9v/ve772Sxfv+8OzN4/9rrWayTfTsfvfT7gX/0o+/Ou+++/cv+6+0XL158d9HgX6PjXb0DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+DWhgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwhSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBhCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICFKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMIUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYQpIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAhSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqaAJAAA/5W9+w/S7Tzow/4969fLq9VqWS1X0la9iBtxEYowRRg5GAiJw5jBzUDiEJJhklBoJyme1oE2QxLSSRmamU4nnaEhQ9Mwgf4YJi0Be0hDoENADVA8mYDtQqhtFKO6F6ERV/Llelkv69frV3v6hzUM+MddXeme79U99/OZ0T963/t+z9lzznOeX+c8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDELCAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDELSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMzAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABOzgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxCwgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxC0gCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATMwCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATs4AkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQWN3sDAF6ORbEUO1l319zdXJzWsvZ2a1HJet3Lap4gST760d45snH5mVpW8+94vH1vLStJDg56Wfv7vayN1XEta7HYqmUlSZbLWtSzH+xd0/fdfVLLyu5uLyuplvsb6d07d5bF+1nz3pkki81uXsnGledqWafnuvez1aqXtdUrhqs7dpidWlaS7OSwlvX88719e+1+sY66PtfLSrKz3asTN9ue54p/xs2jq72wJKfLvVrWPffUorKx7tUbT8t1gmZdbl28zra3a1G5etBrn+1tF9swSb7ne3pZ/+3f7t2nD1e9+/TO0++rZSXJjz3xSC3rzW+uRc23ryDJv36yV+4/ePlf17KOH/3yWtbWUa/dmSS/8zu9MuS+xVEtq9p3dVTcrySH6969eueg1z473r2/lrW17vV9J8lxesdsa9Et92vKY3XNgZ9nX9U79++7uxaVk2W3n2wrvXP/cNWr7+xs99q4p+m23w+u9LK20gvbag7mNgepk1xd9frJ9rZ7Y1qLmY5n1TXrxMWOsuK0grpmv21zbtKq2K5IkruL9atm1maxzXS63a03LmY65bA5j6E9X6j5d3z2g72y8b67itfZsjsvrzkV6vLlXta5c71+/eYUr3KzIg8e/Wov7J7X9LKefroWtd5/oJaVJFsp9qUWC/2dRXG/Hn+8l5Ukjz1Wizrd79W/m/W4PHmpGJbk4Yd7WcWbzGazIle+oZ1s9/rJmn1XG81jVh5fbXbyNOdtNs+Po4NaVJJkb7d3PjaLkGqTuj2+2lS8nzXnfbdf09Bse26ue89zNJ9PbF9mpyk+c3zUm/+6WvT6iJfL7rhg8xQ5Kc5NmrPmub8unvuL4rm/syzPXTvq3WOWxTGt5nNMO8Xnb5J0H2At3qybc+WKzaUk3TpI0/Fqns9znJbf17FbnFfTbMM8uF8cQ7jUG2NK0h1gLZbDm69/fS2r7f7i/NdcKd6nL1zoZZXHEDaK/dFbV3rnx0lxnLr5rry25nu8mmMjH/lILSpJ+XnZVa8SclKsy63mO1RXfiqmqDypvVltvL84IaTZr99+zdvWsnj/LJaN1XcOlq+zrdVBL2zRewZnve6VxO2xujvu6GU1963Z//fBD9aikiTPP9/ra2++EyrL3VrU1YNu/3BzLlTzmDWz5vwsZD7aqxc027nt55ubz/bfvzvP58Sfutw9Zleu9PJe+2hxDYtiG+ZkXXx+tdzn0qw43r8svv/1UrFjovg8WJLk/PlaVLNv4v79Yr/Ek0/2spJkt3fM8o531KKeuvhVtawHlk/VspLkZ/5pL+u1f6JXufrgnQ/Wsu77aLHSmOTZg2nHIdt9ta8U85zxBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPAKYgFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIlZQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYhaQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiYBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJmYBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICJWUASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGIWkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACZmAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAiVlAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBiFpAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJgFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmZgFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIlZQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYhaQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiYBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJmYBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICJWUASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGIWkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACZmAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAiVlAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBiFpAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJgFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmZgFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIlZQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYoubvQHAvG0MY3aWJ5P9/vF6c7Lf/kTrdS0qSXLlqLfG73JZi8re+qCWdbi8t5aVJLu7xbBLV3pZi151YbHbPWbN63rj6LAXVrQql41bxfLq+ed7WaeL3v2sbZ3evl16shaVhy70sqo36pQbic0yZHu7FtUu8xfLnVrWybpXR90s1kG2u5dZcvmoFvWqV/XOj7y6/YcsKlYcV6vevXPK9vrNtrE67oUVy6vmubjR3K+kum97u/PsFl8sevfpk2I9P0ne/OZe1tV1795ZrKLm+MIjvbAkjxX3rdm/c889vazjYp0gSS5cKIatd2tRWynWCcrt94sXi2HvKvZHF0/Gk+29WlaSbDerIKteWPM6O11u1bKSZOvKc72w4iBTtT+63Pe9kYNa1t1316KqY+Jby9NaVpKcFPetarWqRfVagh937lyvLD5d3F/L2ji4Wss6Xs63DtK8x2yse32bzXI46fYXNOuNp8USa2tR7vs+6pX7zf7o0/1eObxVvKbrip1XzTZTsbqTpNvt0qwXVHesPAF2o5h3xx3F/oLiMauei0k2i30T29u9ekHz1G+OvzfnFSRJLu7Xoo5XxXpj8by/dKkWlSS5eLFXNm6k1590WHy+Yuc1r6llJcnhxdfWsnaK8xsX28W5a2Xvv9Qrix+6WOy3vVIcFyw76k3brPbvbBb7/06K85WT5EMf6mXdcUcva+fKB2pZe+V5DEmv3ljtK7j8TC+s+nBiun/I5pzUYudVex7D5qr4rErx/Gj2N7afE2/WC1Yp3qubz+UW251Jd0yrqVkMt49Z80Lbaj4zeKVYOLbrIMUTsno+Fhuep+U+l41m/Wq3N69ms/nsWfv1Xs33gxSfZWo/6jZXzbKxeX4cr3vts63qwxxJzp/vZTXnucx0vmGSnJzrzbtqtqkXxaytdqFf7Ac53H2glrWT4rnffgFV00wrIfcNxWemkmQ1z/7ozUWvbrW5Ko/lHvWu6+a9c6t4zNru3+/t29WD3rsil806yFG5bGz3y5U0x8/adf2qg4Na1GK7d01vHnSvs3Vx35pzvw8XvX7U5jtWkuqpX537/eyHev0g993dLRufuVJ8X96i16+/t1tswzRP/CTrO4rPOA+9v+N954p1/aef7mUlyblef9LJoleX21n3xt+X+93x1eZ8oeb7gZtzsfeWvTL/8uXuHMDti7175xNP98r8f299qZaVxx7rZSXVh8Ief7wWla9/rHc/O9x/qJaVJMtit/7mt3xLLatZBVlc6NU/knLb89FHa1H/59trUfnar+0es8tPTPv77fnerxTznMEMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8ApiAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAiVlAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBiFpAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJgFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmZgFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIlZQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYhaQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiYBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJmYBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICJWUASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGIWkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACZmAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAiVlAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBiFpAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJgFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmZgFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIlZQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYhaQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiYBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJmYBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICJWUASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGIWkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACZmAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAiQ3jON7sbQBmYBiG9yZ55BP//yPnz+e9f//vT5b7Q0dfP9lvf6Jv+IZaVJLk8cd7WX/qyf+ulvWLX/HXallfOvxSLStJrl78I7Wsd33WUMu68G97dYXt7VpUku519h98c++Y5dlne1HjvbWsJHn1q3tZe+/66V7Yww/Xog53H6hlJcnO9mkvbL3uZS0WtajTbNSykmS16mVt/Wf/cS/s+7+/FnWy7h6zJ5/sZT3y5I/3wt74xl5W8ZpO0r3QrlzpZe3v16JOl1u1rCTZyEzvZwcHtajj7W69cbnsZW388P/aC/viL65FnVz8pG6eSTWLxp33/Kte2IULvaxz52pRJ9msZSXJ5uqwF9a8dxbPj3a74uiol7Vz8FQt6/R8r01drX+0Xb5cizrdv7+W1VZtv6+L5XCxIne87t7PmlX95u3szjt7WffdUTwXk2p/wVNXeu3cYrWxW34kubreqWV9x3fUovKd39nLeijv74Ulyfnztagf+ee96+zP/bla1KxdutTLKp6K2Vwf98KSXF31zv1mV3uzbrW3fdILS/Lsh3r11He/uxbVHBLPg/vd6+xk0bvOmnX93d1eVrNPP+mWIR/6UC/rrrt6We1j1uxvbO5bc7+a13TS3bfmnInmsM/eotumPkyvTd2s61+82Mtqlh/Ne1nb5tHVXlhz0nKzUz/dfrK9ZbH+3Wx4NgurJFfPPVTL+tjHalG5765u+6zpON35ay1by944dXuubfP+2Sz259onl3TLqzvu6GXtLIv9jcU5oklyuOzNE222O5vjq+0xhOb9rN2f1NIuG5vl/sa6WF4Vd6xdB2kes+p8smK9sT3/tXnuN+evVefwtB8Un2tlf8Z9V81nwsq7VrOV+fa5VJ/dXvTK4Y13dd97kkcfrUU157ncfXctqts+Kz/fXK2DLObZrqg3Bpt5zaxiZ0H9Wci5liHN/sZyZ9IzR73x1Wp/40L7/UY4XPXKkJ3FTMuPJFePen/H5q5Vx33aipOWry57zwHvXek9N9WcC5J0b9XNOal7q2d6Yc0bdVmzHJ7tfLK2mb7jcOPKc7WsJLPtLzg915uf0e4GmeszFhsHxfnRbcXr7NmP9Nrv993Ta1NfPei2qZvdLu13TbQ0n79Juv0FzWdlN5/+QC3rqcWDtayk+96C6hyvYl/B4Xavr6D63vRktu9Ob89ZrmqOaTXL4ea7Pdua537xfYrH+937WVNzTmp1QtlcH3pIJv87fsFjj+V9v/Zrn+qj943j+AWTht9E3dYhAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwG3IApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE7OAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDELCAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDELSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMzAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABOzgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxCwgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxC0gCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATMwCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATs4AkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQsIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQtIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEzMApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE7OAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDELCAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDELSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMzAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABOzgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxCwgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxC0gCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATMwCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATs4AkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQsIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQtIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEzMApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAExvGcbzZ2wDMwDAM703yyCf+/0ceeijv/dmfnSz32VfdP9lvf6J77qlFJUmOjnpZO0fP1LKeWveO2QPL52pZSZLt7V7WN3xDLerH/vL/Ucv6iq+oRSVJfvu3e1mPvOdHa1k/vfvna1nnz9eikiSPnCte18WC+Hj/wVrWel2Lquft7vayNtYnvbDFopeV5GS9Ucva/Ikfq2WdfO3X17LKhyyrVS9r62Ce9cZz52pRSZKtHHcDS46zVcuq/w2Xy1rU4VGvHG42YZplVZJsLU97YU8+2cu6cKGXNWfFE/JkuVPL2kyvjnq83qxlJdViuFu3KpZVp+ndX5L5/h2bjdz2dVatXzU7C5pl/u69taykO4awt1u8zoqOV92ysXnqN7Oa/SDtvs29Za9sbLapm8es3U92+XIvq9kUfP3re1mbB93x1cNl7/7ZLEP2crUX1hwcSbfvqtkWbNpcz7dvs9n2nPNYXfPv+MQTtahcvNjLavaTtZ0uev0FG6tiedWuODYrBnO9obUHfmban9QcqG73ETfv1SfplY2bq8NaVr0jpFletfetpDkuOOdbZ3vf5qr6HMKyV+ZX68PNdmeSw1Vv35rHrHoylvvJqvXGYkF8ut27n9Xnky16537zmv7IR2pRufvuXlbSrX8fpnfuV8vhduXq4KAWdbjYq2XtbM93jtes+wBbZjyGYJ7LjdGs8zT3rTnfsDmnJplvN1lzPsjpue5cyur9zLjPjTHTC+3qUa8tWJ2blORku1f/3lzMs/698eT7a1lJcnrxoVrWRmZ6zIr71Xyuv61ZBzne7tVBqs8xJfOdM1GsEzTnFSTdP2Oz76o6XlEcF0yqXZvd9+LMuL3UfCasuWvtceqm5vhZ85g12zBtzfp39Zn0yx/ohZXfDTLbsvGoOG+z3f8314dz5zoumPk+N/XU5d59+oH9cn2n2Y5Z9sa0mnX9w3V3rK75PrSnn+5lPXC+WG8sj/s0z/3mlNTmudh+vGKut+q5znNpa+7bzqr4Xov2y2aLHY7Nsdy5NmHm3L/T7CvYWhXnMTRv1Em1EnK627umq30u7Tpqcf5adT5Is7+xXGmc63u4m3NPqg2mTP8Mzpd+6RfkiSfe96k+et84jl8wafhNNN8ZRAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACvEBaQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiYBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJmYBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICJWUASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGIWkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACZmAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAiVlAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBiFpAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJgFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmZgFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIlZQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYhaQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiYBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJmYBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICJWUASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGIWkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACZmAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAiVlAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBiFpAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJgFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmZgFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIlZQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYhaQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJjY4mZvADBzw5Asl5P9/F3T/fQn2Vgd98KS7GwXd27dy3pg97SWldV2LytJ1ute1hveUIv62MdqUXn3u3tZSfL61xfDVhdrUa/Zr0Vld7eXlSRZnutlrVa1qEuXalG52DsVkySXL/ey9o6eqmX9yycfqGV91cPP1LKSZHO7eP/8qZ+qRb31p76+l/XWWlSS5MKFYtjb316Les/Fb6tlfcmX1KKSJMt7tmpZG+/51VrWVvEmc5ze3zBJVge9rEWxt24jvfbZer1Ry6ortgWP15u1rA9/uBaVJLnjjl7WTvGiXi92almby14Bsu41l5IkR0e9rJ3tXtl4vJpv2di8nzXL4dNFrxzeWh3WspIkTz7Zy3r44VrU6bl7a1ntQde9VbG/4Epv7052e8esbSfF63q3179zmt79rNhl+3HFzs2tYgdPsw5SrROkO1T3+Z/fy9q83Ov7bh+0CacSfJLNdXG8/6h3Mp6U+1ya19lmu07cUr6hnS6L/dFHvWN2ut3rc2n2oybJ297Wy/rsz+5lVa/pg4NeVpJfPeiNHZ8/X4vKslh+bB1drWUlycn2Xi2r2ZfavMXs7RYrckm3k7g4GerwqFeXa9a9k2RR7Es9OqhFZa/ZZGo3qosnSfPcb/4Zi0N19Trq5qpXDl9d9+r6e8U57e1xweaYZ4p9BRvrk1rW1aPevSxJmtM2q4VjMeupp7vX2fnzvTZTs0+ueU23x322dnvnY7v+3bK56NZBTpa9esF2dZ5LL6o5lpukmjbXuUkb5b7N5ryaZl2uOdd2K739SpJVc9+W85xnvlk+Zll22xYtJ8XnOdpzlrv9LsW757nec7nNMj9JTha983GzeH48+8He+XHf3d3+6GYf8U56hchesd2Z7BazunOkm3OhqvPJ2g/3F1WPWblvoqXa/5dka1G8Vxc7v5ttmPa4z1ZzILI5YNE++YuqY3XNOTXFrNXu/bWsZL79+tWO1Oa5mHTfNLHq/R2b79Bo3juTZGfRq383+67mXB9uPhuw1SyIZ13f6fVHb1z6QC0r+8UXKpZ1y5Dic+LF/WpPtW3OdVkWx5ge2C/2FbQPWlH1ucti2JUrtagk3b9j9dy/clCLOlyW39dRbA5W381XHPNsPn+TzPc54GababN8O2vOA2zOmTjdLs5dK68r0exwrD67XdyvD32oVzbec8983wPYrFs1n9uujxsXnzmuvm9zrn1y6d7PTi48VMtq9kvM+PHm7vzGZkFcvs6abcHbyXxrJQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACvEBaQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiYBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJmYBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICJWUASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGIWkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACZmAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAiVlAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBiFpAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJgFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmZgFJAAC6juBtAAEAAElEQVQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIlZQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYhaQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiYBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJmYBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICJWUASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGIWkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACZmAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAiVlAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBiFpAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJgFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmZgFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIlZQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYhaQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiYBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJra42RsAzNu48aqcbO9N9vvLYil29WCrF5Zkd9nL2lgWw1arWtRxusdsUfwzbr7xjbWsz+4dsmxv97LqeRcu9LKKx6zu8uVe1npdi3r44VpU3QP7J72w9bla1FedP61lZbXby0qq9+q85S21qDddqkXl4sVeVpIsinXik7d8Wy1r8XO1qNx3d7GsSpKj4nVWvMmcLjZrWYvebTpJsrfdO0euHvX+jk3Nsqpuf/9mb8Ek7rqrm9fsmsh2r9441/ZZ+5ouNs+qthbFOkj5oB0ebdSyNosVg43iyXiy3KllJclms++qeD5upNd+P1n3zvsk2TxXvJ8Vj9nqqBbVr6MWO6SvHvTOx93dWlS2lsU+uSQpXmfNY9asezfL4SRZLHp/x3vuqUUlOd+LavYPl+M2mzeZ4oXWvp81y/0UD1n1D9msxyXZODqs5rU07zHHq25d/wu/sJd1vniLOd3utXO7Ryy5sNvL2lk91wtb7Bazuje0Ztzm+riWtdWccNjutG02ZIr7ttMcG5lxH3FT9X626pUfSXJavIM2523OdYxpvjtWbncWVcfD072m1+nNc2me+s25Qkmq9+pmO7f5NEd1vnKSFM/HRXFeXrPPZXe3W2dsnvvN8qp5j2neX5LuGMJOiv2o7YpB0fFyumdIP1G1mVu8qE/P3VvLmrPqvLyy5r4dr+Y5p73dT7a57h2zk2L7rPln3Nkuzxc66g1UbzY7yg4Oelnl+s5m82UTxUrqHXcUW9Xl/sblsniPKbYrmm2mjeL9JemOwW82bzLNl4OU5+Vl2StDNtM8H+f5gGJ72Oe0WA5Xn8EpPs/R7t5p9m1W55kXz4/VutvGXRfntC+b8xiK7aX2/OhmXrPcb9at6s9CLprv/Jnpg+Ll/Tpc9+qoO8Xnz6rPlM54vlDzHSu90azk2Q916yD33VN8xmL/wVrWnN/HMM9W7rzfL9Qsipvd+ru785yb1FZ9VtbzqzfESbG/YFGcD7IsVxs3V715V6fNtudqvn1Xzf6k5r1zXWyfba27z22vFr1jtrXu9QFuFG8yzX6JpHv/3FoUnz8rXtR33z3fOmqzP2ln2XwnfLMSMt+G507zRctXDnpZ7ff1XrlSi2rW5DaLDaZ232b1PV7Fun51bKT8TPp64n0bx0l//hVrnm9nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHgFsYAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQsIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQtIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEzMApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE7OAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDELCAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDELSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMzAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABNb3OwN4JVpGIZFks9NciHJXUm2k6ySHCb5rST/dhzH45u2gS/BHPcJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAW4MFJPk9wzB8YZKvT/InkzyaZPMaXx+HYfj1JD+V5MeT/MtxHMfJN/I6zXGfAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuPVYQPJlGIbhQpLHft9/X5Jk91r/ZhzHYfINu07DMHxNku9M8obr+WdJHnrhv29L8v5hGP5ekh8Yx/H5G76R12mO+wQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMCtywKSL9IwDOfzyYtFnrupG/UyDcPw7yb5viR/5gb83ENJ/mGStwzD8K3jOP7iDfjN6zbHfQIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAODWZwHJT2EYhvuSvC5/cMHI+27qRt1gwzB8ZZK3J7n3Bv/0FyX5hWEYvn0cx394g3/7mua4TwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMyDBSQ/tX+Rjy8aOEvDMPzpJG9L8uqJIl6d5H8YhuFzxnH8zoky/oA57hMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADzsXGzN4CuYRi+OsmPZLqFFn+/vzkMw385dcgc9wkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIB5sYDkbWQYhgtJfjTJZ7yIr/8/Sf5Gki9Lci4fX5xxN8kXJvkrSR5PMr6I3/k7wzD86ZewuS/KHPcJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA+Vnc7A2gYxiGRZIfyccXTLyWZ5P81XEc3/YpPvudF/57T5IfHIbhdUm+P8lrz/jN/3kYhkfHcXzq+rb62ua4TwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMzTxs3egBm5lOSnb/ZGXMNbk/yRM77zb5K89tMstPhJxnF8Z5IvT/LDZ3z17iTf+2J+8zrNcZ8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYIQtIvjS/meSfJvnbSd6U5Nw4jn8oybfe1K36NIZhuCfJd5/xtSeTfPU4js9cz2+P4/jRJN+U5J+d8dU/MwzDG6/nt69ljvsEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAfC1u9gbcAp5J8q4X/nt3kneO4/jBm7tJ1+07knzmNT4/SfLnX+p+jeP4/DAM35zkV5JcuMZX/06Sx19Kxqcwx30CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgpiwg+al9X5Jnk7xrHMfLN3tjXo5hGHaSfOsZX/vecRx/+eXkjOP4O8MwfHuSf3aNr33ZMAxfOY7jL7ycrDnuEwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPO2cbM34JVoHMf/cRzHn7jVF498wTcn+cxrfH6Q5L++EUHjOP54krMWUvy2GxA1x30CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgxiwgOX/fdMbn/2gcx8MbmPc9Z3z+dcMwXGvxxxdjjvsEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAjFlAcsaGYfi8JK8742s/cINj/3mS37rG55+R5M++1B+f4z4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwfxaQnLevO+Pzd4/j+OSNDBzH8TTJj57xtbO26+X821txnwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJi5xc3eACb1xjM+/8mJcn8yybdf4/M/MQzDq8ZxfP4l/PYc94mX4Z/8k17Wa17Ty0qSRbGE3jm4Usv6397xQC3rL7z5uJaVJO+/tFXLeujXfq2W9RV/6VW1rO/5ni+qZSXJ0VEv68sf/+9rWd979F21rLe8pRb1gvtrSQ+eO6xlPfFELSrnz/eykmRn3bvQjpd7tayDy7Wo7O/37i9JsnGlVy9oVrB+5X+vRWV3t5eVJF/1R096YcXzY3+/V+ZfPdqsZSXJ9nYvb3NxWst6+ulaVLa3e1lJslfM21v22jGn6d1jtpa9czFJjlcbtayt1aqW9fafqEXlzW/uZSXJ5WL96v6DXgX8yfUjtawLF3rn/XJZi0qSrNe9rJN17+94+XKvTvDA+W45vJNem3quQ12b627fZr0h01LsANxsF47FQYRm2djUHIdJkl98Z+/v+If/cC0qxepwtpqdckk+sCr2R1/o3asPj4rXdPMESfLd391r537jN9ai8lWPFQe0mv3DSd516cFa1p133lvLet3ralHZWHXrjVdXvetsb7tYvyo2PNt1q2o9tTkAX8zaKlccr1zpXWeP7F+tZeXp4vlRbp+tFzu9sHbbs6V8nTX7o3d3i2Mx6bUrThfd8dVmnee4OH7WPPPbvajNseP9/V7WRvE6a7epny7WQZrF/rlzvayNo97YyGGK9Y9057lsrIvzoIonY3O8s523ld59erN4zI7X3frO1lGxfVaca9tUP2bFuVAHB7WobG/3+q6aXUlJsrfdu8c8c9A7H5vzM66uu3WQ5jE7XPX2bSe9/So3K6pl47Mf7JVX993Rq1y1x31Ol722YLM/qXmPac9pb7aZtha9rJN063JVxXbMZrEMOV0Un3WbcaO6+sxDc4ypPJ5VHYMvnvvNfv2T5jWd7mV9VGzH7DXrcu0JsDOds9x87rJ9zJ58spd14ULxWdkrz9Wyqsds0e2zbZbDm82w4iFrjgsmyVaz8dntkK5F7RTHs5J068TNud/NCRrlpmDT5qpYhlTbZzPu3ynqNqm77fed5nyQKwe1qOpc/XaHdFHzz3iy6D1b9P++qxaVJLnrrmJ/47p5P+ud+6fpPu9TfTY3vbCjda+/cWe7/A6NYlE812f768/VFfsmdrZ7nROHxffl1cfEi/0uzTmph8XncttDCFn2xmKaY+LNZ4tm/W6+Yr2x2j5bdNvUW8UxrcOj3jW9LJZXT1/qZSXJIxeL/SDNAZLiTebooBaVve1uh3SzjtqcD7LZvKjLE6Srf8fin/G0+M7vto3m+xSb52Ox/Ljv7lrUC4onf/HvWB33KddRp+4G2Zhn19iZbtPdnr9hGBZJ/tgZX3t8ovhfSK45QvCZSa77dXlz3CcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABuDxaQnK8vSHLnNT7/WJJfmiJ4HMdVkl8+42svZbHFOe4TAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtwELSM7Xa8/4/H3jOH50wvx3nfH5F7+E35zjPgEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAbsIDkfD16xue/OnH+Wb//UhZbfPRlZr5cU+wTAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtwELSM7XQ2d8/usT5z95xuef9xJ+c477BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwG3AApLz9YfO+PysxRBfrrN+/85hGO65zt+c4z4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwG7CA5AwNwzAk+ZwzvvbMxJtxOcnpGd85a0HI3zPHfQIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOD2YQHJebo7yfKM71yecgPGcVwn+e0zvnb/dfzkHPcJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA24QFJOfps17Ed56bfCuSZ8/4/MVs5/V891bbJwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG4Ti5u9AUxi70V853DyrTg748Vs5/V891bbp4phGP7TJP9JIepzCxkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC3JAtIztPdZ3z+kXEcny9sx4fP+Px6Fluc4z613JPkkZu9EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALezjZu9AUxiecbnv1vZiuTojM/P2s7r+e6tuE8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADcJiwgOU+bZ3y+rmzF2Tlnbef1fPdW3CcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABuExaQnKc5LrY4x30CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgNmEByXk667g+X9mKs3NedR2/Ncd9AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4DaxuNkbwCTWZ3zeOu5n5XzsOn5rjvvU8sEk7yvkfG6SzyjkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3HIsIDlPJ2d83jrurz7j87O283q+eyvuU8U4jv8gyT+YOmcYhvcmeWTqHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgFvRxs3eACbxsTM+36xsxY1dbHGO+wQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBtwgKS83R0xufbla1I7jrj87O283q+eyvuEwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALcJC0jO09UzPn/1MAzLwnbsnPH5Wdt5Pd+9FfcJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA24QFJOfpt1/Ed3an3ogXkfFitvN6vntW3o1wVsb17BMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC3CQtIztOVF/Gd/cm34uyM61lscY77BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwG3CApIzNI7jcc5eyPC+KbdhGIatJHed8bXfeLG/N8d9AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4PZhAcn5unTG558zcf6L+f1L1/mbZ33/VtwnAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbgMWkJyv/++Mzz9v4vyLZ3z+7DiOx9f5m3PcJwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG4DFpCcr/ee8fnnT5x/1u+ftX0v5d/civsEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAbWBxszeAyfzfZ3z+xRPnv/aMz3/5JfzmHPdp9oaM2VwfT/b7b3rT1mS//Ym2t2tRSZKjo25eyzd+YzNt2QzLZ35mMewrv7IW9df/+gO1rDe8oRaVJLl4sRi2/5dqUd94UIvKnXf2spLkvt95fy3rdPuhWtYjF09qWYerzVpWkpxs79Wymo2b+8/1jtlpusfs6nav3F+ua1HVe8z5872sJHnmSu8c2d+/v5Z1vliV29vuXdNJkkWxxDo4qEWdP98r8zdyWsv6uOIxW/cKx42jw1pWlt322dayeMyKHQaPPlqLqveD7GwXr+vdC7WoC8X6zkc+0stqnx/NImQzvXrB7m63rl/VPElWq15W0emy1/edJBur6frxP9HhurdvO+0Cq+g0G7Ws5mXWPGQb625b8EunHsn8fY7XvXvM1rJYjytf0w8ur9ayTta9NnW1eVasDyfJW9/ay6qOMS3nW7d67LFeVrNLrlm3ave57C2K989iP1nz77guN2E2mwNozfOxeFGflMfqqveY3d1a1PGyV99pFh9Jslfs2zzNTi2rWS3YKs9kbo73N9tnx6teX0G1LZhUy/2tRW/fmsesrdmEL97OuseseO9MkgcWvbHj0+3e/ayqeOLvXHmulpUk2T7XzStp9rNP+TzFp7JojjMd9SrgJ4vefjX7kpLkdLdY7hfr+seLXpnfPmYn614ZsrfbnivXsbvbrQ8fF+fQn2veOovXdLPu/XG9C7tZhjT7G+dcNt51Vy0qp8uZtmFSnkdc7LjdKZ78zT7buuLfcbM4vnpcnLuWlPtSi9fZnMcQmu2z7mh/L+3wqFvX31mWnwkr2WxOLlh0z8bN5vM+xT7A5tzv9vzXXL5ci9qsNqrn+8qt/f1e1mZxfPUmdE5ULMrzXDZXxbZgs13RPBfLc9qbfS4pvhuk+Qxfe65t85gtzt1by2rOy2v3bfbfW1BSPGjden66nRPFMqT5HMJx2v1kxbnfu72ysVkHac5zSZKNYp1nq9nOLZaNjz7avc6q989mO6bYL7FRfq5uq/mSsmIf4M5B77ncrLp1/eaFti4+h1BtU5fvZ805h0cHtajqfLL2uM9JcY5Gs51bHc8qP1h3UmxbNMdimnXUqwczfv9U8Zpudk20+5Ka/Y07i+JzD8U66oUL5Wf45vqipuI9Zq/5suryuHGzX26uI+LNen7SHrPohTXnEDfr+Umy2awTN8vh4vvFm2tKJMlmsf7dPB/bY55NU4/3Dxkn/f1Xqvm+eYKzFls8PwzDlCOcX3LG51MsIHkr7hMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC3AQtIztQ4jk8n+Y0zvvaGKbKHYbg/yUNnfO0d1/u7c9wnAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbg8WkJy3x8/4/Ksnyn3jGZ//+jiOZy0E+enMcZ8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYOQtIztvPnPH5nxqG4VUT5H7DGZ//9Mv47TnuEwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADNnAcl5+8kkx9f4/N4kb7yRgcMw7CX5mjO+9raXETHHfQIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGDmLCA5Y+M4HiX58TO+9ldvcOxbkmxe4/PfTPJ/vdQfn+M+AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMH8WkJy//+mMz//kMAyP3oigYRi2c/bijT80juP4MqPmuE8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADMmAUkZ24cx59J8qvX+MqQ5HtvUNzfSrJ/jc8/muT7Xm7IHPcJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAebOA5O3h757x+R8fhuE/fzkBwzB8eZK/ccbX/pdxHJ99OTm/zxz3CQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJmygOTt4YeTvPOM7/zdYRi+7qX8+DAMn5fk7UkW1/jah5N890v5/U9jjvsEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADATFlA8jYwjuOY5K1Jxmt87dVJ3jYMw1++nt8ehuErkvx8kn/njK/+V+M4Xr6e376WOe4TAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA87W42RvwSjUMwx9L8tB1/rPPehG/e12LGb7g58dx/PWX8O9+zziOvzQMw3+T5L+4xtc+I8kPDMPwZ5N81ziO7/x0XxyG4XOS/M0kfyVnn0c/n+R7r2+LzzbHfQIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGCeLCD56f1HSb55gt/9gZfwb/7DJC9rAckXfFeSP5rkj53xvTcledMwDE8k+YUXsg+T3Jnks5N8aZLXJxleROZzSf7COI7Pv9SNPsMc9wkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICZsYDkbWQcx+eHYXhzkp9N8kUv4p88/MJ/L9VBkq8Zx/GZl/Eb1zTHfQIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGB+Nm72BtA1juOHknx1kndNHPVcPr7Q4q9MnDPLfQIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBeLCB5GxrH8YNJvjLJD00U8c4kj43j+EsT/f4nmeM+AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMB8WkLxNjeO4Gsfxm5N8bZIP3KCf/XCSv5bky8Zx/M0b9Jsv2hz3CQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgHmwgORtbhzHn0zycJJvSvLOl/gzv5HkbyW5MI7j3xvH8fkbtX0vxRz3CQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgFvb4mZvwCvVOI7fkuRbbvJmVIzj+LEk/zjJPx6G4bOT/PtJXpfkkSSfk2QnyVaSjyb5cJLfSvJrSX4lyb8Yx/Hf3ITNvqY57hMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC3LgtI8geM4/ibSf7RC//Nwhz3CQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgFvLxs3eAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIC5s4AkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQsIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQtIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEzMApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE7OAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDEFjd7A4B5e/50yNXV1mS/f+nSZD/9SV776GkvLMnubnGN31XvdtA8ZufPd9dJ/t3fLYad369Frde1qOz3dquv+YcsuuOObt7J3Q/Vsi49WYvKxYubtazt7VpUkmTj6LCW9a/es1PL2t/vHbM776xFJUnuvruX9YM/2Mt64ole1l/8i72sJHlov3edHa9619k73lGLymOP9a7pJLl/8Vwt6/TcvbWsg4NaVJbLbl1/K8e9sOWyFnW86v0dV0e1qCTJ7m4xbLtXNp4/X4vKRrr9ICfr3vm4uVrVsrZ3p+sX+6SsYl1/Y1UsF5N86MO9v+N9d/Xa79vbxTpIu19i0etvPFn0zo/NRa9sLBZVSZJF8e+4LI5OnqZY3ykfs6ad7d65P9c6QZI8ddCrNz5wrnevPlkXy+Hy/ex4uVfLapaNzfb73qJ7zJptpq2DZ3phxQG0Zl9SkqwPilnF03Fru3hRtyshzT/kUbFDqdiZ1Kx711250ssqFvrtvs1qlefnfq4WtfWa19Sycu5cLyvJ4VGvHbOz6o0xbRXHK9KeUlPsTN3KSS2ratU9aKfL3v2zOT6ytSyOxTQbg0keWBbPkVXvml7O9FxMUp1H3J1b0MvaSrF9VhyHaTtddOfwtDTvZXPWbHbev98uh3tlSLOu35yb1BzLTdLtlytWrarj7+vu3JOt4v2zeT87Lc5da3dHb617HXPL4t+RW0/z3N9adPuSjhe9c39r0Sv3q31J65n2/yXdAYtmVrtJXdy36jXd7Nss90dvFI/ZlO9f+ER7y94NbWe72CmXdM+RYpu6WddvPxvQbDNVhzyLp+Jmu4+4OK+meX40pyYtl/Ps+066c7+T3t9xszjW3yyrkiTrYuBcH7Ioz2mvlvvNwrG5X+VzcbN6YTfrBd1n+6vmWl41zfhv2Hw+caNYNjafY0pSPUdWxWfdFtvF86PcH31SrH+vVs13rxX7JWpJH1etyjX7rpr1xnKfS/M6Wxdv1cvd3nO5GwdXa1ltW8VnHk7WvXNxxtNfs7eY53sAm++ZSLr9jVurXhlSfWdBuT96s/jcQ7N91rS3XZ57UuzfbM5JrZpxf+Np8ZhtXOk9K7ssv0PjZF2ck9ocpy6e+yfL3t9wc9WrxyXJonivbs7XPy72ybXn2jbbTNWxmOJ1Vl+ao/lcTLE+fDW9dsVeuWxsvvuhOrpaXJujbs6dPDfRPFu9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK8gFpAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJgFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmZgFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIlZQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYhaQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiYBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJmYBSQAAAAAAAAAAAAAAAAAAAAAAAAD+f/bu58W2Mz3s/aPq3bt3b28VdYo6fQ7KQYi2aCt2d7BNg43Tgx6YEJIeeOBB4E7zl9y/waMLmfc/cJMQPMggGEOMaZK26SRKI4QQR63DOUWpKO+UdupkoEyiaxK4yfqqWf35DCWo56y91np/PO/7rgcAAAAAAAAAAFiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBhCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICFKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMIUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYQpIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAhSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDCFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGEKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsbPNV/wOAdfva12YuLpb7++++u9zf/rKHuObu2TxksR6evpXFenrMQs2LF12smZlvP73LYj1s9lmsP/7jLNTc3naxZmbeurrPYt08/U4W6+o6CzXnu+43nJmZ99/PQn3nvfeyWGUfc3bs2qra97/fxdqEM6m6bSz98IddrN///S5W2Hx8YbPLQh3D5/FHP+pinX30YRdsZubiKgt1OmWh0rZxP21/dh+Ovye8Z6XLi26OOzPtw399nYW6uPpWFuv+1OZBtpv4GYmcnbo50/1ss1jbXTf+mJl5FPYxd6ewzQ/zZJ991j0fMzNf/3oX6/PPu1hPHnX9y/HY3rMl8/hfVnbTZ7c3Wazd4TyLNdP2MXPbNVi3p+53vLho79khfPYfduucw7ycyy7YzBxWupvictfNqe+mfc8uN2W+oBsT3x27+dl+187Ndrvw2k7duOBh0z37Z2VSrlZeWxirz4F013b/9O0sVvnkHw5hsNoPfpCFeth089x6Tfx81z2Rd5suR7zfxPtBVuomzPGcH3+RxXoI1ytyYfIqbRvLBODEe6HCPNmnn2ah5vHjdq1uwnxSu8rUSXNyZaxp97SXawjl/KzM78y0Y7m7MA+SdmfHcDF3ZiZcg7+57Z7HdGtBfHjk/qIbE29P3Tx3O+E+l3JPXmwb9p1l53k6tfsY7nddH1PmG8t9DHVyM13TCtd9JnwWVy0cX5Wj77tp+7M0b1uu1YXt1fXzLNTMzOyfdr9jed5nswnftHjcWOYLLtM9Gt0ELf8eQzn5DA96npVjufhsQJoDLOfU5e8Y567SMU94aeenl12wU/ue3YbnYsp3erXj4Vp4FrJM7Jd5iU241j/T5hsfwnMx5Vp/upYbK4cFZZuf79sMx3LpnppyvWLFymd/ynPi8V7bcm3wEA6/y6HV5a79EMk2HBJvN+G+zXCOW289OV/pubq19tMzk57Nbb/TtM7nY6bNk+3D9Yp0z0Q8Bnl57O7Z5VrTSXGHtlnpHL6cV7RzmHbcmM5zw2e/zMnNzJyVH7c9dO/02XW47lMnr8LJZ33+rFLO32fab7qU+e9P/qZrr56E37uv2+Fy2HgfzmHWOhyeafeTld9/3V53Z9I38Zn0chqzDRM8u125Tt2+1fW3jyvbcoIW58mWXvd5PW8s+vd/Wa3zTQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD4JaKAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDCFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGEKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIUpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwhSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBhCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICFKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMIUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYQpIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAhSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDCNl/1PwBYv7N5WOxvv3jR1cHdxC3mZtNd23az3D36svK6Docs1BeOxyzU2UcfZbH+/M+/k8X6p/80C/WF8J6dXz/PYv3F+29nsa6utlmsmZn906ddsOfdPTsrG6zwuZ+Zmd2ujRdZcnzzZadT13fOtGOed9/tYr3/fherfs32F91Nu7jIQpXN8Bwuur5zZmYXvmfb25dZrFefX2axzt/MQuW2Lz7OYt3u3spi7SduHMvG+E/+JAv1b//x/53F+r3fuc9izcy8vO7mFpf/4l9ksT75w/8ri/X1r2eh5nLXvtPb8J3ehnOY+80+i/XkcTeHmZmZ0ykL9bApcxPrHHvPzJy9+EUW63T4VhZrG05yb2+zUDPT5hsnzMmVaf2wqZqZmctjN9a/ue3G+mX6r16rK+fUL6ebU19cdGOQOjv8yafdtf2zf9bF+if/JAs1375qO7QPPjrPYl1fd7F++7ezULM/tffsftf9jq8+696zN8N84z7cnzEzc3fs1pn2u+7a7sP1s+20ebLrME/20W0Xq5znvnXVDhx//lH3O/7ar2WhZve4u66z410Wa2bSSfxm1431y0nT2altG8tJ/M2pG4Ocz00Wq1budPl/ftyNUf/4j7NQedv44Yvu2Q+3v85773Wx9puubbyfdt/mq1fdW/3kUdjHHLv+5Xjs3rGZmd1F94zswznT3am7rnItd2bmZz/tYv2978Zrx5GXm24Ncmbmebgn9b33uuexXD8rzzHNzLy8Lkep5bmprm2sjwVsT92Y+H6696zcm1RvZNiEawgPYaztbTd/v9t01zXT5vVfHrs82WU4P6vXfabc61IODMLc5luHOCd36tr9y/BsUb7xqhReWjnP3V93e9eOF93etZl430S5gS3cP38Xjodn2p/x4+vu2t666OYw9T0rlWPU9KhbPKl+/kEXqzwnXo5Byn76s8+yUDMz8+TRRRcsbPT3YS4pnZtNm7tK9+uX32iKc5v1em6l7M7K77nMxHtSw/bqYde1H/k3ViZs98O143T9bNM2jq8+7WI9ftzFutyFz2L9ooXfQ3sZ7qsp1xA++yz+Nt+jcDB3fZ2FutmE3zI6tGOQ8rty23BOXe7PuDxeZ7FmZjZXYV4uXO8/W/FB8cvpzok/HLr2ah/uMy/PV8zM7MK8S/m9vCcX6zx3OTNp3vaTV9346skbYe4qbhv/7Gfds//972ehVvvd45n2WyRzHYa67fZ+//jHWaiZmfmH/7DrP3/3WffNsJnunv3lT7s2v/w2yEx7Nncbzit+ft21Vd9+J/4AVZmXC/PR9xfhdwDjdZ/drhsTf/y8a68++CALNX/w/fY9K7/z9nG4p/3qqou1Pbb7o5c+mvv69bJ//5dVPKMHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+NWjgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwhSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBhCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICFKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMIUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYQpIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAhSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDCFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGEKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIUpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwt54/fr1V/1vAFbgjTfe+KuZ+c0v//ff/I3fmL/6sz9bLO6Ht5eL/e0ve/o0CzUzM6dTF2u362KdHe+6YJtNF6t2PGah/tWfn2exfvjDLNTMzGznPov14fNtFusb38hCzZtvdrFmZvbTtSGffLbPYj151D2LubAtvjueZbH2m+6e3U/Xfsy0bWN5bWHXmY7jZmYubz/MYn3yjbezWE/e7Nr8u+na/Jl1D1Mr2+tftAEvLrJQN8eubTwcslBz9vzjLthMe3G3t1mof/6Tt7JY/+gP2zHqWscFP/lJF+udd7pYbz976ILNzMN0Y/3r6yzUXF50v2P5G860v2OZ29yfbrpgtfKHXKuyg5mZh0OXtz07deOCcjx8votzcuFksGz315xzOd+Ea1rlxYWxHi66tdyZdHo2L150scqxfrqWO/FazDfDsVw4tvrkVbuG8OhRF2t77O5ZOraadk6dNo5lrPA9q/uz0kpv2Ww37Xv28robf1+euvWRh6tvZbHqsX757K/1nsVpkPnssy7Wk//Srb/fP+3W3+v37KOPuljlsmC4bJynbD/4oIv17Wfr3JtU7gUp12FmZi4PYS61/CHDDu3m1O5NOr/t9mjcX3X7GNb8npXXlu4XCvMg5R7imXYfcTmYu9907dWrV1momenPPVTSZzHe/Lra/ULl2CqewN9tulz7fhfmAMtJdb3JPHxGHnbtmLhS58nKR6Q8W1Qq9ybNrPfsSNkO12P9stk/P6x3H3GpbIvL8Xe5H+TJ4/Wur5btcLomHvfTZa49Xcudl1msm02792StY5BS2b+Ua5Az7dmAsv1I9wvVC/Chh013z8pnsbyumZmz23XuWU7f6VO7p321nWd4Xfendt5Z7jNPc9/hd7XKdcGZ9jUr5xXnp25ecbdr5xVlHiQdg4TnpupvGa31e2hlm19v3Fzr75ie0bru2uGZ9nxROWf6+EX3LL71ND5XVyZ5yu9tntp5bmml24hT5R7Rmba9Sjd5rXWRaWY+vu7GqW9drPR7HWv+RlP4nv38tjsLWaf/rq66WOUenv/4fpcD/M7TcC5Yr/uEi4M//6C7Z+V5wTXvtU37mPLDSXHfeTNdbuJ8uvaqvK56uLPW+dn5sfvOxP1FN7aaWX4t5g/+4LfmP/yHv/7b/tdfv379+reWjf7VWe9OXwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBfEgpIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAhSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDCFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGEKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIUpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwhSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBhCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICFKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMIUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYQpIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACxs81X/A4B1e332tbnbXS729y/CVux06mLNzOznLov1MPssVvlDvjyG1zUzl7vuns2me/jffTcLlb9n2+kCXl1ts1iffZaFyu/Zw6F7r9/MIk36Q96c2rZxt+tipc+jmdT/Ebe3XazjsYv19GkX6wuHLtTnXahyLHd58ZDFypUvWtnoX1x0sWbSTuY8/BnD4fDcXbzVBZuZ/e0vumBhJ/Pee1moeXnbzWFmZi4P91ms7alrG3/jN5bLi33Zo0dZqLk/nXXBZma76frqy03Yd4bjuHI8PDNzCIeo5XBnv1vxZPD6Ogv1755/K4tV9p2nTdt37j/4eRbr4923s1jlnPph2nt2Ft6zs3feyWLtN+HEom6Gb8MONOw8H8L26uz5x1msmZlNOPcMl+rKbnouy7zEzHzzm12s+915Fqucw7yZLmi14+/Dobtnrz7NQs2Tb5bzzpmb6X7H83Au+BA+H/Wa+I9/3MX6oz/qYpW/4/bUJkL+4i+6Na1/8NtZqNR2uvzwzMzFRTgfPF10ocL3rG4bn7wZ7st78yoLVc4r6nv2nac3WawPr7txwX633r0F77zTrf3cn9q8XKVci7ncdO/YzMzdKRx/h7/jebju8zfhvt6ZmfNwX81axyD/6T91sWZmwrT+nE/YhoT7yZ4/b/uXZ8+6eOWZhzK3+fhxu/fk0zAHWO7hSScWZYJ4ZibMAZb7XO7C8fA+Xvcp96SWA4N0fXXaeefDrsttrnXcWOcK7o5d/7ld6V65802Ya5xZ7cG6Mr9T5zbL4VU5vipH3+X+jJn2NZtj90A+fty9Z/XZgPI9K8f6Z8d1fmeiDpceGTx1D8h5mHOZmXkIW/702Q8HBvtD2MGU+5Vn0sZxexvmo8uBY9nBTJxPOoXfugrzEmendm9SuW/zUA4L0u+5tOOd8j1L5zChbdh+1NJ7dlpnTm6m3VdT3rOHTfcdgfII38zMxy+6tvGtp+GcKexj9vH+6PLatuX4Knyp62+spOvUm3CvbZgruAnb4ZmZ83A99z48A//WVfdO52f7y0FImNws+5ibY/wNjXAN/jZcHylz33UeJF2nvui+VbO9Dr9fFyvnTJ981uUAy7NnZT890569vNl179mziyzUfPBBF2umrStxF36z9zvvdv303bE8L9j2nS+vuzHIs2dZqFT+DcxwXlHWDTgvryvsX2Zmzg9de/Wv/rRrr37wgyxUerZoZmZ7/VEW6y9fvJ3F+t13upxtvdd26TPOX3tjvef5/2faHg4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgV5ACkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGEKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIUpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwhSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBhCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICFKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMIUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYQpIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAhSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDCFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGGbr/ofAPC/43TqYh0OXayZmbk+ZqGOs89izeY8C3W5u89izczcl7/jSu12ccBTNxQ63mah5snjhy7YsWurZmbuT917tp+7LNb9pruu8+PLLNbMzGwuslDbTfg83naxtnHjWD6PFxdZqHTcePbiF12wmbm/+FYW65vha5aPv0N3x7Ms1j5sQx422yxW+U7PzGzDDNr9dL/jJryu/bTzs7QRCTu04/tZqPT5mJn0xb7bXWax5vMuVGl76uZLXwgfyPLhD5/73a7rX2bavvryEPYxm3BsNd2YcWbmFM4Fv3uVhUqfxbrvvHv67SzWIfwdy3u2ffFxF2zae7Y/hn11mbu6DRPtM3N/6MaN23DOdHYK+84yATgz+123PnI4dH11miKO89FlCrDsY+5P7ViudHkM+8/dRRbqyZtZqHReMTNz/vzDLtjTp1mos3C8s9m1e0F+9KMu1vmxW9Mq17PqbbF/+IdhsPevs1Bn5UQ3HjeeTbivJrQ93mSxTuEewJmZh7AtLp+Psj/bxwusd+Ez8uxZFmrm+rqLFc/Pro/de1Ze2v7UtY2bQ9g2Xrfv9P6w1j2p3XjnyZvx+mr4O+4u1tlPf+97bX5nH+7tfQhz32U++tvP4r1JL150scJ9UOXexlraFoc5wHQ/aryxN107DufU5bjx5na9+4V2F921lf3Z3am9Z/k5vki5blyfqyvPBqx241WcJyv3AZYjufJnPI/Pib8M+8/9lJ1n136U+6BmZh7CMzjlw1/mQcozUzMzswvbxtturJ/2Z/Gm5XLIU+bJypzLy+s251JO4ct9NWXbWN6zy118WDZ0M10e5HCRhUrX+mdm9qeuIX4Ic1dr3b8zM3O+6Z6Ru3Ctv8y5pOP8mSmnZ+WxmDSVFH93rdzHkLZXaU4ufs9C280679kmvmdvXYU5nvDRL7+LU493yrNM5fP46adZqHn0qIs10zb75fcUX4Zj1MuL9b5nZX/28rp7py938V7KtZ6BDxOA5Rx3ZmbSbxx27VX7eLTjxrOwQ0vXIctEe7yBp4z2efnttfJZLPcmTZsry787GAmPv38h/CHL792Xu5PKfPR9vG+z7GLKb0WWZ4DDpbOZmdmGZ+DPr9e5Z6L+fnS5b/OHP8xCpbmC+mzR8fB2Fuu75bhgpeuCMzOffLrs3oLTw3rPt/3P/GpeNQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBIAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAhSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDCFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGEKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIUpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwhSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBhCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICFKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMIUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYQpIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAhW2+6n8AsH4bLc3/PxcXWajTbRZqTqcu1uaw7YJNe20ffNDF+pf/sov19/9+F2tm5ve+192029vuefzgg65G+Lvv7rNYMzPnp5suWNiBHY9ZqDntLrtgM7O/7e7Zw+E8i3UWNvr3m/Y92859Fuvu2LWNZT99OnyrCzYzu5WOt89O3bN4P+24cbfrYpXv2YTvWdl3zsxcXnQv2im+tk77ns2mi/fqVRZq/vRPu1g/+lEXa2bm/Fn3npVd5yefdLHefLOLFb/RbYJxpcnMs3lI421vr7NYDxfdPLcco5Z92Uw7vjo/dM/jZtPlyc6uX2axZma24RpCOqkuH8ZycjYz+7lL42VevMhCPVy1OZdjuH62DR/Hh7KPifuzP/mTLtZ773WxfvCDLtY8fx4Gm/k377+VxXr33SzUXF11sfbl2tnMfPK17p49Ka+tHBfUyc1nz7pY5bgxVM+pf/azbh7zB9/tnv3tJvwdb9v37DbMlp2X7/T1dRcr9jDde3YKn49yr1y533Cm7T73m64/uzl1+0Hqbvpfh2taf/RHXaw0H12PQX7Sxfr93+9iPUy4nyy8Z3cr3gN4E96z8zJnG69B3h+6ZyS9srBD24frnTOTPiNnx+7Zf9h1452670yTgOH8bH91yGL1uaSwxQonMfsytxnnCjbh+LteO67Ur1m5jSFt98vERLy+Wu6F2pTXVj78dfsRXlu6tyB0Ft+zsvsszzzsw3Wfh3jXcjqF34Xj7xXvy0vHBbfhAkn4O96UZ89m5hA++ulLHb5nd9OeOS5f6/tNNxcsm8by2yAz7f7G8kx6edM+/7xbr5iLeF4RDlLP13rmIU66lN/QKJX7d+qcS7lfKD2Tnn40bL3ffljrNzRWmmbPlfvJzjfhOG4mfa/LPuZ4CveIZpG+cAzzBeX0vew7z8scyMxsT+X51e6mff3r3bPY/oYz2/QbGl1nnU5z4/lZueb58rrrz8rp+3043pmJv6cY5m334R7A/BuY4TrkNpyfpd8RyL/zts7vNKUT3bg/O4XzmCdv/CKLdb8Lv0US78sLP+mSjgt+/OMuVv09xfKmlaeL/vKD7jsTv/vbWah2vXMm7TtvjmG+MTx7lu6fn5mbsK7EYaXnV3fxJ1bKfZtl31mqv2V0fezWxMspTPmdyPpc3ePHy+au1jrV/F8Jd1EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/GpSQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYQpIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAhSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDCFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGEKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIUpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwhSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBhCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICFKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMIUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYW+8fv36q/43ACvwxhtv/NXM/OaX//vf/bu/OT/5yV8tFnd7/YvF/vaX3R2+lcWamdkfX2ax7naXWazNJguVe/Xqq/4XLOM//+cu1q//ehdrZubJo/ss1svbbRbreMxCzdOnXayZmbPbmy7Y4dDFKt3etvHK3/F0Wmes2N3ss1j7ucti3Zy669rtslAzs95H/3zX9dP30/XTMzPbY9iflcIH5P7QzWFmZranrr1KJ00vXnSxrq66WDNzc+ze63J49fx5F+t3v9u1wzOTtiEvj924YK3zs3RuNjN3m/MsVjneWeu0c2bm7Bj2neVNW3Fys5wLlnOmsh3en9q28Wa6tvF8073TD7vuWUzbqpn24b++zkKV87PttGPUMl9Q5go++Zuu/Xj8OAs1MzM//WkX69mzLlY5BKnHqO+/38V6550uVtle5bnNMk+21uR3/aKtdc5UDvbje3Z3PMtilbdsrY9Hbb97yGI9TPcs1svv6dwifPjvT9092266Z3Fm0nlu2u6XjWP5G87MzabLF5yfur22a07s3526ucV+E69DRh423W9Y951rHcuVY6tynD/T71+rpHn9FW8CLNurck9NvZRb9mfpekU41i/nMDMz29tu3Jiun5X7UeO2sWyvyj6mXBOvx43lWK58HFc8fU+vrXweLy/C3FV9Rit8+NNcwUpz37WzUzdGLfvpum0sU4BrHX/XTePlbp1jubWOUWdmziZeZ1qjeFHcs/+/r+7P0jHxSs/bp+Ph8NtCMzNzcZGFKtdHylxBfa6uHKSme0/C/TvlHGam7c/Sb4OEayNlOzyz3rXjdH9GvFhX5nhWO4dZ8eaT9PlY8bfQ0nFBeE6l/M5EOjeb9ea/yzRIvfekbIrXuhaT51zCfPT9pmuv1nq+YiYeF6x0f+PNbdu/nB9WOv4urXisv9a9trW1Hjk+e9HVKCjz7DPr3Uv58+fdeOfbF/FaTKisK1HOK8rB/stpv2u72u9SrnTv2kzbd5ZnHsp5Rb436aMPs1gPz97OYq35jNZaz0LWuavS5WbZ9ZHf+r3fm7/+2c/+tv/1169fv/6tRYN/hdaZ5QcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD4JaKAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDCFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGEKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIUpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwhSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBhCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICFKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMIUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYQpIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAhSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDCNl/1PwBYtzfemNks2dJcXS34x/9Hm1MW6guHQxZqv3nIYs3x2MU6tTftyZtdt/rhi30W69d/PQs1jx51sWZm4Qbqf3R7m4VKH/2zCduPmfTibm7XWWt9tztP421P912w8J1+2GyzWHF3NrtwlvjzD7r+7J13slB527g9deOrl6funpXv9Pb2Jos1MzPX112sp0+zUGXbOHHbeL/pnv3thH1n+HysWdlX/52/08XKlfmC6d7pML3Tii9sF8Yq3+kVp8nmPJxYpP10mEet8xLlEPXioosVTivm4dDmXDZl1xn+kGdhLulhF85xJ26LD5dZqO2xm1O/PLXv2eW8zGLd7bp79uTr3XXNXISxZp486frPy4uVrq+W/cvMvPNOOJYL26s0txnmh3PPn3ex1pwn24Wz6vCe3V+9lcW6vc5CfREv3Fvw9r//f7tgv/M7Wajd0+75mInH+j/9aRbq7N13s1inMGc7M3N77Na01poHuTu2uatNOM8th99pqv2i+w1nZv7m0y7W4XF7bWtVTi1ehu1w2TaW73Q6x502/11OYR6m68/K65ppx6jpPpdSvcAaDkLOTt3E87xsHNN9JzPlkcxtubE3fPa3ZUc9k3bW6aWFnczdKdwjOu2e9vLZL9fEb2/be/b5512s80O4VpeOC9p7VlrtXsp63Bja77r37P7Uzc/KPYAz7T7A83DuueJHvx3LlePvLNLMxUXcn53W+cmcen9jqczLlec80+uKE47lPobDoXv2y/6snC+tWpgDPIZ5kH25sWDa9qqcV5TXlS/8hLanuyxWeR4sHzGGz0i47DP34XcE8tcs7GP25cXddtd1X3/LKMzxlHvl9ptuDeE+zkeXbXG5dFzO3ss86kw7LijzIOm3RONE6ln58If92SYcg9T7oNL9IGmCpxsXXB7ae3Zz7Nqr83BOnfbUL150sWbmLPxeddk2lnmQdH/GxLn28ruDK95LWe4zL/O261yB7JV75coaBfW5urRuQLhpIt2fEa/FlPbHMK8ffot4G96zY/hJi5l2WJC2w+F3Jk5P385izdR7JsJvhq31PNjM3IfPyDF9PrpY6XxpZl5eh/mk8Jthu916z6/eHZe9Z6/fWGd9mP+VX82rBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwhSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBhCkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALEwBSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICFKSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsDAFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWpoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMIUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYmAKSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYQpIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACxMAUkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAhSkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDCFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGEKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIUpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABa2+ar/AcD6nc3DYn/7/tTVwb29zULNzMzl7pTF+uTVNov16NE+i7XZZaFmZubseJfF+sY3slDzX/9rFyt/zzZdwMPhPIu1K5/96+sw2MwcDlmo881y/df/x/HYxeq6ly+ED+TDdOOCss2fTdd31p4962KVfcx5OI6bmfQ9uwj7mPSdziL9d0+fZqHuTt1Y/xi+Z5s4o3W+6dr9h9062/1yuDMzc767z2Jtrrr3LH32T3F/Fsb7/HUWai4uulhnL37RBbu66mJN+zi+etXFevKoa6vuN11bNTNzP1287XS/40N4XfV4p5yfpXPq0MO047j9lL9j90CW7cerT7NQMzPz+HEXq0zbXh66ZMEmnlfMrstH79J2v7tn5VruzMyjR2m4TJkrqNfqykd/Ww6wwlh39Rjk+LILVg5Sy4lnPdgvE3PhWm55yy4vwnXjafcxzPe+l4W6v3ori1WviW+PN12wd97JQv38edfH/NqvZaFmph03rrWL2e/atvHu2M0t0nXBcCy35D7ev803vxmu95/CXPuKc8TlnsM0rx+vj2TqByRUriGUc+p0X2+sfM/SbGP9noVz6nZfXjsGKb08hnm5NL0TrvWH47iZur0Kn/2wvdqf6rX+rgO924TnfcIuJuxeZmbF+xvDWJcX6x3rt/esC5XvtS1ftPDa0tl7ftwnvLrw+diG8/eLi3ZNvMw3rnWMWjeN5X6QT8M9h08ed/fs4+ftHq+3nnbXVu5fK3PftfMwv3l37NrG/alb63/yKE4Sv7jOQj1cfSuLdRb+jJflOx33nbfhe7bZdO3wflPesxXPBcNFrW04Ri3XRmbafS5lDrD9xkrcd64051JeV900Hsv9ZOE3C8pcQZ2NLtuQfbpg0cXqtwt1Ac+uu3Mqm91lFov/M9a83zDdWxCO9ctxQXpecNpxwWo/F193aPVANZJ/Ly+UXttaN/fG71n5mpVnmep8Uqm8Z+UZnDLXXjcfZb5xny5ahM9H/BHM8vsgp/B71eW3SC4P3bN4DNfOZtJPEc99+C3izbO3s1jld49nZi4P6zy/Wr7UxzgnV64db8IzOOXexvogwufhvrw1j/VLS38D840JPxr9S8TTCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAwBSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDCFJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWJgCkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALU0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGEKSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsTAFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIUpIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwMAUkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABamgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwhSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFiYApIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC1NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBhCkgCAAAAAAAAAAAAAAAAAAAA/Df27j9W1ju/D/r7OZ6dHQ/js8dnz/U93Hhd78Z13N1Vskm8ISFRiJq0RNpUrNKqhaLSQgsLooCgqYTQKgilSSHQQmmhKm1EVbVCIDWENj/abRChhArKplnSzdbdmNQx7uV6fbk+PXv27OR4Mg9/3C1KvY6P7Xuf97XHr5d0//EZz2eeme/z/f19PgAAAAAAAAAAAAAAABOTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYhJIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAExMAkkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAiUkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxCSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiaBJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDEJJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJgEkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATk0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGISSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMTAJJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgInN7vUHAHbcSy8lzz032dvPHn5ksvd+ucODbS1WkmTTq6KvPnBei5X1phhr3YuVJLPeb/bgg8tarBdfrIVqfoX1gKtFLVT3e5ytisHSvbhiHXKe3j29KJbFtr11rz3bLnq/2bx4Xbf17rP5pz5Vi/XU4htqsR5+eF6Lldzucrdc/QefrcW6dfR4LdZhuQ9ykV4ZWc4uarEWB92y37QtttXN9qzZMVi2+yDFsefy6adqsfLBD9ZCXRTLfZLkoBfv6tmtWqysd3MweL7eq8VKkuXmtBbr6gPVQXUt0qY4JZcky0VxLvXmSS3U3tFRLdYy5bnNn/rferGefLIW6jT7tVjlWbLk5KQXq9jGrBcP1WI9+GAtVJJuX/9wVWzPio3MbFYedxbniPdm5caaO/b8C70+8dUrvb7VatXt6++d9fr6WdVb64r6xq/m93h21otV7O9s073PUlzT2kuvvtrlprM5jjmb9WIdFyusvU1vbSRJtQ453fTu6ePjWqjuXFJZs96vlv3yvrzZoldf7eq87WxW7oMUbYvzBdU9PO3+zqy4NlhsO5t91OZN3dy71ta8tuY2hvZaXX0/dssOr4k39/Y25+TOi+PO9abZZ+z+Zs17er7Zzb3Yu6w67qxFuq15bcsUy35xX958trtzLtU1hGal3+44Fp1veuP35tTV4cFBL1iys2fddnYMk3L/qji/s9fcT1beSrlsrmnt6NxVimemkm6/sbmHp/mbHR3t7m/WLPrz6jGEbuN5sSmOz4pnITMr9vWb+76TXBz09mM317SqtVWxAmn2vZNkf9G7z5pnqavKD+w4PevVw/urXn+n2b6058kWi961NcdMy2J7dnF0rRbrtuLekxT7O9XNSb1QSbI/2805l+oYplkWk+56f3E+erko7oNqP3+qOR+9OKzF6j6br1s5ble9fRPVuc2i9nU158nWxbqxab7pLiI0z3M0h57VMdMOPwTzdN27z3b1iGc73rWD9vM9O9r78tbF3+zGSa/tfOSoVz7ac8S7ukejeV3tfmNzvvGi2N/Z1bKYJHsnvWcczqvP0NjNccXDD3fjNfs7zeLRPN+8WpXL4o6mVJk397+W9wA2zxw33TrrXdfhqruGcP/9vWtr9uXWxfOJ7SmXqefJtuMw6fu/We3u0yAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3iQkkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmASSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABOTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYhJIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAExMAkkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAiUkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxCSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiaBJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDEJJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJgEkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATk0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGISSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMTAJJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIlJIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQkkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmgSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxCSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiYBJIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE5NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBiEkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATEwCSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICJSSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDEJJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJoEkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQkkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACY2OxefwBgx+3tJavVvf4Ud8W2nHN3b72uxTqf7ddiLXNai5XFoherbL7ufY9Xr/Tu4fZ9lt5tlnkuarG2mddiZdbtTl6/0Ssj1xa9ArI8KNZXm00vVpLTda887q963+Pe+rwWa7tY1mIl3SIyPzioxWreZsXL6rvyWC3U7KwWKttVrz+cJOvitc2LZf/kpBdrl++zZr2/l20t1i6PqXN01ItVbKjn5X5jVbESaZb9zaxXfyzqKwvF+cVm2S/GWpZ/s/PiWHBZnJu42PTu6Xo93JxLLf5m+7PenFyz3CfJstieXRTbmFWxvtrl7k51Tm7TG+Quy8s+zfmCvU2vvmqaz3rjziQ5X/fa6ne8oxYqp2e962ov7Z+md5/tF+dBmmVxuWjfZ702ZrY6rMVqmp/cqsY7X/S+x+WsOHfVXKc+K07qJ1kV+yDNPnF1PnrWHZ+lGK/ZntX38DQVC/+muIdn1iz7q+59Ni+W/Zz06v3ZwW72d5Jkf1X8zXZ1kqd8XfPi2KK6ftbcB1Xso+5qsU+6W1KbfdRNcY0p6e5Zrv5oN2/WQjXXYW4rfo/FdcHm3oIdPjrSrfeLX2SzHk7S/SKbmymPHurFKquWkWJ71tza2F5frV5ccVHronlGq2y+6Z2Lac5dVbty7fFZsa1ettvqkub6e5LMi53iXd17Uj6+2lVsO5t7ANv7hZp9/W6/oBerOpeU9j7z4j7iTfG6yr/ZuvibzXd1I/EON2jNS7t10iuLh8W9lPUzWuvd3DMxPzupxWpvtt0vDj7P17u5d222Kp9vLo7Pls2yv8OH+6t7C4oV/8WieE8Xp4eT5KL4PIZ58Z5u7j2pPp8syd5Z73l5y+a4orjPvP1cnLNN7z7bL5+LqSlv8tor1iHNufb92e4+502/8c5ti3PfSbJf/M2q52LMk90Vu7p/fr+892S/2Zc7KQ5kinVj8xmpSbJf/MlWD/fq/fN1t41p2tFHa1VjHR70YiW721Q3H93YPC+YpHpxzTNah7NiXolN8YxWeZ6suczU7he01E+/N5+XtyjuBzkr5l6oH/jZzbNuh9XGc3fH783O1ar4PIa98rOM9idu0PaGcdL3f7Pa4Se8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALw5SCAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDEJJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJoEkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQkkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmASSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABOTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYhJIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAExMAkkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAiUkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxCSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiaBJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDEJJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJgEkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATk0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGISSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMTAJJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIlJIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQkkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmgSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxCSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiYBJIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE5NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBiEkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATEwCSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICJSSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMLHZvf4AwI67775sDw4ne/uzs8ne+svsr7a9YEm2q/1arE3xezyf9a5rObuoxUqSW2fzWqzDxXkt1sWml2+6eU/ftqxFOjzo1SGbTS1U5ikGS3J83LvPztfTtV9fZt0LdXLS+w6T5NpRry7epndtN0569UfzO7yt9z1uH3u8Fuun/nwtVL7ru3qxkuTgoBis2Mg8/XSvLH7dE72+VZIsFr06JCcntVAHRw/VYrV1+1fFen/Wmxrc23Tbs/NFry+3XPWurTnunM26/cbVqherWR57I+pkXqysLorj6aQ89izWjc1Y22ppTJbr01qsap1fvK5qWUySo6NaqB/+K7065Mkna6G6Y7MkOTuphXq6OA/y7nfXQuXq/cV7umx/0ex/Fztyu6w58CzalscV6+Jc+2FxLNj8Htvj9/1Zseyf9WItm3254nUlyXKx6AUrzm02+8NT7qF5Jc3brFkRN/fUpBkryac/3Yv11Q/f6gVb9+qPvWZdleT0rDfvMps1Y9VCZd7eydzsfzf7cuvemud5eY54uT6pxbpY9drqeXr7yc7X5TniZlXcHAw264/yhGNzHaG6/j7r3WfNvbbN60q6/Z3m3Ob1m712+vi4FipJcr4uzssV7+nNorc3qXm+IkkOZ8U1i2JFfJJe36q9VtecS63OtK+LN3V5/F5VvLa94riivo+hWF9V17R2c1nwtub4rFge583qqnyfbWe9OZ55se282PTu6Xn5MGRz7qpZHJt9q/1Vuz3rhWq2Zzu6zeW25jp1cQN9855uzpMl3TFTdV5uh2+06nCw+DUuF81522571iyOzfWKveZ5jvZ+oWKsZpe4OY96kd5+ofaWidNNbyxYfU7T7KAYq/urPf9Cr268+kBx70lxXqI6j5rkvDg3MTvorZ816/zm0CxJHn20F6s5ZmpWV+0hzPyst/+12Zerbm1sd0KK8yDVPTzF62rfZ81nP1T3JhX7qBfd1f7MT3p146K4XtFcz6q3Z81gxXNTTc0l6iTZFPv6zXnUalls32jNL7J5rq74/Lr2fbZsPnut+Zym5vpZse1Murf1snhuqnmWutkfTnZ3vqC5j/jWSfc3a17bzj5vsznITaqTqc01z1ub3vrZYXH8Xn0WQ8prFs3+cLMCKe/bPJ315kGa+xsvFr17ulrnp7v35Kx41m2/+Uyo8mBwVsxd1Hymc7ML0nwea5Isp95LOQzTvv+bVHekAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPA2JIEkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQkkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmASSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABOTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYhJIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAExMAkkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAiUkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxCSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiaBJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDEJJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJgEkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATk0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGISSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMTAJJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIlJIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQkkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmgSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxCSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiYBJIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE5NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBiEkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATEwCSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICJSSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDEJJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJoEkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQkkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACY2OxefwBg9+1lO9l7r1a7mwd3s+nFWq16sfbW571gs0UvVpKDg2Kws14Bma9v1WItFoe1WEmyXExXP73c+bpXXy03p7VY57P9Wqyk23ldzi5qsbazeS1Ws85Pksx6v9reWa/sHxz0yv7pulc+kmR/1asbt+nVjY89VguVl17qxWq7ddYrj83f7GK27AVLMk+vjbk4eKgWa77ZzbYzKf9m6V3bvDo+605DNvtyTYcHvXa6OjGRJOtevPP06v3lyfVarBwd1ULNZ8WymGRbrBunnMu8l/aK7XSSbFe9MdPypDd3dTrrzV2tulOb2Ts+rsX6YC1S8s53FoO1Fev9xboWKlcfbNZX3RutOcczK3blmvPsF5vuuuCLL/RiXbnS66M251HXxfoj6a7VXWx69/TZSS1UZuU5l/1ihXWx6K5ptRSH00mS/eJ4cFfnNtOe2yz+Zs2xYHPqqjy1WV3PbY5zv/j5WqhcLfZRk91dX63Ok5Xno7eLXv97Xvwet8U1z/LUVbbFPWXVfkFxJ1R97ax5Wzcb60Wv9Dfr/KQ7hm/+ZNV9m8U+yOlZt3w0+6i3Tnpjpvvuq4XK2VkvVlKtrqr1R7Pv/fwL3ftsW9yT2ux+HzbnJcptZ3Mv5eGq2JcrFpD2uk+Ke0+yKO4BrI47u3Obzfpqs6P94Xa/cbHqjd+b32Nznqw5hkm632N1HbJYf2wPumchq/V+uX9V094fXdTcJ7ou7oPaT2+fS5Kcr3rr1NV6uBeqev4mSfWLvH6jVzdeO+5dV3t81mzPzot7vKr3Wfk8R/UsU1F/bqKn2eVpzkc3V6qb99kur/tUFxGKsZp7rpLkgQeKwYo39bI4hmmuQSbJ4aJ4dru57rPq9Xhu3Oj+Zk3zdXGcW6z0F4ty32rWu7bmHPHcU2HfcnZ1b1LSnSNu7gdp/mbd8VJyUVyra447u/Mg5fasuUej+SyjTbE/XHx2TJLsz3rXdr4pnnlY9zY4tsfUzWmQTfE8R/WZYeX7rFpfVR8g3dOth6u78qp2ud/YXKduj2NaDpsP4UmSTe9Hq97TzcJY3i90a9M7G3BQ7PA0q6vmvMTNm7VQSZKjo961VffwNNcF2/244pmw5tpxsxqeL3Z38rvZxDT3QX3+i92efnNNvNn/bpaP+nMEpn7g1ThO+/5vUru7mw0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgTUICSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICJSSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDEJJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJoEkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQkkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmASSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABOTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYhJIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAExMAkkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAiUkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxCSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiaBJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDEJJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJgEkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATk0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGISSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMTAJJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIlJIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQkkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmgSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxCSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiYBJIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE5NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBiEkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATEwCSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICJze71BwB23GaT3Lgx2ds/fXZtsvd+uccfq4VKkqzXvVj7n/4btVjnH/ona7GWN67XYiXJ5qhXHucT3lcv99dvPF6L9VVfVQuVJFkuirGe/rlarPPHvroWa1H8DpPbzUrNrNdVPjurhep+h2Xns/1arGeeqYXK+x897wVLcrFZ1mL97M/WQuXjH+/F+sN/uBcrSa4+0Csjhzefq8X6b3+21wf5pm+qhUqSHB/Pa7HmZ7dqsZ49O6zFeuc7a6GSJFev9PoF86c/W4t1ety7z/bXvbKYJBerXnmcr09rsX7gT/T6O7//9/fqqiSZzXrxlp/867VYnz3+1lqsx45roXJy0ouVJIeLXn/n2Zu9/vBx8TfbbLr39LLYB3n+pV6dfzW967rY9K4rSbLotTF/6A/VQlVjPfBAL1aS5Lne+Ozpp99Xi3Vw0KuvDg5qoZIkq1Uv1l62tVjb7NVizXNRi5UkV670yuPeutffuSjW+e0NKbs6196sr/Y23fusWUqav1lxiSn768/1giU5nz1Ui7W8+WwtVo6OaqF6Ledtp+tee7Z/1tujMS/+Ztt0x9Sf+lQv1nd/tNdv3D/r7XPJM8VNV0lOj3pjpua83CNHxe+xuVEuyXrRnHfp1fzLWbEvV958sl305m2bbWfT/qo7Qnv+hV7Zv3p/sQ5pdvbLdnXMVP3Jqu1Zr15Mkr2T3vrIqrjW3ywfzTnbtvmiurG3Fqm97rP36d4+8/kTT9RiXRTXqdv7o5v7GKqz7cX2bN5cPOOu2Guf0TrondFq9gvms2K/YNGdkZ5vimuexT7xfNOrGxfFOZCku069nRV/s+J91twzkaS7KL7q7S3YFvcQl6ejq2cvm/f0alWcRy0W+6TbL2iOY6p1Y/GeTrp7XRaL3rWdr3ttTHtMfbbpXVv7DPyu2tXy2Cwf7fusuM0873pXL9bVXy7uPWn+aMV9J0l5zaJ5oxVjbU5qoZJ0h4LLg96g6bT4TIv2Uv+tde/aDg969/T1G70+QfGxWkmShx/uxdpvPqymuC5440Z3LPjoo8XzPs0zFrvaIU6qDVpzHXLebGPKA4vm7PdFcb/+crG7e3hms+I5z+aaZ3ED/bxcNzb3R2dHn924LJ85Pi+OY5rFcVs8X7Ff3ktZPQNffP7UrU1vLXeXnzU7PzvpxWqehSzuz0iSF17oxbpypRdrWRwLttdXu+vUvVi5ebMWanvUO2uf7O7egqaLct14uOrVIadnxecIpNffuSj2d9pb2l98sRer+QzdamXVXDxLsl8c5zbrq13ea9uc1795s1cPP37cq4eXQ/l5HZte/2pXz1Jvi3sbk2Qz8bz+mGHS93+zaj+TCgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOBtRwJJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIlJIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQkkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmgSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxCSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiYBJIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE5NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBiEkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATEwCSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICJSSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDEJJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJoEkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQkkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmASSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABOTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYhJIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAExMAkkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAiUkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxCSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiaBJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDEJJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJgEkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATk0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGISSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMTAJJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgInN7vUHAHbcMCSz6aqax49PJ3vvL7cqxkpWzXCPPloLtVxsa7FyfNyLlWS+Pu8F22xqoT70oVqonJz0YiWpfo9Ny9lFLdb5el6LlSSLRTHYzZu1UPvNSn9RHgIUb7Pl2Ukt1vHxQ7VY7bpqvun1rz784f1arI99rBYq73lPL1aSahnZPvZ4Lda3vasWKvff34uVJPOzW71gxcbzoNjEVPsESc7Xe7VYy6OjWqxqE3NwUAyWrM96seYTznu83Hd+Zy1U/T4rfo3JE0/UQh0Xv8fmPX246o07kyTr3sU1p5Pms+I8WXptWZJkva6FunrQnJPrVVbVejHJXnrl8ff8nl55bE65LFMsi0ny8MO1UN/WC1Ut+3ubcnvWnAAvFv694o+2nXXno/ea6z476sUXu/GuPtD7zS4Wy1qsXXaR3n3dXD+rNmjFuaQkWRb7jc1ru5j17un2EvX+olj2N7s5EbLedPsg3/zNvVinZ73x2X6zbqxuuupW+4883JxP6t3TzXo46a4hNOfaq2Om9vis2AdZrXp1Y3VuotwHuXqlWDkW7+mm9tzVYtG7r6vrI80OeLFT0N4C2NxDf1a8p8vbGLp2dD66eU8368Uk1YXq8+I4t9kfrh8LKF5cdfzenJPbdPcxVPsgxT0T1YmJ8hmtWfG+nmdXx2fl9qxYGc93dN2nOQeSpFpf7RXbzm1xr1yzyk+SZXtTWUlzHqTd19+7cb0XbEfPIZRbs8w3vb0n82Ld+PwLvbrx6pVye1a0o9Vw9mfdfXK3Nru576o5t3m4KHdC0vvNmvdZcyw4L9cfR0e9FrT5m22vPFKLtXfWO2tfb1+KawgXq8NarOb32P7NmttEt8U9PPvFvfrb8r7v5jj3orju0xwLPvZYL1aS7K+K45jic96a64LFY25JuvdZc19e84xWXbESuX5jN8+vrlbluc322cuS6rNjis/wSpK9ZoFsLpA0N3mVN58077N5cSy4Peo9m6+9VteM1yyOzbNnzT5qUp5vLP5oO1w1duM1C0hzEWHVe7Zn0n1+Y7N8nJ316qvDg+766mxW3LtZLPvNPkh7j9d8U+yEnPR+s/NV7zer5kNId962+hyB4pnjZjPd3jOxf6V4yKLZB2keHmnPozb3R69780nbYr+x/gyv4gD+Xe/qrYmfpvebzcrjiv3m2YDiPf3szd3cc5VM/zWO47Tv/2ZVfmIwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwNuPBJIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE5NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBiEkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATEwCSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICJSSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDEJJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJoEkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQkkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmASSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABOTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYhJIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAExMAkkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAiUkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxCSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiaBJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDEJJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJgEkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATk0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGISSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMTAJJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIlJIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQkkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmgSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxCSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiYBJIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE5vd6w8A7LZfyX25NXtosvdfFGux2aYXK0lmzRr64KAWalvMXby3uajFSpIsFrVQF4+9vxZrf3Nei7U4XtZiJUk2xRv70Udroc4381qsYrFPkqzXvVjP3Jyu/Xq5h4vf48nNXqwkeWTxuVqs65veb3Z0UAuVzzy93wuW5P2P9drPj3ykFip/9s/2Yn3hC71YSZKnPlkL9SMnv7EW64knaqGazfRtZ70G7XR2WIvV7FpVx0ttxQ7P6qgWKheb3lgwSfZX21qsWye9cczXPdEbn6U8D5J1L+D5qtdvrM5dNevG4u+VJL94s9cnft+jvfqjaV6c30mS67lWi3VcHFM35yXa89Hf8z29tvqjH62F6s5d3bhRDJb8rZP31WLdLM4nfdu39WLNmzd1Ul2LuX6zN0d87aDXxrzwYu+6kuTKlV5fv1kcl7Nef+fKle5YMMXvcX7Sm/vOatWLVZ50mRfLY3Wc25woa8ZKqhXW9qA3t7k+q4Xqa97WzT0Ts1473Z6OvnqlWDf+5E/2Yj32WC/WUXHyO8nJSS/WMsWxZ3EMMy/3QV56qTe2OFz0xkzblPddFZ2ve2OL5nzSdtYri3vr7hzxrmr+Zu2uflXz4ooN9faotwY5T3c966K4J/Vw1du7dr7uXdds1p0nmxf7ctV7ujgvsffMU7VYbcsnDmqxTs9699l+TmuxkiSbXsdxvzj5fbHp7lluap5l2hTnrpr7QZrnVJJkuWjuAexd2w4v+2S76tUhe8U+cbP+aM41Jslq1VuLaY5jml3U9rm65p7lwxTnk4pfZH2erLxm0TJP+ex2U/PGLlb8Vx/sdUKac0lJ0ozWPKfSbNC2xTFM0t0jvSy2Z8tVrwO+y79ZVXMfVHG8lFSX+7vPdGmePZv1frPmHEiSbBfFM8fFfb3NseD+otwfrq6v9jZTXhwU11fLY8HnP99rq5v7DZ96qjdP9pu/sbzu80zx4FTxnl4f9dqz5tx3ku4hnFVx5Fm8ruZe7CSZF+dcisOz6lTSWfnMw6pY9pv9xub62UVxXJEk85NbtVgXxTWms5NaqCwW3bnNZh2y117UKmmviTf7PM2h4EVxpn25Kff1m6fCivdZc2/B4UF37mperPhvpdeeHTbXmMqq62dVxb3f5eee7DXjNfeDtJ9B39QcEBY7PM0uavsZmM1naDTPxSxnvfusucfrvHwud33Si3V4UBzEVB/O1x0Mnhbvs/o6ZEn7Pmvu4bna3Ev5VPGs2/FxL1aS58fe2vGVK717+pGjHT7bP/FttjeM0wZ4kyo/rQ8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADg7UcCSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICJSSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDEJJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJoEkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQkkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmASSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABOTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYhJIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAExMAkkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAiUkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxCSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiaBJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDEJJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJgEkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATk0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGISSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMTAJJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIlJIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQkkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmgSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxCSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiYBJIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE5NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBiEkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATEwCSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICJSSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMLFhHMd7/RmAHTAMw88nef/L//tv+A3vzyc/+fOTxV2ub0323i93vjisxUq613ax6l3b/GyHf7Oc12JtF8tarL1sa7EuNt3c1vNc1GJtZ/NarPW6FqpaVyVJFoterNmsFup80ysfy1mv3CdJTk56sY6OaqHa9VXT/ORztVg//NMP1WI9+WQtVI6Pe7GSZL7p9UGun/T6IM0q//DmZ3vBkpweP16LVWzOqpZnvboqSbWNyWZTC3WRXh+krdnXrzo768U6OOjFSrJNr3/V/BpXq16s5vi9+Xsl3Ws7PetdW7O/09ash2+d9dqzl16qhcoDD/RiJcknP9mL9aEP9WI177P5zeu9YEmev+9aLdb999dCZX/WG+M2+95Jcpr9WqxqH2RT7Hvv6iA33f5V8zc7XXfHndV6f33aC7bLHccdva+r93RxvJQkuXmzF2tH5+TqivfZrpb99jzICy/0Yl0dinPtzTq/3HbeWvfWzw7T26NxK719V+3uTrM4Ntdyq+3ZDv9ozTni/U1531VTc3KieVMX77PmfsO2vZNi2S+Wxeb6e3O9M0kOV/ba3qn2FMgudwtaqnVVku1Br//dLPtN7ftsV/eeNO3o9HCS8vpZs9Jv/2g7OrfZ/Mnq+yibZaTdKS7Zrnr7CpJueWzGqp6bateNxc7cxaw3912tr8q/mfWzO7d3VtyfkeRi0auL57PdPbvdtKtd4l3extDU7Bc0z4m37eoYvrmW23w2SLLbzwfhzjXv6epzT4p1fnstt7pP9LnnerGKD2Rot9PV5/AUF+s+80yvPWs/r+NwXTwTVtwf3Tx32V6DbJaRZtX4yPGOPh8h2dmNDLt6Hizpnglrrok3l5iqZ2XLmmsIzd+s+RyBJHnwwV6s5liwOYY5X+/uvMRysZvzO/V9DDs62d48x9Teu9YcW+yvdrO+2uFtDNXfbJc3mu/qfv3mnvb62f7iF3m66bUxzWb6cNbde1I9C1n8zZqafZDmY9OTbn21q3sm2v2dF1/sxWrOFTTnXA4X3Xmyzz63m2Om5tpIe92nWRffd18vVvOebj4OKkmuHU3bxnzgQx/KZ/7O33mlP31mHMcPTBr8Htrd2U4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACANwkJJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJoEkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQkkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmASSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABOTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYhJIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAExMAkkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAiUkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADCx2b3+ANAyDMNekkeTvC/Ju5Ksklwk+XySzyV5ahzH03v2AQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANhZEki+jQ3DcF+SX5/kA0k++KV/vy7Jwa/6NyZZJ/kHSf5+kl9K8nNJfibJT4/j+IXyx35dhmF4X5LfmuQjSb4hyf2XvP6XknwiyY8m+fFxHDeTf0gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB2ngSSd2AYhkeTPPmr/n19bidd/DWN4zhM/sFexTAMH0jyG5N8e5J/Kpd83i+ZJ9lP8p4k35jkd3zpv18Mw/A/J/lzSf7iOI5fvOsf+A0ahuGfSPLvJfmuJHuv43/9dUn+5S/9+/vDMPzxJP/5m+naAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeOuRQPI1Gobh4Xx5ssije/qhXoNhGIYk35Lktyf57iTX7uLbz5P8pi/9+0+GYfijuZ1scX0XY7wuwzAcJPnBJL8vyZ0m6/yKJP9hko8Nw/Cvj+P4E3f4fgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALxNSSD5CoZhuJrkw/lHE0Zevacf6nUahuE9Sf5Akt+W24kQp3Y1yX+U5F8ZhuFj4zj+j4WY/4hhGN6f5H9I8thdfuv3JvmxYRi+P8n3juM43uX3BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYMdJIPnK/mqSr7nXH+IOfXOSf+sexP3KJJ8YhuH7kvwHrWSLwzB8Y5JPJHlgqhBJPp7kfcMw/K5xHLcTxQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAH7d3rD8BO2kvy7yf5oWEY7ps62DAMX5PkJzJd8shf7Xcm+a8KcQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANghs3v9AXjTGJN8NsmnkzyT5PkkX8jtMvLuJA8l+aYkX51keI3v+S8m+eUk/9pd/qz/v2EYDpL8SJKD1/DyX0zy55L8VJLPJDlJskhyLcmHk/y2JB/J5ffF7x2G4W+P4/jH3sBHBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4G1IAsm3t19K8peT/ESSnx7H8fSy/2EYhsMk/0KSfyfJe15DjH91GIafG8fxT97RJ/21/VCSRy95zeeT/MEkf2Ycx1952d9eSvJ3v/Tvzw/D8FVJ/kSS77jkPX9wGIafHsfxZ17/RwYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAODtZu9ef4Ad8kyST9zrD/EafDG3ky5+a5L3juP4b4zj+OOvJXlkkozjeGscx/8syVcm+b4k29fwv/3HwzC8941+4F/LMAwfTfLdl7zs2STfMI7jn3qF5JFfZhzHv5vkn07yRy556TzJnxqGwT0EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADApSS/e2P+7yT/fZKPJ/nOJEfjOL43ycfu6ad6df9Pkj+Y5CvGcfx94zj+L+M4jm/0zcZxfGkcx+/N7es/v+Tl/1iSH3ijsV7JMAzvTPJHL3nZ/5vk28dxfOr1vPc4jttxHL8nyX9xyUu/PsnvfT3vDQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwNvT7F5/gLeA60k++aV/P5Pk/xjH8YV7+5Fel+tJvj/JD43j+Mt3+83HcfxrwzD8s7mdUPO+V3npbx+G4XvHcfyFuxT6X0ry3kte87vHcXz6DmL820k+nOQbXuU1Hx+G4b8ex3FzB3EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADYcXv3+gO8Sf3xJL8lyT8+juNXjOP4z4zj+H3jOP74Wyh55GmSjyf59eM4/pdTJI/8h8Zx/Mu5naTy1ewl+d13I94wDHtJ/sAlL/vvxnH8sTuJM47jS0k+lmT7Ki97JMk/dydxAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2H0SSL6CcRx/aBzHHx3H8ca9/ixv1JeSXX7/OI7npZA/mOT6Ja/56F2K9ZEkX/kqf/+VJP/u3Qg0juOnkvyFS172b96NWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOwuCSS5K8Zx/EKSP3nJyz4wDMOVuxDud13y9784juPfuwtx/qE/csnfnxyG4avuYjwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB2jASS3E0/+hpe88E7CTAMwwNJfsslL/vTdxLj5cZx/D+T/M1LXvbP382YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA7BYJJLlrxnH8VJLPX/Ky991hmN+UZPEqf/9ckv/pDmO8kv/mkr9fltQSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAt7HZvf4A7JwbSR54lb8f3OH7f8clf/8r4zj+yh3GeCU/luQ/fZW/f80wDFfGcXxhgthvacO4zXJzOtn7P3t2ONl7v9yqFum22ap3bfOb12uxnr/vWi3W1dVFLVaSnG+WtVjLTe/art+c12JdS68sJsn2uFced9aqWztepFce57NtLdayGCubXqgkyeLVcn+/dc3X0/VvvsysPGw7OqqF+uAHa6Gal1WtP5IkJ2e1UKtVr79TLfqPPloMluxvzmuxTot91C9+sRYqiysP9YKV7W16jfVzN3p9q/cdFdvOpFuJnPXq4f/97/XK/td+bS1UkmS97sXaT688Pvvcfi3Www/v1WLVFevGk5Ne3djso9aHZsWxZ7EaziMHxfZs0Z1z+dZv6cX6xE/26qvvuGxV6W46Pi4GS66e9crjL97stWf7za+xXDnuN+eTNr1r2856bWexS5CkO8ezd3KrFqs5r78/682BJElmxfu6WIc8/2LvPnvwwVqoJMl83Ssj20VvnqxZX52ddceCB0e7OS/3QvE+u3qlu4awTa+M7N3orfc31/r3Ul73Kf5m1QqrORFS7jgeHhTLyLrXBzkodq2a8ztJsrz5bC3W6cEjtVjNYW57fNacb6xeW3PfVXnvyfMv9Nqzd7yjFiqH7Y3ERd2y39sf3Sz6m+J6Z3/dp7hWd9Ybnx0W95k353eS5OrwuVqsi1lvrqA5Z/u3nunVVUnydcfFPfQHvTF1sx6+ebMXKymfeyi2Mbs959LTPPOwKcaqnnnYYc19cvNZeQDfvLhmI1PsgNfXxIt72tfFPe3nzbqx+B0mqZb9anks7j2ZF8/lJt22et6cBymWj3n7XF1Tse2cF9uzi013H8Ouro8sZ736qjmGSdpLFr1gy5PenNz5qrt/p1r2U+xfFevhs2J/OOnuKbt2VOxfFSuQ83XvO/z852uhknT3iTbrj+2i1541p0Bux+uVx8PiPobmOYT63ObioBereKM1j00dzspn0otl/3zT7X+3XDtuP2PlpBbq6Ki3dtwsH81xZ5JcP+n1iZvlsdkvWC6682TN7Y3FW7q6X6j+qOfimKl5ZYcpnrt8sLxJtFiJXCx658TnZye1WMvyMzCrv9mm+Js11zzbG2CfeaYW6uLRx2uxml9j9XmbSdbplf3mucspn8v+Zcp7T2ar3m9WVazzb6W7Z7n6nKaj5r6aXuV4Wj7b/8Uv9sbUD7xaZpG7rDkWXBx166rlojc3sb+jz6q5KM6Ttdd9qsOY4sUtm3uWn3q6FyvJ1eZGl3f0FmMODw5qsXLSvdEeP+6Vx+az+fZ+5IdrsZZPPlmLlSSz497zGJr94fmn/mYt1rWHH67FSpJsDrrx3iZ2+InS3COXJVC8/w7f/9sv+ftP3uH7v6JxHH8hyS+9ykuGXP7ZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeJuSQJK7bXnJ399wiudhGA6SPH7Jy/7XN/r+r8HfuOTvH54wNgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG9hEkhyt73nkr+/eAfv/bWX/P1kHMdfvIP3v8wnL/n7ZZ8PAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAtykJJLlrhmF4JMm7L3nZ/3UHIT50yd//9h2892vxc5f8XQJJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXpEEktxNH3kNr/n5O3j/xy/5+y/cwXu/Fk9f8veDYRiOJv4MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAvAVJIMnd9Dsv+ftnxnF84Q7e/72X/P2yBI936tkkF5e85rLPCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwNuQBJLcFcMwfH2Sb7nkZX/pDsM8esnfr9/h+7+qcRy3SZ6/5GUSSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPBlJJDkbvmB1/Cav3CHMa5d8vcbd/j+r8VlMS77jAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALwNSSDJHRuG4buS/OZLXvbXxnH89B3EeEeSBy552efe6Pu/Ds9f8vd3Fz4DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbzGze/0BeGsbhuFdSf4/9u4/yNb7vgv7+zk6OjrarNarzUr3zvWNrMoyUYRjSOI2TjHBJG4mIRQIOLTTlCYtLZP+GEiBCf05zbTTHwNloNMJMEA7zJQpAVwCwW1cMGmgnsZN3ERjnESkiisrQr2Srm/WV5vVeu/RefqHPG0jK9qVtM/76p77es3oH+1zz+c553me7+/v8/lzZzj0P3mTofbOcMz1NxnjLE6LcZbzrBqG4d9M8m8UQr2zEAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOCWJIEkb9YPJnn7Kcf89XEc/9c3GefeMxzzwpuMcRanxXjLJZBMcl+SR2/2SQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANzOZjf7BLh1DcPwB5J81ymHvZDkj5xDuOUZjvmVc4hzmsNT/n6W8wQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOA2I4Ekb8gwDO9N8l+d4dB/exzHXzqHkIszHLM6hzhvNsZZzhMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDbjASSvG7DMFxK8reSLE859G+P4/jfnFNYCSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC4ZUkgyesyDMNWXk4eeemUQ59M8t3nGPrUe3Ucx5fOMd6v5bQYdxTOAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgFvM/GafALeOYRjmSf5akveecuhxku8cx/GXzzH86rQDhmGYj+N46nFv0mnPzI2J478Rzyf5uUKcdya5qxAHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgliOBJGcyDMOQ5C8m+fZTDl0n+X3jOH7ynE/h5AzHzHOGRJNv0p2n/P0s51k1juMPJvnBqeMMw/CzSR6dOg4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMCtaHazT4Bbxp9K8t1nOO5fH8fxwxPEv3GGYxYTxH2lWy6BJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADefBJKcahiGH0jyh85w6B8bx/HPT3Qah2c4Znui2P9/95zy97OcJwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALcZCSR5TcMw/OEk/9EZDv1Px3H84xOeyrUzHLMzYfyzxjjLeQIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHCbkUCSX9MwDH8gyZ88w6H/9TiO/8HEp3OQ5KVTjtmd+BzOEuNzhXMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgFiOBJK9qGIZ/McmfPcOh/22SPzTx6WQcxzHJtVMOuzj1eZwhhgSSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfAkJJPkSwzD8niR/KaffHz+U5F/7YnLHhqdO+fuFwjmcFuOzhXMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgFiOBJL/KMAzfnuSvJLnjlEP/ZpLfN47jevKT+v88ecrf3zFl8GEYtpLcd8ph/9eU5wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMCtSQJJ/l/DMHxzkg8nufOUQz+a5J8bx3E1/Vn9KqclZ3zXxPHfmWQ45ZgnJz4HAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbkESSJIkGYbh/Ul+JMnylEN/PMnvHsfxZPKT+lI/e8rfv3Li+Kd9/mfGcXxx4nMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgFjS/2SfAzTcMw9cn+Z+SbJ1y6E8k+WdvYpLEnz7l7181DMNd4zh+YaL4X3vK339mori3tHGY5Wi+M9nn7+5O9tFf4sXynb84vl6LdbJ/qRbr7uNaqKzni16wJFsp5tadb2gVfvHizT6DyaxWvVjL09JBn6N1us/Z8WEv1mLeK7DWy9OaYednVi4/TpbTtQO+RPE5W2xv94IdHPRiJdU65m1v65UhzZ9xq1ydrffvr8UqFo3ZylEv2LxYeSY5WvXu/WZx1WyDtB0X7/3Th2fOz0MPrmuxsirfIMX67GTeu2bvelct1Eabcqzqlfb3a6GqZqviGEhS7VTv7vbq6eZYQbcuS7aWvXK42d5pNnjWmdVitT38cC/WYXEsaT7vXrPj1YbWZ5vcsSh+t+vHvfqseckW82Ifpq046dmsY+rj0aved1sUv9t999VCZZbuc3ZSHAdp3o3N8mpvWW7sr4q/ZLEjc/fdxfms8rzPrFhZN9eeLI57cwhHxbIqSe65pxfrZL6Z1+z6qnvNumMTve/WHk+qKra/d5abuZ5sVWx7J92lcs01qc11Ls8+v7njjXvL4tqCDd56UR13KbaJT7b3arG25sUyvzn4nVQHAavl8GGvwXOhuYA+yVMHvfVku8Wvtlj2Ks9HHumuj14ve/2zgyu1ULm026unL83LZWOxLdccc6m2dpqLJpKN3YNTnV4tt0HW28Vx26LqWFLK8+/NAaXiM73Ja3iahUhzH0JTcz9Y0q0+m1Xnorkvd5MVb5DFpt6M6T5nq+I85FZx7XdzTU2Sahukec0WzXK4vS6v2Ldo7m9eFAc3q++0qCve/MUO2na5aGzOU7ff6dLSrM4u3Ft+pptfbrmZfep2c6car7jfvruvrnsv7sx78yPNsYnm2Ob14+748IZOIXTn38sLDrvrQXp9puaemPaNv6lbBreWxT51+TlbFd+h0Z0/Kypfs+b8avOrbW3ovsskma1642TVuZhiod98h1eSLLd78Q4PaqGyt6H1dJLqu22b/dxuG6Q8V1esY6rvTmqucymvY6j+js1GSLE+u/FCLVSS5PLlYrDinvSj4hhguw/THG9svk+xOXZVrTuT7rsEmoMuxfpscdjLzXFpf4PX2hbvj2uHvf7S3iOP1GIl/b5ny9Wne7G2i2P6Sar7faopVd773l6s8kt0m1MWe1d/oRfsN/7GXiw2wmausuHMhmH4miQfTXLaq6d+Osm3jeNY3lH7q/xcktdq2c6T/IYJ43/dKX+XQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBXJYHkbWwYhl+f5O8k2T3l0H+Y5FvGcfz85Cf1GsZxXCX530857ANTxB6G4c4kv+mUwz4+RWwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABufRJI3qaGYXhXko8l2T/l0MeTfHAcx89Nf1Zn8rFT/v7PTBT3G5J82Wv8/VeS/MREsQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALjFSSB5GxqG4cEkP5bk4imHfibJN4/j+NzkJ3V2f/eUv/+WYRj2Joj7oVP+/uPjOJ5MEBcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIANIIHkbWYYhrcn+XtJLp9y6C8l+aZxHJ+Z/qxel59M8tRr/P3OJN95ngGHYZgn+b2nHPbXzzMmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAm0UCydvIMAz35+XkkQ+dcuj/nZeTR352+rN6fcZxHJP896cc9m+dc9jfm+TCa/z9xSR/45xjAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsEEkkLxNDMOwl+RjSb7ylEOfT/LN4zg+Mf1ZvWF/Kcn4Gn9/9zAMv/M8Ag3DMEvy/acc9jfGcXzhPOIBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwmSSQvA0Mw7CT5KNJvvqUQ68l+eA4jj8//Vm9ceM4/qMkHznlsD8xDMPiHML9/iS/4ZRj/stziAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAGk0Byww3DsJWXky3+k6cc+vkk3zKO46emP6tz8V+c8vd3JfkTbybAMAzvTPInTznsfx7H8bE3EwcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDNJ4HkBhuGYZHkh5P85lMOPUzybeM4/h/Tn9X5GMfxf0vyP5xy2B8chuF738jnD8NwX5K/neSe1zjspSTf/0Y+HwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgNuLBJIbahiGeZK/muRbTjn0xSS/fRzHn5j+rM7dH0lydMoxf2YYhv9wGIbhrB86DMNXJfkHSb7qlEP/7DiOnzrr5wIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHD7mt/sE3irGobhG5P8utf5z778DJ/7r76B0/n74zj+n6/z3/ypJL/rDMf9rSTvGobhXa/7rN6YF8Zx/Kvn8UHjOH52GIbvS/LnX+OwIcl/nOTbh2H495L8L+M4jq964DDcn+QPJvnDSe4+Jfw/SvLvvu6TBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4LYkgeSv7V9J8t0TfO5feAP/5l9O8noTSH71GY/757/4X8tnk5xLAskkGcfxLwzD8FuSfNcph359kr+X5LPDMPz9JD+f5CDJMsmlJO9N8ptztmfiKMl3juN4+EbPGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgNuLBJJsgt+f5L4k33KGY9+R5F96E7G+kOQ7xnH8h2/iMwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALjNzG72CcCbNY7jF5J8R5IfnTjUYZLfM47j35k4DgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABtGAkk2wjiOR0l+e5I/nmScIMQTSb5hHMf/cYLPBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYMNJIMnGGMdxPY7jH0vym5I8dk4fe5LkP0vynnEcP31OnwkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBtRgJJNs44jj+R5OuS/M4kP5Zk/QY+5rkk/3mSf2Icx39/HMcXz/EUAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuM3Mb/YJvFWN4/g9Sb7nJp/GGzaO4wdu9jncTOM4rpP8SJIfGYbhviTfmuQbkjya5KEkO0m2k5wkeSEvJ4x8PMmnkvzdJD/5xc8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAN00CSTbeOI7PJ/nvvvgfAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1M1u9gkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbDoJJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJoEkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQkkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmASSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABOTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYvObfQLAZhsyZmt+Ml2A1fF0n/0KO/cua7GSJE9frYVaXO59t/n2ohZrtaqF+qLed1tkXYt1aXmtFivZLcZKZsXfsZm3e7aasNx9hfW8d98nybJYFJ9kqxbr8KAWKstlN4d885o1n+mTVe93nO/u1WIl7bKx59LuUS3W9cNe+ZEkO8teuX983Cv3l7u937Hdbpy0j/RKh70+06JZ6Jev2XLZu/dnx73yKoe9H3K9vVOLlSSzg14/ZrXs1dUHB7VQOe4VH0mSixd7sfrjBR3N77Uo3yDPHPbKkGZ1Ni/O0FTbH0mefb5Xd959dy1UdRykWeYnycc/3ov14IO9WF/2Zb1YF+4ptuOSPP5kr8/09rfXQmVnuxerOb6TdOvPebG8Whxfr8VqtgmS5NJ+sf4s3h/VO3+7+FAnWax6ZXFzDqHZblx375BqGVJt7Bc7aNdX7fHo4hxC8ZrNm2MF27vFYN3nelGcp97Y+6Ns8cTP1WKtH3m0FmvnsFi/JMmqWMdc7a0ny+6lWqhmeydJcnDYi9VsgxTV51cPn+sF29/vxarf/D3NcduT+Wb2z9qaY2XN+dWtFNuozcJxd7cXK8m1g979sd18zpa98cZ2+XHXi71YLxZj7RRvkK15eR3lRz5SC7X7wd9Ri7Ve9urp7shmksceq4VaFMfar6dXNr74YncfwoU7e+vJmtdsXdzHdFKsO5NU14k255iaYwXteZ9ZcxykOb9abcyVa7Ti77hstgua8xXlcbLFhs5DLpqTMeX1r4tiH/6ouN9nq33zFzWL/WoV07xk5UmEZt+zOuuzwdesaVEcI27vt29q7jlu92Na2o9Z826s7oUsmhfrl+b4Tlu1HC7+ju15n5158Tkrrk1aXL5ci5XyO1Zy9aAWarZbC1UtG8vbEKp19S//ci/WVnPdd1mzjjlZ9eqY5tDVYt4dJ5sX13hdPyyucymWV935iu5+n6N5bx5ysSz+juUKrdk/a877NNc2VueNk+49UmzwNMds2/t9mu9/6BYhvbKxvbe/uU60WcXksLgnplyf3XihGKz5UBfL4dnF7j6mk+Z7uJsFf3Ed1IXyO6Gaawua7y1tbrFoFsNJt0999UotVPWdg809MUmy16w/i/VZcw/fqjhW8EJxzDZJ7ruv+F7b4lrKGzdqoeov57t6fH8t1gMXe9es+X6y8lbI7rv1f/RHe7GefLIX6zu+oxcryU/9Uq+O+fo7i4255jUrP2jPjtOWjauXhkk//61qM1fOAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALyFSCAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDEJJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJoEkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQkkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmASSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABOTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYhJIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAExMAkkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAiUkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxCSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiaBJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDEJJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJgEkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATk0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGISSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMTAJJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIlJIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQkkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmgSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxCSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiYBJIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE5NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBiEkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATEwCSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICJSSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDEJJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmNr/ZJwBstjFDjlaLyT5/6+rTk332l1gue7FuRrySw8NerJ3tdS/YBlvv7tViPf98LVSS5L77erHm1VZXL9gs3edsterlP9/KUS1WstWLtOxes/WG5qxfHF+vxTpZ7tRiJclidVyL9dJLvXs/Bwe1UPPd4vdKqpXMjRu1UFmterG69XRydDxdH+mVtua9H/Ikve+1WDXr6WTV/G61SKn2O9vtxuzu1kI1e+/7+8VgZcWqOnu7xfux+cW2t3uxypXnpeW1XrB2w6CmO9Z4YXiuGK343Va9WPN5tVWQ9763F6s59H3c6+Jmvez2BR9+uBdrZ15sfx/2+jCreXnMpXjzd4eje99rvzx1Vu3nbveu2klxnL3esiqWxYt2P7ekPqZfLBurz/Syd/fvHHfHyXJQbGAV+7nVecHiT5gks019zja0HE7K8yOPPNoLVnRUbutvNeeO9y/VYjXbcoucFKNlY9flNe0su9dsvX1/LdZsVfxuxcGrC/d0e2jXjnv9s00d1m/Prx4e9vqDzWJ4XRxrnzUHpJuNxiR7xWnIZtl4bdVrN7bLqs99rhfr0Qc3cw6hOsmUJB/8YC1UdR1xs7x6uri3KMn6ff90LVbzZyxOV2TnuLmuIMn2bi3U9eIa0ea+qcXVK7VYSbK+2BsHOSnu51gUx/Wb48NJcr3aryhes4Pe2rV5cQ9fkhytiv33Yn22aG5gba7bTKqdi+LWoqQ4v9q+ZkfHxb2Q1bZ+cZ1Ld4dFtf3d3hfT0l5LuanvLWje++2xq1mz81keS22ZFduoSar156z5UBf3nh0X2wRJsmh2Bzd131RRezh6a9Vb57Le7s3FNOf6223UarTLl2uhqmva2+sKig/29eL4zmFxiPjixV6spPv+mAv3Ftf1Tvjev1dq7plKumXI4rDX/l60GwZFOxeb+4CLfcGDXh/maNmdQ9gq9t+3ivNnR8W1jf1hid53a/bOqm254l7ZpLuPb1a8Iatrscv9s6bqHourV2uhFuUXJ035LuxXWsw3c69be8/xSy8Vg+3v1kI117S3Nec8m/OQ3a0Bmzsn3hwumBX7Fdvb5XfNFhWnz6pt/eo7B5Osi+3UWfGiNcuP5jqo+bzb3mnO91+f98aT7r67FirZ7vYr9ovtgmuHvfLj0sXec9ZcR5kkW80hnt/6W3uxnniiF6s8Wfeu5p7j3a+txXr88VqoXCzPiV84fGrSz5+PxSQIbyGbmc0FAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4C1EAkkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAiUkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxCSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiaBJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDEJJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJgEkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATk0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGISSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMTAJJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIlJIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQkkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmgSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxCSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiYBJIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE5NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBiEkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATEwCSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICJSSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDEJJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJoEkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQkkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmASSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABOTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYhJIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAExMAkkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAic1v9gkAm20Y19laXZ/s86/tPjTZZ7/SjRu1UEmSe+/txVocXqvFunqwV4u1Mz+uxUqSZ1/YqsW6885aqCyXvVgX7lv3giU5WfVyaV+9WguVSxd7sXJwUAyW9J6y5GS7V17t7Xbv/abZ6uRmn8Ik1ts7tViLlO+Pea/gv7R7VIuVZa9wLFadL1utaqHuvHNRi1X8WpmXR0ea7auffqxXeza/15d/ebNV0G2nPnO1992az9nubi9W0n2uP/zhXqxPf7oX63u/txcrSR58sBfrmSu9vuBjj/X6Fe97Xy1U9spjLs8c937HZnn1wgu9WBeOn+sFS/LU8f21WA/s9vqdJ+m1h7e3a6GSJH/5L/divf/9vVjvfncv1uzTn+oFS/LYwXtqsd7//l4bdXblmVqsrYOna7GS5OThR2uxmuPR+/u9snFxPN2c46s6PKyFOtm/VIu1WPXG5I5W3f5709WrvX7FA5d74xKz4+KYbdl82Suvrh/27o+d7fKIdHNAqejaca+8ao+TzQ579eei2JFZp/ecHXeHQaqP2ZRrur5EcRJhPu+V+UmSZe/er84dF2/Go1X3mi13e+ONzXH99zzcnH/vtkFmxXv/2mHvftzd7cUqdnGTJI891ov1TR8olo3NtXLlhQzHx721UE1bKZaNzYbcE0/0YiVZP9Ib25wVq5jmVMzisZ8sRksevVhcSLy8XAvVXPc9L64RTZLZv/P9vWA/8AO9WM12Y3PhSZLZR36kFmvxgQ/UYjWv2bNjb11Bklwo7pvKvNfvvHbQKxv39vdrsZLuuNzWvLf2pLn37J5apJc1uzHNueOjZe+Z3irP1W016+rmQobmzdgedCnOxVTXr23w5pFquObYVfEGaU9Rby2b443FBs8GX7Od7d41a85TL9Jro14vzo0k5fc/FAvi5nzWszd6bdQkuVBcc1gdTyp2PD/+8e5ayt/2wWKwZoOneM0+/WRvjLi55yFJTla979ZsDl8/7tVn7T3pq+JbVqpjE/PN3EudJKuLvfehNZcRN+/9+pr25k1SrM8W272LdnTc6y8l3fUgzfdPzXdroerPWXO+f1F8ztbF9agpr2mvrtFY9toFxwe1UPV94s3xpGZrv1nHLJfd+qz5br6TYvt7MW/ueeiFSsp7wo6LX65YYD11pTse3dyb25xDmBXnBQ/TXUvZrD+be0f20lu71uzDJMmiuB5kdfGBXqzNXcZQtfX4T9diXXvwa2ux5uU2yIsv9mJduKc3XtB8R+rXvrt70WbtNWUlTzzdq2P295t9wVqoJEmzpt457L3H69qy996k9sRP870Fe5/+B7VY6/d/Yy1W+zmrjkf/8A/XYuXJJ3uxynu0PvGJXt/ztz38C7VYj66aA/u9PZ5Jcn132v7Z+o5iIqa3kO4INQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBtSAJJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIlJIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQkkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmgSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxCSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiYBJIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE5NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBiEkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATEwCSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICJSSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDEJJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJoEkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQkkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmASSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABOTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYhJIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAExMAkkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAiUkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxCSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiaBJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDEJJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJgEkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATk0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGISSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMTAJJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgInNb/YJABtuNst6e2eyj987uDbZZ7/Syb17tVhJsrj6TC3W+uKlWqz9Ys1zMt/qBUty4e7rtVjXM91zdTOty7mtFzmpxbq0u6rFOjru3ftbu7u1WEmSVe93XBz3nuksl7VQ6/miFitJZsfHtVhTtjleaZZ1LVa7bJxd6bVBTvZ7bZBF8ZoVb/skydaqF3Bv2SuHM+81HI+Ou2VjsTrLI4/0YjU1f8N2wN3d3v24teq1d47m3T7M1rzX1r94sXfNvvIra6Gyv9+LlXTrz8PDXqwHH+zF2psX+zBll/Z7z/TRqvdM33dfLVTWub8XLMkDx0e9YM12QbFP3SyrkuQDH+jFevSRDe1TlyvPh4vhZk9+phfs4sVaqGvL3rhEkuzNe/f+ctm795vj7Nne7sVKquO2xWGQ5LDX+N7a7i5JaY5/V2/HYofpKN351Rde6MW6t3g7NseuTlbl+dVmB75YOG5v98qP5hxTknIl0zMrrhfaKbYJkiTL4jWbFyu0YvlxXBzfSZJFs11QHDBojuvX51eXvbL44Yd7dfX1Va8tt1Ouz46Oe7/jXoprUle9NantLnVzfqQ6mNr8IcvtuDte7MWq3o/zcluupXx/PP10L9b+fnHNRLFNkPZa28uXe7GKjblFs3/25JO9WEnyoQ/VQq2XvXZjs5reObzaC5ZUF+ZV944U+2cX7imuK0iS9MqQ6vBOs1lw3F24uVX8IU+K40n33FMLlYODXqyku2xiveyVjfPq2qQN7cMkOdntrV9rztVtHffGkpLkenHfw852cwxwQydzk8yXxTmLZsOgGau8d6S55nC2oeONzT18bc321bJYfuzMu/2z5thEc43G9cNe+dF8p0XSbX/X19WUvO995YDNgbn2+HfJw8VqenbYfaZXxfUgzWbjzrK3pv0km7snvbl+vtlubK+1ba6Pbs55zufF37E8Hl0tsJqL5YrPdHNM/2XF/T61SF3NvlmSLK4+1wtWHHOZFfdSb7XXtDf7FdV9Kr35ivZWjua7k5rF/oZuY0qSHBevWbNfsbfbi7Uo7ttOUv0hm3sDqut6D4qx0t2HUF2TWlygsant4aQ8J368uetB1pcfqMW6eqUWqtmlrqve+8XNRc1r1ny/YdLdA19da9t8ztovLm3OnxU7TRcu1EJtdp6HZa8Bvt7t7V99+tO1ULlxoTtX11z7vSjuU/mpn6qFyld/dS9WUu6ffcVX1EKdfOd31WJVc3Mk+bqvKwb7XK9d8Jnt99RiPXT4VC1WkuysDib9/NlLNyb9/Leq7soGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgNuQBJIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE5NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBiEkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATEwCSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICJSSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDEJJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJoEkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQkkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmASSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABOTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYhJIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAExMAkkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAiUkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxCSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiaBJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDEJJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJgEkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATk0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGISSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMTAJJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIlJIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQkkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmgSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxCSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiYBJIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE5vf7BMANtx6ndnh9ck+/pnjvck++5XuuFELlSS5sL9fizU7uFaLlXnvmi1WR7VYSXKy3KnF2i7W4LMrz/SCrVa9WEnWlx+oxZrNexdta8Jy90tcOezFart4sRbq+mEvr/uVK7VQSZKLF3tl407z3l8ua6Fm5bLxZP9SLdYiJ7VYuXpQC7W1vV2LlXTbIIvDZruxWHeuuvXZyXavTXx8XAuVnWXxmU653TjfqsXaKj5nzXtxq1nmJ9W+xf7+ohbr7W+vhcrO9roXLMk6vTbx295WC1VVbRPMu/fHM1d690exK1itp7dWxf5SkjTbxAcHtVBXj3ttgkv73brzk5/s1WePfvrDtVizD32oFiuPP96LleSJea//fml5tRYru7u1UHvlvuBTT99fi9UcTprPe+XHzrw779N0cNj7HfeKY5ttzXu/+TMepTguke5zNr+3992a/Zjt7V4fpj0n3qyrrxXLxuYzvTg86AVLqmPtzz7fu/cv3Nudi6k6LLZTi4MTR7u9PszOqjiflSSr4v1YfKavFruCzTG5JDlZ9cqrTW2jtjXHN68X1zfuFOfPTla9tlWSXL7ci7We9+ZHmuP6y/Iujzvv7MVqNnf2dnux1steH3f28MO1WEny9Cd6sR7Ybq5N2sz5rCT5sR/vtXe+6d3Fh7rZuPrTf7oXK0m+53tqoWarXhtkp7np4cMf7cVKkg9+sBaqOf3evD9ysLn7EA6L6w33tovXrLymvdkAP171rlnTHXfc7DPYDMUhub7ic9YcmZgX+2cnxbGkJJkXi+Kj416/Yrks3iHFdS5JMjsuzucWG47N+0M5fD7W271x1Gq/IqneJNX2d1Fzz1TSvUeOivMj1T04x93Cccr3xXyJYn3W3MdUXHL1suY6hubET/H+aLZBTorznUmy1dwTVhxPOin2PKvvR0iyOO49Z+tlt5/b0h7avPBS7z1N1w+L6/LKe46rivVZ830uTe3u+yy9+7FZhlTfDVLeo3Wy29tXV91j0Vy4ucFzdev93v0x38yl+knKa20Pe/2YTV4f3XxPU3OcrDmH0N4L2dzn2dwX8+zzvb7gA5e7/Yrm3pFmwX+t+N6T9lxdc7ntA809D8V1DKtyG6Q5Vra93avPXnyxFip78/I7oZrzTE8/3Yv18GaObSbdcZDmptLd4ljBU1e7c+LN/bLNlVD33NOL9cxBr99ZTAPysuIYT/NdRs096e1rtrUslsPL3pf7xx+vhcrXfE0vVpLuWOrHPlYL9cn5N9ZibRfXGybJk0/2Yv2OF36mFmv32x6txcqqO5A69bzPOC9uen8LKY5kAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANyeJJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJgEkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATk0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGISSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMTAJJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIlJIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQkkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmgSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxCSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiYBJIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE5NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBiEkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATEwCSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICJSSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDEJJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJoEkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQkkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmASSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABOTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYhJIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAExMAkkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAiUkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxCSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiaBJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDEJJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJgEkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATm9/sEwB4M65c6cXa3e3FSpJrdy5qsfa2t2uxDq/WQiXbW8Vg3Up1cfBcLdb64qVarNWqFuqLAXuhFgfFm79ZYBXLjyTJ4WEt1LqYa71577/tbb1YbSfLnVqsRU5qsU7m3fqs+d1yfNyLVSyv1svuNWvWZ1kua6Gav2O7DbKht37W6fVhZuWLNsu6F2ze61ksDq/VYtXbjcXf8eLFWqhcuPt6L9hxeei4WO5fuLfY3tlQzTI/SS5d7JXDR8e9vmCxaZVkc/vvzR9yVfxabe9+dzHYshfs+mHvmd6p/ojJN+4X26if7IVqjm0+9XTv/ki6TeJmrGaR317d0Byb2Jv32qjXDovfa7dYViVZFcdctpa973ayapZX3QdtMd/Mtn7z/qgXjsUxl6atYjnc1pw/u6/Z9TwujhGXx6NPtvdqsRbz4nhjU3uR14Zq9iuqc9RJ1vPe+GZ3DLCoPcFavCF3mvOCzbVrG/ycNedyl8vueFJTs7yqFiHNBRrFsaRnn+/ei837Y73baw8378Vffsc/1QuWZPcfN4Pt1kJV65fv+75arCR5av5QLdbl4vBOsxje+tZv7QVL8pnj3h6Lh1bW9Z6Hp6726urm/NneI72Her3dG2tMunX1lad7sX7dw70+zPZ2t93Y7J9t6n6fFL9XkqS4V6W5ZnlW7MQsylNn7Xg1xQftpLz+dVGcX22uLajOiTfbqEnWzX18GzqJcP24+5w17WwXC+Jix+K4OOaSJMtlMV6xLVdto5b3HM83s7iq9t/bS662qpuOe5pjxIcHtVDZ2y6vXWuuu2ru9yk2G+t9s+bvuKHL8upN7w29Zs09Wtvl8ejmeFKzXXBw0IvV3jtS3TOY3lrbRbUg7oVKksM0+zHFfVPHxfd1tBXnc5vlVbNd0N1blKzTqz+XG9puXFx9phcsybN39NaeNN1zTzFYeQ6hOi5XbDje0+wzPV1coJFktf9ALVazLdfsV7S3jjS/W3PP8dXiq4jvuqsXK0kOXuqN2zaL/cuXe7GuH3fHQZqvxr787vfUYm0194NdPejFSvLseH8t1oV7d2uxLhbL/FlzLXaSo1WvbGzO9jfL4UvbvTG5X3iyWw5fvNjrV3ziE7VQ1bqz2bZKksPiePTjj9dCVd85WO6+52d+vlc6fv0f/aO1WE9+pBYq/8LvOuoFS3LlSq9s/NSD31WL9X0fqoXKRz/aazMmyQ/90LSf//nPT/v5b1Wb+xYDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgLcICSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiaBJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDEJJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJgEkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATk0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGISSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMTAJJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIlJIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQkkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmgSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxCSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiYBJIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE5NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBiEkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATEwCSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICJSSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDEJJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJoEkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQkkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmASSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABOTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYhJIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAExsGMfxZp8DsAGGYbie5J5X/v+7Fou886GHJot7fNLLg3vHHbVQSZJZMcXvHbNeXbB6aajFav6GSTL0vlqG9Uu9YMWbf5ObJdVr1rz5mzd+kqzXvVjF3/Gl4u3Rfs429XYc0vshx3Sfs+Z3q96Q1Ruke82qP2Pz/ij+ju2ysRmv3SauaV+05nPdbO+4Gc9Fs587nxXvj3ZbvxlvkzufLe37o2hTm6h1zfqs+EPeWPVi3TnvllXHX+h9t+XwhVqs9Z131WLNxuIAT9KdtHjxxV6su++uhbpxoxYqSbdJ3IzVLPKb81lJNraN+tK6973a86ub2pbb2PG/ZGPHAKtt/Q0eJ2vOn1XrmGblmWSc9Qrjjb33y8/ZOPQac8PYux+r32uTx1w2td24wW39TR2O3uR2Y9Wm3iDJ5l6zDbapzavZsJmdwdWqFqoeb7nsxWrei80+blK+Zndt5nPWnkS4kTtrse7sheqOyb3ULRxvjPNarOrc8cYOpHbn+5tDgHf1psTrmrdjs9hfLHqxOB+b3H1v2tS9kJyT4oO2yXu0mt9tY+cFkw1eELKZ7eG26raY4g/ZnMtNPGbnYZOLxqYN3fLwcrzmfG51IXGvrb+xa9faNnR9Rn3NRFG7z9RSr8uKhchL2cw1ovUt6RvacKzWZ+Uhuerrp7Kh734oa5ZXTXekvCCkqfnuteKa5U19F1rbphZX7bUnq/TWnjQ12wXVOcgk66H35ZptkOp+n1V3Xd447y2Wa+7RWqd3zTb53XzN8qq5rlcb5HzMi9V0+zlrjhc01yxXlTcHrMZegTW/YzPHyer7xJtreIpzFtU9x0OvbXWy6g5IN+uYo6NerOb3amuOJ32h92q+6j6E9v3R/B3vvqtXXn3+hd7N+Ladbt15+CvFdzoX78crV3qx3vGOXqwk+fznp/385577xaxWr/owvzCO48600W8eCSSBczEMw3GSDd52CgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATOwL4zgub/ZJTKWb1hoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgNiSBJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDEJJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJgEkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATm9/sEwA2xkGS3Vf5/ydJfunX+DfvTHLXq/z/LyT5xXM5KwAAAACAW5+xVAAAAACA12YcFQAAAADgtRlHBQAAAAB4bcZRAQAAAABOZyyVKXxFksWr/P+D8nlUSSAJnItxHC++3n8zDMPPJnn0Vf70i+M4/vo3f1YAAAAAALc+Y6kAAAAAAK/NOCoAAAAAwGszjgoAAAAA8NqMowIAAAAAnM5YKpyf2c0+AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBNJ4EkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQkkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmASSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABOTQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYhJIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAExMAkkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAiUkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxCSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiaBJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDEJJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJgEkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATk0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGISSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMTAJJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIlJIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMQkkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmgSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxCSQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiYBJIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE5NAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBiEkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATEwCSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICJSSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMLH5zT4B4Lb2Z5Lc9yr///n2iQAAAAAAvIUZSwUAAAAAeG3GUQEAAAAAXptxVAAAAACA12YcFQAAAADgdMZS4ZwM4zje7HMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2Gizm30CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJtOAkkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAiUkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAxCST5f9q702hrr6pO9P+ZBAIhQABpQhtQergkwYBN0ZNCkU6ksbwCeq+KlpemLK/dqIsKAwVrlATxAkqhIMVFoCxKQiuICorSN5Z0ARMSJPSEEEJICPN+OC8SIO959tlnP+ecvfbvN8YZfFjzrLlWRsh+x/999jMBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAmRkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAzAyQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZmaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDMDJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJkBkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzM0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGYGSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADMzABJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJkZIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMwMkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGZmgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAzAyQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiZAZIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMzNAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBmBkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzMwASQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICZGSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDMDJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABmZoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMwMkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmQGSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADMzQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgZgZIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMzMAEkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAmR213wcANlNVHZ3kFklumOSqSY5JcmGSLyb5WJIPdvfF+3dCAAAAAIDNIK8FAAAAANZRVR2V5DuTnJCtbPPYJBclOT/JudnKNi/ctwMuYcQ7AQAAAACsmiwVAAAAAFilETPHEe8EAAAAALBKclQOguru/T4DsCGq6nuSPCjJDya5bZIjtym/NMk/JXlVkj/v7n+Y/YAAAAAAABtCXgsAAAAArKOqun2SBye5b5ITk1xxm/JOckaS1yR5eZI39AF8eH7EOwEAAAAArJosFQAAAAD2VlVdIcmtktwuW99Hv12SGyY57tDP1bP1PfSLknwuyceTnJnkvUneluTN3X3xXp97USNmjiPeCQAAAAAOstFz1BHJUTloDJAEZldVP5rk/05y8i62eUeS/9zdL17NqQAAAAAAkqra778oObW7X79XzeS1AAAAALBZquqEJN99mZ87ZuvLJofV3TX7wXaoqu6T5FeS3H0X23woydOSPKe7L13FuXZjxDsBAAAAwLpalyy1qs5KcpO97nsZP93d/3UvG8pSAQAAAGBvVNURSU5Kcs8k90pylyTH7GLLC5P8RZLnJ3lFd39114dcgREzxxHvBAAAAAAH0Sg5qudRlyZHZeUMkARmU1W3SvIHSe66wm3/OsnPdvcHV7gnAAAAALChNmWApLwWAAAAAMZXVTfMt7/g/Dt2us9BGiBZVTdI8owkP7zCbd+T5NHd/ZYV7rmwEe8EAAAAAOtknbPUTXphjywVAAAAAOZXVUdl6yXnD0/ywCTXnKnVmUmekuS5+/VS7REzxxHvBAAAAAAHzYg5qudRd02OysoYIAnMoqoenK0J1cfOsP0FSR7Z3S+bYW8AAAAAYINswgBJeS0AAAAAjKeqrpvklHzzS86vu4q9D8oAyaq6S5L/nuQ6M2x/SZLHdfezZtj7sEa8EwAAAAAcZKNlqZvywh5ZKgAAAADMq6pum+Tx2Xph9rX2sPU7k/xUd79rD3sOmTmOeCcAAAAAOEhGzlE9j7oSclRW4oj9PgAwnqr6+Wx9AM7xMvIc2vfPqurfz7Q/AAAAAMAQ5LUAAAAAMKzXJjk9ya8n+aGs6IXnB0VVPTDJX2aeL2MkyRWSPLOqnjLT/t9mxDsBAAAAwBoYOksdkSwVAAAAAPbE/ZP8VPb2pedJcnKSv6+qR+9VwxEzxxHvBAAAAAAH0MbkqCOSo7IuDJAEVqqqHpXkGUlq7lZJfr+qHjlzHwAAAACAtSSvBQAAAADWUVWdmuTF2frSxNx+uar+n7mbjHgnAAAAAIBVk6UCAAAAwEY4Osmzq+o35240YuY44p0AAAAAgG+zZznqiOSorJOj9vsAwDiq6k5JnpPFXkb+5iT/36H/PSvJF5NcNcnNknxfkv89yZ2nWiZ5TlW9v7vftuSxAQAAAACGI68FAAAAANZRVZ2Q5CXZ+lLLlH9M8oIkb0pyRpIvJLlKkhsl+Z4kD09yr0znpE+sqvd2958veextjXgnAAAAAIBVk6UCAAAAwIF2aZJ/SvL+JGcm+UySLyW5UpJrJTk+yb9Jcssd7PmEqrqwu5+64rMmGTNzHPFOAAAAADCQtctRRyRHZd1Ud+/3GYABVNXVkrw7yU0nSs9I8nPd/ZcL7PlvkzwzyXdOlJ6Z5MTuPn+BowIAAAAA/Kuq2u4vSk5P8vKZj/Cq7v74KjeU1wIAAADA+Krq3UnuMMfe3T31BYZZVNVRSf4uyZ0mSj+Z5DHd/dIF9jwlybOTnDxR+vlsZZtnL3LWRY14JwAAAABYJ6NlqVV1VpKbHGb5zUn+eOYjvKm7P7jqTWWpAAAAALC3qupXkvz2RNkHsvV9+1cneUt3X7jAvscn+Zkkj8nWC9GndJL7dferFqhd2IiZ44h3AgAAAICDbOQc1fOoclQODgMkgZWoqtOSPG6i7PVJHtLdX9jBvscl+R9J7jFR+rTu/oVF9wUAAAAASCYHSP5md//GXp1lVeS1AAAAADC+JV96flaSDyX5t9sV7eMAyccnedpE2XuS3Le7P76DfY/O1pdU/t1E6cu6+8GL7rtg78dnsDsBAAAAwDoZLUudeGHP87v7J/buNKsjSwUAAACAvbXNi8/PS/K8JC/o7nfuYv+rJDktyU8tUH5uktt093nL9ruc/o/PYJnjiHcCAAAAgINs5BzV86hyVA6OI/b7AMD6q6rbJPn5ibK/T/LAnbyMPEkO/eHj/kneOlH6mKq69U72BgAAAAAYjbwWAAAAADjknCQvS/KfkvxAku/o7psmefS+nuowquraSX5jouzDSU7dyZcxkqS7v5LkEUn+fKL0h6vq3jvZezsj3gkAAAAABrRWWeqIZKkAAAAAcCB8OFu56A26+z/s5qXnSdLdX+run07yqCSXTpQfn+SXd9PvskbMHEe8EwAAAACsoWFy1BHJUVlXBkgCq/DrSY7aZv1zSR7e3Rcus3l3fynJw7I1RftwjkryhGX2BwAAAAAYiLwWAAAAADbPx5O8PFu53A8luU5337i7H9zdT+7u13b3Z/f3iJN+McnVt1m/OMnDuvvTy2ze3Zdm68szZ02UPnGZ/Q9jxDsBAAAAwDobIUsdkSwVAAAAAPbPh5L8eJJbdfcfLvsd9MPp7j9J8pgFSh9TVVdbUdsRM8cR7wQAAAAA62LEHHVEclTWkgGSwK5U1c2S/MhE2X/q7nN206e7P5qtF59v56FVdcJu+gAAAAAArCt5LQAAAABslGckuX+S47v7Bt39wO5+Une/atkvLeyXQ19UefRE2Wnd/a7d9OnuLyR53ETZ91bVXXbTJxnzTgAAAACwpobJUkckSwUAAACAffPJJP8+yW27+4WHXnw9i+5+VpI/mSi7SpKH7bbXiJnjiHcCAAAAgDUxZI46Ijkq68wASWC3fj7Jkdusn5HkD1fU65lJ/nmb9SMPnQcAAAAAYBPJawEAAABgQ3T3c7v7Fd39if0+ywo8KsnVt1k/L8mTV9Gou1+e5E0TZY9dQasR7wQAAAAAa2ewLHVEslQAAAAA2Afd/cfd/azu/uoetfy1JBdO1DxoBX1GzBxHvBMAAAAAHHgD56gjkqOytgyQBJZWVUcm+XcTZU9b1RTsQ38o+r2Jsh+rKv9tAwAAAAA2irwWAAAAAFhjj5hY/8PuPn+F/f7LxPr9q2q7L4gsYsQ7AQAAAACsmiwVAAAAADZAd/9LkhdNlN1lBd9NHzFzHPFOAAAAAMC32MMcdURyVNaW/0MDu3HPJMdvs35Rkv+24p7PT3LxNuvXT3L3FfcEAAAAADjo5LUAAAAAwNqpqpsnOWWi7Dkrbnt6knO3WT86yY8su/mIdwIAAAAAWDVZKgAAAABsnFdMrF8tyU2W3XzEzHHEOwEAAAAA25o1Rx2RHJV1Z4AksBv3n1h/ZXd/cZUNu/u8JK+eKJs6FwAAAADAaOS1AAAAAMA6msoQ39HdH15lw+7+WpKXTJTtJtsc8U4AAAAAAKsmSwUAAACAzfLGBWputov9R8wcR7wTAAAAAHB4c+eoI5KjstYMkAR2494T66+cqe/UvqfO1BcAAAAA4KCS1wIAAAAA6+igZpv3qKojl9x7xDsBAAAAAKyaLBUAAAAANkh3fy7JxRNlx+2ixYiZ44h3AgAAAAAOYw9y1BHJUVlrBkgCS6mq45PceqLs9TO1f93E+m2r6noz9QYAAAAAOFDktQAAAADAOqqqo5LcdaJsrmzzTUku2mb96klO2emmI94JAAAAAGDVZKkAAAAAsLE+M7F+5WU2HTFzHPFOAAAAAMBCZslRRyRHZQQGSALLutPE+jndfc4cjbv7rCTnTpT5EAQAAAAANoW8FgAAAABYR7dNcpVt1i9J8tY5Gnf3RUneNVG2TLY54p0AAAAAAFZNlgoAAAAAm+mYifXtXra9nREzxxHvBAAAAABMmytHHZEclbVngCSwrJMn1t85c/+3T6yfNHN/AAAAAICDQl4LAAAAAKyjqWzzfd39lRn7z5FtjngnAAAAAIBVk6UCAAAAwIapqqsmufpE2eeX3H7EzHHEOwEAAAAA25g5Rx2RHJW1Z4AksKwTJ9bfO3P/qf19CAIAAAAAm+LEiXV5LQAAAABwEJ04sb6O2eaJu+y5W/JaAAAAAGAdnDixLksFAAAAgPGclKQmaj6y5N4nTqyvY+Z44i577pYcFQAAAAD23pw56ohOnFiXo3LgHbXfBwDW1i0m1s+Yuf+HJ9ZvPnN/AAAAAGCDVNUVknxnkhsnuWaSKyW5JMmXk5yX5GNJzunuL+/D8eS1AAAAAMA6GjHbHPFOAAAAAMCaqaojk9w0W8+9XjvJlZNcmuTCJOfnG8+9XrBPR5SlAgAAAMDm+aGJ9fOTnL3k3iNmjiPeCQAAAADY3pw56o55HnWSHJVdM0AS2LGqqiQnTJRNfUjt1tT+J8zcHwAAAAAY322q6neS3CPJ7ZMcPVH/tar6UJK3J3l9kld396fmPKC8FgAAAABYYzedWN/vbPMqVXXt7v70DvYc8U4AAAAAwHq4cVX9ZpJ7JTkpyTFTv1BV/5zkHUnekORV3b1XLxWSpQIAAADABjn0kvGHT5T9bXd/bckWI2aOI94JAAAAADiMPchRF+V51MXJUdk1AySBZVw3yZUmaj4+8xmm9r9KVV1n7pezAwAAAABDe+gO649IcqtDPz+erYGSr0ny7CSv6O5e8fkSeS0AAAAAsIaqqpLcZKJs7mzzE0m+lq1s93BummShL2SMeCcAAAAAYK3c49DPTtzs0M9Dk6Sq3pTkD5K8uLu/utrjbZGlAgAAAMBGelCmc8GXL7PxiJnjiHcCAAAAACY9KDPlqDvkedTFyVHZte3+5QE4nOsvUPOJmc+wyP6LnBMAAAAAYC5HJLlvtv6S9e1Vde8ZeshrAQAAAIB1dI0kV5qomTXbPPRlk89OlO0k2xzxTgAAAADAZrlLkv+W5P1V9fCZeshSAQAAAGCDVNWRSZ44UXZxkpcu2WLEzHHEOwEAAAAAh7EHOepe8zzqN8hR2ZYBksAyrjWxfn53f2XOA3T3hUkumCibOicAAAAAwF45OcnrquqPqupqK9xXXgsAAAAArKNFMsNPzX6K5JMT6zvJNke8EwAAAACwmb4ryZ9W1elVdb0V7y1LBQAAAIDN8nNJbjNR8/zu/tyS+4+YOY54JwAAAADg8ObOUfeL51HlqEwwQBJYxjUn1s/fk1NM95k6JwAAAADAXvvJJP9QVTdb0X7yWgAAAABgHS2SGe5FvrnKbHPEOwEAAAAAm+1+Sd5RVXdc4Z6yVAAAAADYEFV1QpLfnii7JMlTd9FmxMxxxDsBAAAAAJdjj3LU/eZ5VDgMAySBZVxjYv2Le3KK6T4+BAEAAACAg+jWSd5SVbddwV7yWgAAAABgHU1lm1/u7kv34ByrzDZHvBMAAAAAwPWTvLGq7r6i/WSpAAAAALABqurIJM9PcuxE6Wnd/ZFdtBoxcxzxTgAAAADAt9jDHPUg8DwqXI6j9vsAwFq60sT6l/bkFMkFE+tT5wQAAAAAOJz/leQdSf7x0M85Sb5w6OfibP0l3LWSXCfJnZPcLcn3J7nagvt/R5LXVdX3d/eZuzinvBYAAAAAWEcjZpsj3gkAAAAAWA8fSfKWbD3z+r+SnJlvPPf65Wy9JOdah36+O1vPvd4lW8+zLuKYJKdX1T27+227PKssFQAAAAA2w5OS3HWi5pxDdbsxYuY44p0AAAAAgG+3VznqojyPunNyVHbFAElgGVecWP/qnpxius/UOQEAAAAAvu7SJH+R5PQkr+zusyfqP3no531J/jrJU6vqSkkeleQXk3zXAj2PT/JnVfV93X3RkueW1wIAAAAA62jEbHPEOwEAAAAAB9cbk/x5tp57/eBE7acP/STJ3yV5elUdmeShSX4pyUkL9Ds2W8+9ntzdn1nyzIksFQAAAACGV1X3T/IrE2Wd5P/o7i/ust2ImeOIdwIAAAAALmOPc9TteB51d+So7MoR+30AYC35EAQAAAAARnFukiclOaG779vdz1pgeOTl6u6LuvsPktwyyeOTXLLAr52U5LeW6XeIvBYAAAAAWEcjZpsj3gkAAAAAOFg+n+TpSW7V3Xfr7t9d4GU9l6u7L+3uP+3uk5P8WJJFXi50oyR/uEy/y5ClAgAAAMDAqup2SV6YpCZKf7+7X7+CliNmjiPeCQAAAAA4ZB9y1G/ledTVkaOyKwZIAsuY+m/HpXtyiuk+R+7JKQAAAACAdXbj7n5Cd39sVRt299e6++lJ/k2Sjy7wK4+pqtsv2U5eCwAAAACsoxGzzRHvBAAAAAAcLKd09+OXfUnP4XT3i5LcMcl7Fyj/4ar6wV20k6UCAAAAwKCq6jpJTk9y1YnStyX5xRW1HTFzHPFOAAAAAED2LUf9Vp5HXR05KrtigCSwjKnpxUftySmm+1yyJ6cAAAAAANZWd0/lnbvZ+61J7prknInSo5I8cck28loAAAAAYB2NmG2OeCcAAAAA4ACZ+bnXM5LcLcl7Fih/8i5ayVIBAAAAYEBVdWySVyU5YaL0s0ke2t0Xr6j1iJnjiHcCAAAAgI23jznqN/E86krJUdkVAySBZUz9AWGvPgSvMLE+yx9kAAAAAAAW1d1nJ3lQkq9MlD6gqm6+RAt5LQAAAACwjkbMNke8EwAAAACwQbr7vCQPyNaLh7ZzUlXda8k2slQAAAAAGExVXTHJy5LccaL0y0ke2N0fXWH7ETPHEe8EAAAAABttn3PUPeV51G8iR2VbBkgCy5iaTnzFPTmFD0EAAAAAYA109zuT/NZE2RFJfnyJ7eW1AAAAAMA6GjHbHPFOAAAAAMCG6e6zk/zCAqWPXLKFLBUAAAAABlJVRyZ5UZJ7T5RekuSh3f13Kz7CiJnjiHcCAAAAgI11AHLUPed51H8lR2VbBkgCy7hgYv3YPTlFctWJ9alzAgAAAADsld9J8qmJmocssa+8FgAAAABYRyNmmyPeCQAAAADYTC9I8t6JmgdW1dRLby6PLBUAAAAABlFVleS/JnnwROnXkjyyu185wzFGzBxHvBMAAAAAbKQDkqPuF8+jylGZYIAksIzPTaxfbU9OMd1n6pwAAAAAAHuiuy9K8uyJsttU1XV2uLW8FgAAAABYR1OZ4RWq6kp7cI5VZpsj3gkAAAAA2EDd3UlOmyi7epKTlthelgoAAAAA43h6kp9YoO5nu/tPZzrDiJnjiHcCAAAAgE11EHLUfeF51CRyVCYYIAks47MT68ftxSGy9SG+nalzAgAAAADspZcsUPO9O9xTXgsAAAAArKNFMsPj5j7EAj12km2OeCcAAAAAYHO9LMklEzU7fe41kaUCAAAAwBCq6reSPGaB0v/Y3c+Z8SgjZo4j3gkAAAAANs4BylH3k+dRYRsGSALL+MzE+tFVddycB6iqaya54kSZD0EAAAAA4MDo7n9K8qmJslvtcFt5LQAAAACwjqayzSS53uynmO6xk2xzxDsBAAAAABuqu89L8u6Jsp0+95rIUgEAAABg7VXVryX51QVKf727f3fm44yYOY54JwAAAADYKAcsR903nkeVo7I9AySBZZy9QM11Zz7DIvsvck4AAAAAgL30ron1E3a4n7wWAAAAAFg73X1hpr/sMGu2WVXHJLnqRNlHF91vxDsBAAAAABvvnRPrJ+x0Q1kqAAAAAKy3qnpckicvUPqfu/uJc59nxMxxxDsBAAAAwCY5aDnqAeB5VDgMAySBHevuCzL9IXiTmY9xwsT6p7r7SzOfAQAAAABgp86aWL/OTjaT1wIAAAAAa+ysifW5s81FzUE5GgAAF3NJREFU9j9rh3tO1a/jnQAAAACAzXXWxPqOnnvdwb6yVAAAAAA4gKrqZ5KctkDp73f3L818nMs6a2J9HTPHqfp1vBMAAAAADO8A56j76ayJdc+jsrEMkASWdebE+s1n7v9dE+tT5wMAAAAA2A9fmFg/Zok95bUAAAAAwDo66NnmJ7v7wh3uOeKdAAAAAIDNNcdzr4ksFQAAAADWTlU9IsmzFyh9bpLHznycbzVi5jjinQAAAABgaAc8R91PnkeFwzBAEljWP02s33Lm/lP7T50PAAAAAGA/XDyxfoUl9pTXAgAAAADraMRsc8Q7AQAAAACba47nXhNZKgAAAACslap6aJI/TlITpS9K8jPd3fOf6puMmDmOeCcAAAAAGNYa5Kj7yfOocBgGSALLeufE+kkz9z95Yv1dM/cHAAAAAFjGlSfWv7zEnvJaAAAAAGAdjZhtjngnAAAAAGBzzfHcayJLBQAAAIC1UVUPSPLCJEdOlL4sySO7+2vzn+rbjJg5jngnAAAAABjSmuSo+8nzqHAYBkgCy5r6EDyxqqb+YLKUqjoqyR0mynwIAgAAAAAH0fUm1i9YYk95LQAAAACwjqayzRtW1XVm7H/HifU5XtazjncCAAAAADbXHM+9JrJUAAAAAFgLVXWfJC9JcoWJ0lcn+dHu/ur8p7pcI2aOI94JAAAAAIazRjnqfvI8KhyGAZLAst6e5KJt1o/N9AfVsu6U5Jht1i9K8o6ZegMAAAAA7MZ3Taz/yxJ7ymsBAAAAgLXT3R9L8tGJsrvP0buqrp/kFhNlf7vTfUe8EwAAAACw0eZ47lWWCgAAAABroKrunuRlSY6eKH1Dkgd398Vzn+lwRswcR7wTAAAAAIxmnXLUfeZ5VDgMAySBpXT3RUn+bqLs1Jna33ti/U2HzgcAAAAAcGBU1dFJTpwoO3On+8prAQAAAIA19vqJ9f3KNs/o7qkvixzOiHcCAAAAADbTnSfWd/zc62XIUgEAAADggKqq701yepIrT5T+bZIHHJDvk4+YOY54JwAAAAAYwprmqPvF86hwGAZIArvxuon1B8/U9yET638xU18AAAAAgN24V5KjJ2reu+Te8loAAAAAYB1NZZsPqKojZ+g7Z7Y54p0AAAAAgA1TVbdJcsJE2bLPvSayVAAAAAA4kKrqjkleneTYidK3Jfmh7v7S/KdayIiZ44h3AgAAAIC1t8Y56p7zPCpszwBJYDf++8T6yVV1y1U2rKrbJbn9NiWd6XMBAAAAAOyHR06sX5Ktv+BdhrwWAAAAAFhHr0xy4Tbr10ly71U2rKprJrnPRNlLd9FixDsBAAAAAJtn6rnXJHnzLvaXpQIAAADAAVNVt0/y2iRXnyh9T5L7dPf5859qYSNmjiPeCQAAAADW2prnqPvB86iwDQMkgaV190eS/MNE2WNW3PaxE+tv7u6zVtwTAAAAAGBXqurmSR4yUfbG7r5omf3ltQAAAADAOuruC5K8fKJs1dnmzya54jbr5yR547Kbj3gnAAAAAGCzVNU1kjx6ouwjh55fXYosFQAAAAAOlqq6RZLXJbnWROn7kpza3Z+f/1SLGzFzHPFOAAAAALDO1j1H3WueR4VpBkgCu/VHE+s/WVXHr6JRVd0wySMmyp63il4AAAAAACv2e0mOnKh5yS57yGsBAAAAgHU0lW3et6pOXEWjqjo201/w+JPu7l22GvFOAAAAAMDm+O0kx03U7Pa510SWCgAAAAAHQlWdkOQvk1x3ovSMJPfu7k/PfqjljJg5jngnAAAAAFg7A+Woe8nzqDDBAElgt16Q5FPbrB+T5Ckr6vXUJFfaZv2Th84DAAAAAHBgVNUvJvmBibLzk7x4l63ktQAAAADA2unu1yV57zYlleS0FbX71STX22b9K0mesdsmI94JAAAAANgMVfWQJI+eKLs0yXN320uWCgAAAAD7r6qun62Xnt9wovSsJPfs7nNnP9SSRswcR7wTAAAAAKybkXLUveJ5VFiMAZLArnT3RUmePlH2yKr64d30qaqHJfmxibLTuvsru+kDAAAAAIyvqk6uqivvUa9HJfmdBUqf2d1f2E0veS0AAAAAsMaeOrF+t6r6D7tpUFXfl+SXJsqe192f3E2fyxjxTgAAAADAHquq21TVNfao16lJXrBA6Uu7+yMraitLBQAAAIB9UlXXztZLz282UfqxbL30/GPzn2rXRswcR7wTAAAAAKyFUXJUz6PKUTmYqrv3+wzAmquqY5J8IMmNtin7YpJ7d/dbl9j/e5K8Lsmx25R9NMmtu/vLO90fAAAAANgsVXVakocleUqS53b3l2boccVsDY583ALln0xyq+4+bwV95bUAAAAAwGFV1QlJztyuprtrb07zDVVVSd6S5JRtyi5J8iPdffoS+988yd8kOX6bsi8muUV3f2Kn+x+m53B3AgAAAIBNcZCy1Kp6fJJfT/K7SZ7Z3Z+doUcl+eUkT0py1ET5l5Pctru3/eezw96yVAAAAADYY1V1XJK/SnLiROknkty1u8+Y+0yrMGLmOOKdAAAAAGAdjJSjeh41iRyVA+iI/T4AsP66+8IkvzBRdtUkf1FV99vJ3lX1wCSvzfYvI0+S/+hl5AAAAADADhyf5OlJzqmqp1XVHVa1cVXdLcnfZrHhkUny2FUMj0zktQAAAADAeuruTvJ/Jeltyq6Q5KVV9VM72buqvj/TX8ZIkt9c5ZcxRrwTAAAAALBvjkvyxCRnV9VzDmWEK1FVJyZ5dZLfzvTLepLkN1b1sp5ElgoAAAAA+6Gqjs1WLnjiROlnktzrIL/0/FuNmDmOeCcAAAAAOOgGzVGPi+dR5agcKLX17y7A7lXVC5P82ERZJ3lRkid19we22es2SZ6Q5OELtH5hd//4wgcFAAAAADZaVZ2Wyx/u+KEkr0jyhiR/392f28Ge10tyrySPTXKnHRznGd392B3UL3oeeS0AAAAADK6q7prkFjv8tWslecpEzU8vcZy/WcWXWqrqyUl+bYHS1yR5Qne/bZu9bpLkl7N1n6kvmfxNtr6Yc+miZ13UiHcCAAAAgHWy7llqVT0+ydMuZ+mcJK9M8rokb97JC2eq6hpJ7p7k55KcuoPjvDzJg3qGF5XIUgEAAABg71TV6Unut0Dp/5vk3fOe5puc292vXMVGI2aOI94JAAAAAA6q0XJUz6N+GzkqB4IBksDKHJp+/fYkt1zwV96V5M1JzkxyQZKrJrlpku9PcocF9/hAklO6+4KdnRYAAAAA2FTbDJC8rM7WX2R+IMlZST6R5PNJvnJo/RrZejnQtZPcOTt/sVCS/M8kD+3ury7xu9uS1wIAAADA+KrqeUketd/nOOQnu/t5u92kqo5M8oYkd13wVz6Q5E1JzkhyfpKrJLlRtnLb70lSC+zxqSQndffHd3zgBYx4JwAAAABYJ+uepW7zwp5vdW628sV/ztZzr59LclGSS7P13Os1k3xHku9OcrssljVe1t8nuU93f3GHv7cQWSoAAAAA7J2qOivJTfb7HJfjb7r77qvYaMTMccQ7AQAAAMBBNVqO6nnUw5Kjsq+mJpMCLKy7L6iq+2Trg+1GC/zKSYd+lnV2tj7UvYwcAAAAAFi1SnLjQz9zeHGSR8wxPDKR1wIAAAAA66m7L62qByX5qyR3WOBXbnXoZ1nnZSvbnO3LGCPeCQAAAAA4kI4/9HOPGfb+6yQPmOtlPYksFQAAAABYrREzxxHvBAAAAAAcOJ5H3ZnzIkdlF47Y7wMAY+nujya5Z5KPzNzqw0nu2d1nz9wHAAAAAGCVLk3yq939o919yZyN5LUAAAAAwDrq7s8nOTXJ22du9alsfRnj3TP3GfJOAAAAAMDG+L0kp875sp6vk6UCAAAAAKs0YuY44p0AAAAAgI3geVS4HAZIAivX3R9OckqS187U4jVJTunuuV96DgAAAACwSm9L8t3d/ZS9aiivBQAAAADWUXd/OsldkvzJTC2+nte+dab9v82IdwIAAAAAhvahJPfs7sd191f3qqksFQAAAABYpREzxxHvBAAAAAAMy/OosA0DJIFZdPfnu/sHkvxEtiYer8Knkjyqu3+wu89b0Z4AAAAAwOZ5V5J/3sN+70zykCR37u5372HfJPJaAAAAAGA9dfdF3f2oJPfL6jLdLyb5hSTf293nrGjPhY14JwAAAABgdh9I8r497HdGkv8zye26+6/2sO+/kqUCAAAAAKs0YuY44p0AAAAAgFl5HnU15KislAGSwKy6+/lJbpbk55O8f8lt3nfo92/a3XNNZgYAAAAANkR3P7+7vzPJTbI1VPGPkrw3ySUrbPPhJKcluWN337G7/6y7e4X775i8FgAAAABYR939yiS3SvKIJG9bcpuPJvnVJCd099O6+9JVnW8ZI94JAAAAAJhHd7+mu2+b5LpJfjTJs5K8PclFK2xzTpLnJLlbklt29x919yqfq12KLBUAAAAAWKURM8cR7wQAAAAArJ7nUeWoHEy1z+8qBjZMVd0iyQ8kOTnJbZPcIMlVkxyT5MJsTUr+WLZeQv7OJK/u7jP257QAAAAAwCapqismuV2S/y3JTZPc6NDPDZJcLcmVs5VlHp3k4mz9RecXkpybrVzzA9kaRPkP3X32Xp9/p+S1AAAAAMA6qqobJfnBJKckuU2Sm2Qrwz0myVeylW2em+T9Sd6d5LXd/Z59OeyCRrwTAAAAADCvqjoyya2T3CHJzfKN515vmOTq2coXv/7c61ez9dzr17PGf0nywST/mORt3f3BvT7/MmSpAAAAAMAqjZg5jngnAAAAAGA+nkeVo7K/DJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmNkR+30AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgNEZIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMwMkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGZmgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAzAyQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiZAZIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMzNAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBmBkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzMwASQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICZGSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDMDJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABmZoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMwMkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmQGSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADMzQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgZgZIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMzMAEkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAmRkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAzAyQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZmaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDMDJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJkBkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzM0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGYGSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADMzABJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJkZIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMwMkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGZmgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAzAyQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiZAZIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMzNAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBmBkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzMwASQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICZGSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDMDJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABmZoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMwMkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmQGSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADMzQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgZgZIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMzMAEkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAmRkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAzAyQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZmaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDMDJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJkBkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzM0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGYGSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADMzABJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJkZIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMwMkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGZmgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAzAyQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiZAZIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMzNAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBmBkgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzMwASQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICZGSAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDMDJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABmZoAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMwMkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYmQGSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADMzQBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgZgZIAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMzMAEkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAmRkgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAzAyQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZmaAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDMDJAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJkBkgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzM0ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGYGSAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADMzABJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJkZIAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMwMkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGb2/wOlxHidEYeSUAAAAABJRU5ErkJggg==\n",
+      "text/plain": [
+       "<Figure size 9000x7200 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "t2d = t_cmp.reshape(2*64, -1)\n",
+    "fig = plt.figure(figsize=(15, 12), dpi=600)\n",
+    "mx = max(-np.min(t2d), np.max(t2d))\n",
+    "plt.imshow(t2d, cmap='seismic', vmin=-mx, vmax=mx)\n",
+    "#plt.savefig('img.svg')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 65,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Ratio 0.086761474609375\n"
+     ]
+    }
+   ],
+   "source": [
+    "lg = sum(np.abs(t)>mx*0.05)\n",
+    "print('Ratio', lg/t.size)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Possible approximate contractions\n",
+    "\n",
+    "## Compress the tensors\n",
+    "\n",
+    "Suppose we have an algorithm that takes a tensor $T$, and returns a compressed data $T'$: $C(T) = D$, while the output tensor is compressed in some clever way. \n",
+    "There also should be a decompression algorithm, which takes the data and returns a (decompressed) tensor. $C^{-1}(D) = T'$, while $T'$ may also contain some noise or in general has fewer information.\n",
+    "\n",
+    "## Approximate tensor contraction\n",
+    "\n",
+    "For a tensor network $\\mathcal T$, construct another TN $\\mathcal T'$ which results in a similar result, but with smaller memory overhead. \n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.2"
+  },
+  "toc": {
+   "base_numbering": 1,
+   "nav_menu": {},
+   "number_sections": true,
+   "sideBar": true,
+   "skip_h1_title": false,
+   "title_cell": "Table of Contents",
+   "title_sidebar": "Contents",
+   "toc_cell": false,
+   "toc_position": {},
+   "toc_section_display": true,
+   "toc_window_display": false
+  },
+  "varInspector": {
+   "cols": {
+    "lenName": 16,
+    "lenType": 16,
+    "lenVar": 40
+   },
+   "kernels_config": {
+    "python": {
+     "delete_cmd_postfix": "",
+     "delete_cmd_prefix": "del ",
+     "library": "var_list.py",
+     "varRefreshCmd": "print(var_dic_list())"
+    },
+    "r": {
+     "delete_cmd_postfix": ") ",
+     "delete_cmd_prefix": "rm(",
+     "library": "var_list.r",
+     "varRefreshCmd": "cat(var_dic_list()) "
+    }
+   },
+   "types_to_exclude": [
+    "module",
+    "function",
+    "builtin_function_or_method",
+    "instance",
+    "_Feature"
+   ],
+   "window_display": false
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}