From e1b9a6d1df273d7902da92e71eb64b8908bf25b3 Mon Sep 17 00:00:00 2001 From: IISCAditayTripathi Date: Mon, 13 Jul 2020 15:42:20 +0530 Subject: [PATCH] first commit --- _init_paths.py | 15 + cfgs/res101.yml | 18 + cfgs/res101_ls.yml | 22 + cfgs/res50.yml | 17 + cfgs/res50_1.yml | 19 + cfgs/res50_2.yml | 19 + cfgs/res50_3.yml | 19 + cfgs/res50_4.yml | 19 + cfgs/res50_ls.yml | 18 + cfgs/vgg16.yml | 14 + check_image.py | 1 + cls_utils.py | 124 ++++ coco_class_map.pkl | Bin 0 -> 1292 bytes explore.ipynb | 629 ++++++++++++++++++ get_common_classes.py | 70 ++ get_train_test_quick_draw.py | 30 + .../VOCdevkit-matlab-wrapper/get_voc_opts.m | 14 + .../VOCdevkit-matlab-wrapper/voc_eval.m | 56 ++ .../VOCdevkit-matlab-wrapper/xVOCap.m | 10 + lib/datasets/__init__.py | 6 + lib/datasets/coco.py | 551 +++++++++++++++ lib/datasets/ds_utils.py | 49 ++ lib/datasets/factory.py | 72 ++ lib/datasets/factory2.py | 72 ++ lib/datasets/imagenet.py | 214 ++++++ lib/datasets/imdb.py | 265 ++++++++ lib/datasets/pascal_voc.py | 415 ++++++++++++ lib/datasets/pascal_voc_rbg.py | 312 +++++++++ lib/datasets/pascal_voc_sketch.py | 420 ++++++++++++ lib/datasets/pascal_voc_sketch_v2.py | 420 ++++++++++++ lib/datasets/tools/mcg_munge.py | 39 ++ lib/datasets/vg.py | 407 ++++++++++++ lib/datasets/vg_eval.py | 123 ++++ lib/datasets/voc_eval.py | 211 ++++++ lib/model/__init__.py | 0 lib/model/csrc/ROIAlign.h | 46 ++ lib/model/csrc/ROIPool.h | 48 ++ lib/model/csrc/cpu/ROIAlign_cpu.cpp | 257 +++++++ lib/model/csrc/cpu/nms_cpu.cpp | 75 +++ lib/model/csrc/cpu/vision.h | 16 + lib/model/csrc/cuda/ROIAlign_cuda.cu | 346 ++++++++++ lib/model/csrc/cuda/ROIPool_cuda.cu | 202 ++++++ lib/model/csrc/cuda/nms.cu | 131 ++++ lib/model/csrc/cuda/vision.h | 48 ++ lib/model/csrc/nms.h | 28 + lib/model/csrc/vision.cpp | 13 + lib/model/faster_rcnn/__init__.py | 0 .../faster_rcnn/faster_rcnn_early_fusion.py | 387 +++++++++++ lib/model/faster_rcnn/faster_rcnn_oneshot.py | 383 +++++++++++ lib/model/faster_rcnn/resnet_oneshot.py | 357 ++++++++++ lib/model/faster_rcnn/vgg16.py | 62 ++ lib/model/nms/.gitignore | 3 + lib/model/nms/__init__.py | 0 lib/model/nms/_ext/__init__.py | 0 lib/model/nms/_ext/nms/__init__.py | 15 + lib/model/nms/build.py | 37 ++ lib/model/nms/make.sh | 10 + lib/model/nms/nms_cpu.py | 36 + lib/model/nms/nms_gpu.py | 12 + lib/model/nms/nms_kernel.cu | 144 ++++ lib/model/nms/nms_wrapper.py | 21 + lib/model/nms/src/nms_cuda.h | 5 + lib/model/nms/src/nms_cuda_kernel.cu | 161 +++++ lib/model/nms/src/nms_cuda_kernel.h | 10 + lib/model/roi_align/__init__.py | 0 lib/model/roi_align/_ext/__init__.py | 0 .../roi_align/_ext/roi_align/__init__.py | 15 + lib/model/roi_align/build.py | 38 ++ lib/model/roi_align/functions/__init__.py | 0 lib/model/roi_align/functions/roi_align.py | 51 ++ lib/model/roi_align/make.sh | 10 + lib/model/roi_align/modules/__init__.py | 0 lib/model/roi_align/modules/roi_align.py | 42 ++ lib/model/roi_align/src/roi_align.c | 190 ++++++ lib/model/roi_align/src/roi_align.h | 5 + lib/model/roi_align/src/roi_align_cuda.c | 76 +++ lib/model/roi_align/src/roi_align_cuda.h | 5 + lib/model/roi_align/src/roi_align_kernel.cu | 167 +++++ lib/model/roi_align/src/roi_align_kernel.h | 34 + lib/model/roi_crop/__init__.py | 0 lib/model/roi_crop/_ext/__init__.py | 0 .../roi_crop/_ext/crop_resize/__init__.py | 12 + lib/model/roi_crop/_ext/roi_crop/__init__.py | 15 + lib/model/roi_crop/build.py | 36 + lib/model/roi_crop/functions/__init__.py | 0 lib/model/roi_crop/functions/crop_resize.py | 37 ++ lib/model/roi_crop/functions/gridgen.py | 46 ++ lib/model/roi_crop/functions/roi_crop.py | 21 + lib/model/roi_crop/make.sh | 10 + lib/model/roi_crop/modules/__init__.py | 0 lib/model/roi_crop/modules/gridgen.py | 414 ++++++++++++ lib/model/roi_crop/modules/roi_crop.py | 8 + lib/model/roi_crop/src/roi_crop.c | 485 ++++++++++++++ lib/model/roi_crop/src/roi_crop.h | 11 + lib/model/roi_crop/src/roi_crop_cuda.c | 105 +++ lib/model/roi_crop/src/roi_crop_cuda.h | 8 + .../roi_crop/src/roi_crop_cuda_kernel.cu | 330 +++++++++ lib/model/roi_crop/src/roi_crop_cuda_kernel.h | 37 ++ lib/model/roi_layers/__init__.py | 9 + lib/model/roi_layers/nms.py | 7 + lib/model/roi_layers/roi_align.py | 67 ++ lib/model/roi_layers/roi_pool.py | 63 ++ lib/model/roi_pooling/__init__.py | 0 lib/model/roi_pooling/_ext/__init__.py | 0 .../roi_pooling/_ext/roi_pooling/__init__.py | 15 + lib/model/roi_pooling/build.py | 36 + lib/model/roi_pooling/functions/__init__.py | 0 lib/model/roi_pooling/functions/roi_pool.py | 38 ++ lib/model/roi_pooling/modules/__init__.py | 0 lib/model/roi_pooling/modules/roi_pool.py | 14 + lib/model/roi_pooling/src/roi_pooling.c | 104 +++ lib/model/roi_pooling/src/roi_pooling.h | 2 + lib/model/roi_pooling/src/roi_pooling_cuda.c | 88 +++ lib/model/roi_pooling/src/roi_pooling_cuda.h | 5 + .../roi_pooling/src/roi_pooling_kernel.cu | 239 +++++++ .../roi_pooling/src/roi_pooling_kernel.h | 25 + lib/model/rpn/__init__.py | 0 lib/model/rpn/anchor_target_layer.py | 219 ++++++ lib/model/rpn/bbox_transform.py | 257 +++++++ lib/model/rpn/generate_anchors.py | 113 ++++ lib/model/rpn/proposal_layer.py | 175 +++++ .../rpn/proposal_target_layer_cascade.py | 214 ++++++ lib/model/rpn/rpn.py | 121 ++++ lib/model/utils/.gitignore | 3 + lib/model/utils/__init__.py | 0 lib/model/utils/bbox.pyx | 105 +++ lib/model/utils/blob.py | 101 +++ lib/model/utils/config.py | 409 ++++++++++++ lib/model/utils/logger.py | 71 ++ lib/model/utils/net_utils.py | 276 ++++++++ lib/roi_data_layer/__init__.py | 6 + lib/roi_data_layer/minibatch.py | 87 +++ lib/roi_data_layer/roibatchLoader.py | 387 +++++++++++ lib/roi_data_layer/roidb.py | 188 ++++++ lib/roi_data_layer/sketchBatchLoader.py | 536 +++++++++++++++ lib/roi_data_layer/sketchBatchLoaderVOC.py | 526 +++++++++++++++ lib/roi_data_layer/sketchBatchLoaderVOC_v2.py | 532 +++++++++++++++ lib/setup.py | 68 ++ ratio_index.pkl | Bin 0 -> 1210929 bytes ratio_list.pkl | Bin 0 -> 1210929 bytes read_store_quick_draw.py | 63 ++ readme.local | 25 + test_cat_list.pkl | Bin 0 -> 45015 bytes test_compare.py | 408 ++++++++++++ test_net_oneshot.py | 419 ++++++++++++ test_net_oneshot_voc.py | 409 ++++++++++++ test_ratio_index.pkl | Bin 0 -> 77313 bytes test_ratio_list.pkl | Bin 0 -> 38735 bytes train_val_sketch_early_fusion.py | 424 ++++++++++++ train_val_sketch_oneshot.py | 413 ++++++++++++ 150 files changed, 17018 insertions(+) create mode 100644 _init_paths.py create mode 100644 cfgs/res101.yml create mode 100644 cfgs/res101_ls.yml create mode 100644 cfgs/res50.yml create mode 100644 cfgs/res50_1.yml create mode 100644 cfgs/res50_2.yml create mode 100644 cfgs/res50_3.yml create mode 100644 cfgs/res50_4.yml create mode 100644 cfgs/res50_ls.yml create mode 100644 cfgs/vgg16.yml create mode 100644 check_image.py create mode 100644 cls_utils.py create mode 100644 coco_class_map.pkl create mode 100644 explore.ipynb create mode 100644 get_common_classes.py create mode 100644 get_train_test_quick_draw.py create mode 100644 lib/datasets/VOCdevkit-matlab-wrapper/get_voc_opts.m create mode 100644 lib/datasets/VOCdevkit-matlab-wrapper/voc_eval.m create mode 100644 lib/datasets/VOCdevkit-matlab-wrapper/xVOCap.m create mode 100644 lib/datasets/__init__.py create mode 100644 lib/datasets/coco.py create mode 100644 lib/datasets/ds_utils.py create mode 100644 lib/datasets/factory.py create mode 100644 lib/datasets/factory2.py create mode 100644 lib/datasets/imagenet.py create mode 100644 lib/datasets/imdb.py create mode 100644 lib/datasets/pascal_voc.py create mode 100644 lib/datasets/pascal_voc_rbg.py create mode 100644 lib/datasets/pascal_voc_sketch.py create mode 100644 lib/datasets/pascal_voc_sketch_v2.py create mode 100644 lib/datasets/tools/mcg_munge.py create mode 100644 lib/datasets/vg.py create mode 100644 lib/datasets/vg_eval.py create mode 100644 lib/datasets/voc_eval.py create mode 100644 lib/model/__init__.py create mode 100644 lib/model/csrc/ROIAlign.h create mode 100644 lib/model/csrc/ROIPool.h create mode 100644 lib/model/csrc/cpu/ROIAlign_cpu.cpp create mode 100644 lib/model/csrc/cpu/nms_cpu.cpp create mode 100644 lib/model/csrc/cpu/vision.h create mode 100644 lib/model/csrc/cuda/ROIAlign_cuda.cu create mode 100644 lib/model/csrc/cuda/ROIPool_cuda.cu create mode 100644 lib/model/csrc/cuda/nms.cu create mode 100644 lib/model/csrc/cuda/vision.h create mode 100644 lib/model/csrc/nms.h create mode 100644 lib/model/csrc/vision.cpp create mode 100644 lib/model/faster_rcnn/__init__.py create mode 100644 lib/model/faster_rcnn/faster_rcnn_early_fusion.py create mode 100644 lib/model/faster_rcnn/faster_rcnn_oneshot.py create mode 100644 lib/model/faster_rcnn/resnet_oneshot.py create mode 100644 lib/model/faster_rcnn/vgg16.py create mode 100644 lib/model/nms/.gitignore create mode 100644 lib/model/nms/__init__.py create mode 100644 lib/model/nms/_ext/__init__.py create mode 100644 lib/model/nms/_ext/nms/__init__.py create mode 100644 lib/model/nms/build.py create mode 100644 lib/model/nms/make.sh create mode 100644 lib/model/nms/nms_cpu.py create mode 100644 lib/model/nms/nms_gpu.py create mode 100644 lib/model/nms/nms_kernel.cu create mode 100644 lib/model/nms/nms_wrapper.py create mode 100644 lib/model/nms/src/nms_cuda.h create mode 100644 lib/model/nms/src/nms_cuda_kernel.cu create mode 100644 lib/model/nms/src/nms_cuda_kernel.h create mode 100644 lib/model/roi_align/__init__.py create mode 100644 lib/model/roi_align/_ext/__init__.py create mode 100644 lib/model/roi_align/_ext/roi_align/__init__.py create mode 100644 lib/model/roi_align/build.py create mode 100644 lib/model/roi_align/functions/__init__.py create mode 100644 lib/model/roi_align/functions/roi_align.py create mode 100644 lib/model/roi_align/make.sh create mode 100644 lib/model/roi_align/modules/__init__.py create mode 100644 lib/model/roi_align/modules/roi_align.py create mode 100644 lib/model/roi_align/src/roi_align.c create mode 100644 lib/model/roi_align/src/roi_align.h create mode 100644 lib/model/roi_align/src/roi_align_cuda.c create mode 100644 lib/model/roi_align/src/roi_align_cuda.h create mode 100644 lib/model/roi_align/src/roi_align_kernel.cu create mode 100644 lib/model/roi_align/src/roi_align_kernel.h create mode 100644 lib/model/roi_crop/__init__.py create mode 100644 lib/model/roi_crop/_ext/__init__.py create mode 100644 lib/model/roi_crop/_ext/crop_resize/__init__.py create mode 100644 lib/model/roi_crop/_ext/roi_crop/__init__.py create mode 100644 lib/model/roi_crop/build.py create mode 100644 lib/model/roi_crop/functions/__init__.py create mode 100644 lib/model/roi_crop/functions/crop_resize.py create mode 100644 lib/model/roi_crop/functions/gridgen.py create mode 100644 lib/model/roi_crop/functions/roi_crop.py create mode 100644 lib/model/roi_crop/make.sh create mode 100644 lib/model/roi_crop/modules/__init__.py create mode 100644 lib/model/roi_crop/modules/gridgen.py create mode 100644 lib/model/roi_crop/modules/roi_crop.py create mode 100644 lib/model/roi_crop/src/roi_crop.c create mode 100644 lib/model/roi_crop/src/roi_crop.h create mode 100644 lib/model/roi_crop/src/roi_crop_cuda.c create mode 100644 lib/model/roi_crop/src/roi_crop_cuda.h create mode 100644 lib/model/roi_crop/src/roi_crop_cuda_kernel.cu create mode 100644 lib/model/roi_crop/src/roi_crop_cuda_kernel.h create mode 100644 lib/model/roi_layers/__init__.py create mode 100644 lib/model/roi_layers/nms.py create mode 100644 lib/model/roi_layers/roi_align.py create mode 100644 lib/model/roi_layers/roi_pool.py create mode 100644 lib/model/roi_pooling/__init__.py create mode 100644 lib/model/roi_pooling/_ext/__init__.py create mode 100644 lib/model/roi_pooling/_ext/roi_pooling/__init__.py create mode 100644 lib/model/roi_pooling/build.py create mode 100644 lib/model/roi_pooling/functions/__init__.py create mode 100644 lib/model/roi_pooling/functions/roi_pool.py create mode 100644 lib/model/roi_pooling/modules/__init__.py create mode 100644 lib/model/roi_pooling/modules/roi_pool.py create mode 100644 lib/model/roi_pooling/src/roi_pooling.c create mode 100644 lib/model/roi_pooling/src/roi_pooling.h create mode 100644 lib/model/roi_pooling/src/roi_pooling_cuda.c create mode 100644 lib/model/roi_pooling/src/roi_pooling_cuda.h create mode 100644 lib/model/roi_pooling/src/roi_pooling_kernel.cu create mode 100644 lib/model/roi_pooling/src/roi_pooling_kernel.h create mode 100644 lib/model/rpn/__init__.py create mode 100644 lib/model/rpn/anchor_target_layer.py create mode 100644 lib/model/rpn/bbox_transform.py create mode 100644 lib/model/rpn/generate_anchors.py create mode 100644 lib/model/rpn/proposal_layer.py create mode 100644 lib/model/rpn/proposal_target_layer_cascade.py create mode 100644 lib/model/rpn/rpn.py create mode 100644 lib/model/utils/.gitignore create mode 100644 lib/model/utils/__init__.py create mode 100644 lib/model/utils/bbox.pyx create mode 100644 lib/model/utils/blob.py create mode 100644 lib/model/utils/config.py create mode 100644 lib/model/utils/logger.py create mode 100644 lib/model/utils/net_utils.py create mode 100644 lib/roi_data_layer/__init__.py create mode 100644 lib/roi_data_layer/minibatch.py create mode 100644 lib/roi_data_layer/roibatchLoader.py create mode 100644 lib/roi_data_layer/roidb.py create mode 100644 lib/roi_data_layer/sketchBatchLoader.py create mode 100644 lib/roi_data_layer/sketchBatchLoaderVOC.py create mode 100644 lib/roi_data_layer/sketchBatchLoaderVOC_v2.py create mode 100644 lib/setup.py create mode 100644 ratio_index.pkl create mode 100644 ratio_list.pkl create mode 100644 read_store_quick_draw.py create mode 100644 readme.local create mode 100644 test_cat_list.pkl create mode 100644 test_compare.py create mode 100644 test_net_oneshot.py create mode 100644 test_net_oneshot_voc.py create mode 100644 test_ratio_index.pkl create mode 100644 test_ratio_list.pkl create mode 100644 train_val_sketch_early_fusion.py create mode 100644 train_val_sketch_oneshot.py diff --git a/_init_paths.py b/_init_paths.py new file mode 100644 index 0000000..bdc926d --- /dev/null +++ b/_init_paths.py @@ -0,0 +1,15 @@ +import os.path as osp +import sys + +def add_path(path): + if path not in sys.path: + sys.path.insert(0, path) + +this_dir = osp.dirname(__file__) + +# Add lib to PYTHONPATH +lib_path = osp.join(this_dir, 'lib') +add_path(lib_path) + +coco_path = osp.join(this_dir, 'data', 'coco', 'PythonAPI') +add_path(coco_path) diff --git a/cfgs/res101.yml b/cfgs/res101.yml new file mode 100644 index 0000000..bb041e1 --- /dev/null +++ b/cfgs/res101.yml @@ -0,0 +1,18 @@ +EXP_DIR: res101 +TRAIN: + HAS_RPN: True + BBOX_NORMALIZE_TARGETS_PRECOMPUTED: True + RPN_POSITIVE_OVERLAP: 0.7 + RPN_BATCHSIZE: 256 + PROPOSAL_METHOD: gt + BG_THRESH_LO: 0.0 + DISPLAY: 20 + BATCH_SIZE: 128 + WEIGHT_DECAY: 0.0001 + DOUBLE_BIAS: False + LEARNING_RATE: 0.001 +TEST: + HAS_RPN: True +POOLING_SIZE: 7 +POOLING_MODE: align +CROP_RESIZE_WITH_MAX_POOL: False diff --git a/cfgs/res101_ls.yml b/cfgs/res101_ls.yml new file mode 100644 index 0000000..f0e5817 --- /dev/null +++ b/cfgs/res101_ls.yml @@ -0,0 +1,22 @@ +EXP_DIR: res101 +TRAIN: + HAS_RPN: True + BBOX_NORMALIZE_TARGETS_PRECOMPUTED: True + RPN_POSITIVE_OVERLAP: 0.7 + RPN_BATCHSIZE: 256 + PROPOSAL_METHOD: gt + BG_THRESH_LO: 0.0 + DISPLAY: 20 + BATCH_SIZE: 128 + WEIGHT_DECAY: 0.0001 + SCALES: [800] + DOUBLE_BIAS: False + LEARNING_RATE: 0.001 +TEST: + HAS_RPN: True + SCALES: [800] + MAX_SIZE: 1200 + RPN_POST_NMS_TOP_N: 1000 +POOLING_SIZE: 7 +POOLING_MODE: align +CROP_RESIZE_WITH_MAX_POOL: False diff --git a/cfgs/res50.yml b/cfgs/res50.yml new file mode 100644 index 0000000..8a311a6 --- /dev/null +++ b/cfgs/res50.yml @@ -0,0 +1,17 @@ +EXP_DIR: res50 +TRAIN: + HAS_RPN: True + # IMS_PER_BATCH: 1 + BBOX_NORMALIZE_TARGETS_PRECOMPUTED: True + RPN_POSITIVE_OVERLAP: 0.7 + RPN_BATCHSIZE: 256 + PROPOSAL_METHOD: gt + BG_THRESH_LO: 0.0 + DISPLAY: 20 + BATCH_SIZE: 128 + WEIGHT_DECAY: 0.0001 + DOUBLE_BIAS: False + SNAPSHOT_PREFIX: res50_faster_rcnn +TEST: + HAS_RPN: True +POOLING_MODE: align diff --git a/cfgs/res50_1.yml b/cfgs/res50_1.yml new file mode 100644 index 0000000..b1110aa --- /dev/null +++ b/cfgs/res50_1.yml @@ -0,0 +1,19 @@ +EXP_DIR: res50 +TRAIN: + HAS_RPN: True + # IMS_PER_BATCH: 1 + BBOX_NORMALIZE_TARGETS_PRECOMPUTED: True + RPN_POSITIVE_OVERLAP: 0.7 + RPN_BATCHSIZE: 256 + PROPOSAL_METHOD: gt + BG_THRESH_LO: 0.0 + DISPLAY: 20 + BATCH_SIZE: 128 + WEIGHT_DECAY: 0.0001 + DOUBLE_BIAS: False + SNAPSHOT_PREFIX: res50_faster_rcnn +TEST: + HAS_RPN: True +POOLING_MODE: align +train_categories: [2] +test_categories: [2] \ No newline at end of file diff --git a/cfgs/res50_2.yml b/cfgs/res50_2.yml new file mode 100644 index 0000000..b1110aa --- /dev/null +++ b/cfgs/res50_2.yml @@ -0,0 +1,19 @@ +EXP_DIR: res50 +TRAIN: + HAS_RPN: True + # IMS_PER_BATCH: 1 + BBOX_NORMALIZE_TARGETS_PRECOMPUTED: True + RPN_POSITIVE_OVERLAP: 0.7 + RPN_BATCHSIZE: 256 + PROPOSAL_METHOD: gt + BG_THRESH_LO: 0.0 + DISPLAY: 20 + BATCH_SIZE: 128 + WEIGHT_DECAY: 0.0001 + DOUBLE_BIAS: False + SNAPSHOT_PREFIX: res50_faster_rcnn +TEST: + HAS_RPN: True +POOLING_MODE: align +train_categories: [2] +test_categories: [2] \ No newline at end of file diff --git a/cfgs/res50_3.yml b/cfgs/res50_3.yml new file mode 100644 index 0000000..f6e282a --- /dev/null +++ b/cfgs/res50_3.yml @@ -0,0 +1,19 @@ +EXP_DIR: res50 +TRAIN: + HAS_RPN: True + # IMS_PER_BATCH: 1 + BBOX_NORMALIZE_TARGETS_PRECOMPUTED: True + RPN_POSITIVE_OVERLAP: 0.7 + RPN_BATCHSIZE: 256 + PROPOSAL_METHOD: gt + BG_THRESH_LO: 0.0 + DISPLAY: 20 + BATCH_SIZE: 128 + WEIGHT_DECAY: 0.0001 + DOUBLE_BIAS: False + SNAPSHOT_PREFIX: res50_faster_rcnn +TEST: + HAS_RPN: True +POOLING_MODE: align +train_categories: [3] +test_categories: [3] \ No newline at end of file diff --git a/cfgs/res50_4.yml b/cfgs/res50_4.yml new file mode 100644 index 0000000..a4c017a --- /dev/null +++ b/cfgs/res50_4.yml @@ -0,0 +1,19 @@ +EXP_DIR: res50 +TRAIN: + HAS_RPN: True + # IMS_PER_BATCH: 1 + BBOX_NORMALIZE_TARGETS_PRECOMPUTED: True + RPN_POSITIVE_OVERLAP: 0.7 + RPN_BATCHSIZE: 256 + PROPOSAL_METHOD: gt + BG_THRESH_LO: 0.0 + DISPLAY: 20 + BATCH_SIZE: 128 + WEIGHT_DECAY: 0.0001 + DOUBLE_BIAS: False + SNAPSHOT_PREFIX: res50_faster_rcnn +TEST: + HAS_RPN: True +POOLING_MODE: align +train_categories: [0] +test_categories: [0] \ No newline at end of file diff --git a/cfgs/res50_ls.yml b/cfgs/res50_ls.yml new file mode 100644 index 0000000..ed88806 --- /dev/null +++ b/cfgs/res50_ls.yml @@ -0,0 +1,18 @@ +EXP_DIR: res50 +TRAIN: + HAS_RPN: True + BBOX_NORMALIZE_TARGETS_PRECOMPUTED: True + RPN_POSITIVE_OVERLAP: 0.7 + RPN_BATCHSIZE: 256 + PROPOSAL_METHOD: gt + BG_THRESH_LO: 0.0 + DISPLAY: 20 + BATCH_SIZE: 256 + WEIGHT_DECAY: 0.0001 + DOUBLE_BIAS: False + LEARNING_RATE: 0.001 +TEST: + HAS_RPN: True +POOLING_SIZE: 7 +POOLING_MODE: align +CROP_RESIZE_WITH_MAX_POOL: False diff --git a/cfgs/vgg16.yml b/cfgs/vgg16.yml new file mode 100644 index 0000000..bf6df83 --- /dev/null +++ b/cfgs/vgg16.yml @@ -0,0 +1,14 @@ +EXP_DIR: vgg16 +TRAIN: + HAS_RPN: True + BBOX_NORMALIZE_TARGETS_PRECOMPUTED: True + RPN_POSITIVE_OVERLAP: 0.7 + RPN_BATCHSIZE: 256 + PROPOSAL_METHOD: gt + BG_THRESH_LO: 0.0 + BATCH_SIZE: 256 + LEARNING_RATE: 0.01 +TEST: + HAS_RPN: True +POOLING_MODE: align +CROP_RESIZE_WITH_MAX_POOL: False diff --git a/check_image.py b/check_image.py new file mode 100644 index 0000000..e49b151 --- /dev/null +++ b/check_image.py @@ -0,0 +1 @@ +import \ No newline at end of file diff --git a/cls_utils.py b/cls_utils.py new file mode 100644 index 0000000..fdd13c0 --- /dev/null +++ b/cls_utils.py @@ -0,0 +1,124 @@ +'''Some helper functions for PyTorch, including: + - get_mean_and_std: calculate the mean and std value of dataset. + - msr_init: net parameter initialization. + - progress_bar: progress bar mimic xlua.progress. +''' +import os +import sys +import time +import math + +import torch.nn as nn +import torch.nn.init as init + + +def get_mean_and_std(dataset): + '''Compute the mean and std value of dataset.''' + dataloader = torch.utils.data.DataLoader(dataset, batch_size=1, shuffle=True, num_workers=2) + mean = torch.zeros(3) + std = torch.zeros(3) + print('==> Computing mean and std..') + for inputs, targets in dataloader: + for i in range(3): + mean[i] += inputs[:,i,:,:].mean() + std[i] += inputs[:,i,:,:].std() + mean.div_(len(dataset)) + std.div_(len(dataset)) + return mean, std + +def init_params(net): + '''Init layer parameters.''' + for m in net.modules(): + if isinstance(m, nn.Conv2d): + init.kaiming_normal(m.weight, mode='fan_out') + if m.bias: + init.constant(m.bias, 0) + elif isinstance(m, nn.BatchNorm2d): + init.constant(m.weight, 1) + init.constant(m.bias, 0) + elif isinstance(m, nn.Linear): + init.normal(m.weight, std=1e-3) + if m.bias: + init.constant(m.bias, 0) + + +_, term_width = os.popen('stty size', 'r').read().split() +term_width = int(term_width) + +TOTAL_BAR_LENGTH = 65. +last_time = time.time() +begin_time = last_time +def progress_bar(current, total, msg=None): + global last_time, begin_time + if current == 0: + begin_time = time.time() # Reset for new bar. + + cur_len = int(TOTAL_BAR_LENGTH*current/total) + rest_len = int(TOTAL_BAR_LENGTH - cur_len) - 1 + + sys.stdout.write(' [') + for i in range(cur_len): + sys.stdout.write('=') + sys.stdout.write('>') + for i in range(rest_len): + sys.stdout.write('.') + sys.stdout.write(']') + + cur_time = time.time() + step_time = cur_time - last_time + last_time = cur_time + tot_time = cur_time - begin_time + + L = [] + L.append(' Step: %s' % format_time(step_time)) + L.append(' | Tot: %s' % format_time(tot_time)) + if msg: + L.append(' | ' + msg) + + msg = ''.join(L) + sys.stdout.write(msg) + for i in range(term_width-int(TOTAL_BAR_LENGTH)-len(msg)-3): + sys.stdout.write(' ') + + # Go back to the center of the bar. + for i in range(term_width-int(TOTAL_BAR_LENGTH/2)+2): + sys.stdout.write('\b') + sys.stdout.write(' %d/%d ' % (current+1, total)) + + if current < total-1: + sys.stdout.write('\r') + else: + sys.stdout.write('\n') + sys.stdout.flush() + +def format_time(seconds): + days = int(seconds / 3600/24) + seconds = seconds - days*3600*24 + hours = int(seconds / 3600) + seconds = seconds - hours*3600 + minutes = int(seconds / 60) + seconds = seconds - minutes*60 + secondsf = int(seconds) + seconds = seconds - secondsf + millis = int(seconds*1000) + + f = '' + i = 1 + if days > 0: + f += str(days) + 'D' + i += 1 + if hours > 0 and i <= 2: + f += str(hours) + 'h' + i += 1 + if minutes > 0 and i <= 2: + f += str(minutes) + 'm' + i += 1 + if secondsf > 0 and i <= 2: + f += str(secondsf) + 's' + i += 1 + if millis > 0 and i <= 2: + f += str(millis) + 'ms' + i += 1 + if f == '': + f = '0ms' + return f \ No newline at end of file diff --git a/coco_class_map.pkl b/coco_class_map.pkl new file mode 100644 index 0000000000000000000000000000000000000000..7b5aa1d65386c439957d912dc1296c58b3de5317 GIT binary patch literal 1292 zcmX|BXK$rC5Y49d?Y*%*+p@j)Ue4BUe2WbDf&~{dw#ii@J?Z`QH;khvgv9ijGiUgB z<{z5cz*M?EH8r)hm8rZgo$cFVYm4?_Upmj~PCIW~n#Odxz+z_doxIUBgPC-Oyr#oAERwIZ?&t`P#27oF zqc|!v>qd9g(9RPD<>sf{tH0g;S#F$C=Yj zqv$kFO9W>wGF8$UoRP}GXgZ6t;_Q19a>Y%a!#QytIpZ^}={(L$C%!hG5+o6-)=n5^ zp8NtXq$>k>opr${nQ9ukh>H?Zo1p0uE(zorCm*cr66i863vvEemW|!kbOl$04Zc=E z$NX1uHCF81C~B_ZTHLH|TjLYQBkMpL*bvTTHU#F_bzGNB6VvLXY?SwO12-bxeMdKO zQ#u@3SJN%r5_s#@Fr2q>J1(iS%-v0F#y!|cLw9f|)=(`!bQgEUQ*|9zyoY-cNCtUg zm>~CYU%V}otkm=X58|4f&2!rrdWeT&=QD6N&?7vGOR^yusPh<)C3|OfcNIOs6Ojtr z_JN+_sdSaATGKN;6H{LC#n5v+kCN@VhZlGu;CGCQE|TG%0=>jb0V2}{y}~PTC`>yL zJ*bRFd5zc7S+J&IXy4#XIz61yHoe7Lu{5gVW1)9=C&k9LXXd=edoeoA*R1ISKFGke z-ieF*h>x<9oJpBvTrandjRlI9quVkgOl ev-^$Tq8e~b3TL>1Kll^9tPNG>dSB7se)B(QYFN7f literal 0 HcmV?d00001 diff --git a/explore.ipynb b/explore.ipynb new file mode 100644 index 0000000..9fc94db --- /dev/null +++ b/explore.ipynb @@ -0,0 +1,629 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [], + "source": [ + "import pickle\n", + "import matplotlib.pyplot as plt\n", + "import os\n", + "import glob\n", + "\n", + "from matplotlib import patches\n", + "from scipy.misc import imread" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "d = pickle.load(open(\"query.pkl\", \"rb\"))" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dict_keys([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80])\n" + ] + } + ], + "source": [ + "print (d.keys())" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'boxes': [339.88, 22.16, 492.76, 321.89000000000004],\n", + " 'image_path': '/home/rajath/work/iisc/data/coco/images/train2017/000000391895.jpg'}" + ] + }, + "execution_count": 58, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "d[1][0]" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "def plot(data):\n", + " img = imread(data[\"image_path\"])\n", + " fig,ax = plt.subplots(1)\n", + " x1, y1, x2, y2 = data[\"boxes\"]\n", + " \n", + " # Display the image\n", + " ax.imshow(img)\n", + " \n", + " # Create a Rectangle patch\n", + " rect = patches.Rectangle((x1, y1), x2-x1, y2-y1,linewidth=1,edgecolor='r',facecolor='none')\n", + "\n", + " # Add the patch to the Axes\n", + " ax.add_patch(rect)\n", + " \n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'boxes': [229.32, 416.77, 293.64, 571.67], 'image_path': '/home/rajath/work/iisc/data/coco/images/train2017/000000483108.jpg'}\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/rajath/anaconda3/envs/onesod/lib/python3.6/site-packages/ipykernel_launcher.py:2: DeprecationWarning: `imread` is deprecated!\n", + "`imread` is deprecated in SciPy 1.0.0, and will be removed in 1.2.0.\n", + "Use ``imageio.imread`` instead.\n", + " \n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "{'boxes': [0.0, 158.21, 44.54, 207.69], 'image_path': '/home/rajath/work/iisc/data/coco/images/train2017/000000293802.jpg'}\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "{'boxes': [157.57, 149.9, 224.29, 187.76], 'image_path': '/home/rajath/work/iisc/data/coco/images/train2017/000000079841.jpg'}\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "{'boxes': [510.21, 153.91, 573.0, 189.89], 'image_path': '/home/rajath/work/iisc/data/coco/images/train2017/000000079841.jpg'}\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "{'boxes': [264.26, 169.29, 373.37, 418.78], 'image_path': '/home/rajath/work/iisc/data/coco/images/train2017/000000515289.jpg'}\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "{'boxes': [200.85, 144.49, 249.14999999999998, 312.28], 'image_path': '/home/rajath/work/iisc/data/coco/images/train2017/000000515289.jpg'}\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "{'boxes': [129.94, 110.24, 180.07999999999998, 257.14], 'image_path': '/home/rajath/work/iisc/data/coco/images/train2017/000000515289.jpg'}\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQEAAAD8CAYAAAB3lxGOAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nOzbV5Qc5b3v/W9VV+ccJucgaaRRQFkCBEhIIMDknE2ywWBg22CDjW0MtsEBMDbBYMACDCaaJECgCBJIaJQ1mtHkPD0znXN3dYX34n0vzlnvZq9zsX02a1mfu+q1nn765vdb/6eqS9B1nWOOOebfl/g//QOOOeaY/1nHSuCYY/7NHSuBY475N3esBI455t/csRI45ph/c8dK4Jhj/s39S0pAEIS1giB0CYLQKwjCPf+KPY455pj/HsJ/9/8EBEEwAN3AGmAUaAMu13W94791o2OOOea/xb9iElgC9Oq63q/rugy8Bpz7L9jnmGOO+W8g/Qu+swoY+V+uR4Gl/9UCk8mkWywWJIMBgyBhtprx2h0UCzJyUcbpciLni+TzWXRFQRNFbFY7sVgEQVJwOvzksxlkRUOSdAQkFFkgU4jjcTpQNI2iaCCXz5JTNQyaiBEVk0HCYrOTTqawWiV0CQTZgGQxEk8kcNrs2K0OioUMOgKKDlazlUwmjd3lJpqIoBZlPL4yhGIOt8dPcHIYdBENjYKioasqJS43osGIqhZRgZwsoyoqJqOEoqoYDSBZbQiqTlbOI4kGMrkcoggWyYjfW04qGUM0CmRyMqqmUOrxkc7mMIgqqDpmg4TJ7iKdTmM2WxA0DYvdQS6XxKSbwSyiSxJKQUHV0mgq5NNZbB4PgiwjiAZ0DdJKHskAxbxC0aAjKRqBimqcXg8H9+6luaWV4eEBcgWBhce1cOjgEapq6rGYTRw92s7s2XMwmSQOHjzInLnzSCXTSJKIUBhlaCKPVlSZ3tCMYBSIh8LougHJoCAanAgGDU1XkSQzkmigUMhjtTnI5xMYJBPRcAyPy0k6L2OxmTAIOsWiRiFfIF2MIWBAUaAgw6zmJuRijmQijiSa0XSwmCXGwmEUTaCm1IeqCJhNEiOhKcySji6KIGjk8xqSZMAu2iktd5NN5yioRTLZPGZJJCUXqPKXYTGaSRczjE9MgaDjcrrIFXKg6Qiijq4r6AhUlzSiFDLklRypdAa7zYNBVcipRbxON7JWoJCWsTksGExGspksqqohGEyYjQZEXUXXBBA1QskksqaiqxpoUOpz4Xb40HWdVCpEJCcj6jq6DjogmSWK+SKKqqNpmvCf5e9fUQL/RwRB+A7wHQCT0cjSBUvQRTsBr53ZVaVYJlJk7AJT0SlaK5pRlTwyYNYKSDYLFoOFyaiA1ashinEKCY18RsFhs2GpKGXqyD5k3YCvooaUrvLMjJmsttrw11Ry8wlL2HT3L3h553YS+XFszgCzy21gsZOKZNE8IlMxEdHo4JpZJxNPjpIupjn31HPpOtSDipcn332BP/7wemITMWRNpaVsAZPRKcKZBNs7v6LW58eY0Qh4HZTPLOXg7kMcjkTpn4oSECWO88+kblYAd3U1fX0TiJYiHd09rKivImV2c3JrA/lolKHEENN9rRwZ2UPBXkGDpYqdI500Bmby4B8e56H7vofXXM5goZcP1u9j2cxpeALl1PpVLGIti2Y0kjCOo+erKDH72T/wFocnof1QB+VLZjDNM5c3t21hZV0DNc4sCYtGXaCS8ZiFm797Ic2zRY7/7hfMqSnhmTfWs7jlWm69YS1P/uV9PtmwmZmLTmDbF+001kp0jI/yxksHuPz4DppW7OH2H97PxRd+m2tvvJm9H97JsrW/YXYZzGtYTKC0laJ4CFumFu8iGyMbJ5m1poXpTcuJjfdycKAdt6+EGWVzOdSZYe48nYGeYbTkfqCZydQEkqWUtvatRPMyXvJsnRqnxK0SHDNw85rTqG9cRqDazPoNj7Bi7tWs37ieLVOHkIIWLjylhh39GTL5DIqjyG9u+iNb3v0tY9Yk/b0Jcnlwlqlcd+INbN/4Dr3iILaMC0uZRK1u4skb/kQ6LzEu7ObxF55halLDbhNxlDoZH43hdlpIp1IUZJn7rz4To8FFTUkzg0OjOObk+ejVbsqqEjRVLOZgX4jZFUVqG1rYuecodTNW8+Env+KhB//B6089jJ4H/4JZfLj3r3Qe8YIcR0Tll1fcwGTRSKb7ECevPY1tH61nVAryzz2TuDwi5qIVVZfJKgnGxvNfm8V/RQmMATX/y3X1//fZ/0bX9WeBZwFcdodulMBgtRGKh8jXlaE5bExvqmBN7Qo6e7M4hRC5RAy7uRKr3080kcejDDAeF3Aa3QxOHWbNiZez6cNXaPBpTFoErlxxJm39I7TMrOeGMh/XLDyea7du4ua/P0prLEK5OIXVYiVDisRknqYZ1UyqMprVRGooT3WFhZHiGFI0zJ7xHPt612H0OxlVZVYvnc9Ar8Y7Xx3h7Nk17Am3k/GKbGvbywUr57Du3Y9wODxU6CV8W6unzD8b0TfO0NRXzGqdy6Ghg3y2a4Jm1xjTmi280jbBrICftkQRuynIkQEnm0cPEB9VCY10cuaapZSGVEx1Ome0ziRhncahYJg5i+bgN9up6BI44du19AymaVm6gC17NqOJFvR8KelYjq2TW3nvnU18+MdPWZU6RPecRt5Y9x5LrpjHSYvuJdxzgOaGJfSGRsjFZU5cFODDD3Zxx4JVlFk7WbrkcorDMqbip7zy6mEQRXJqmsp0lo6hXty2ALMqF2Enyeq2Xnb8+T0iIxY0s4gvb0ByqGS0EGHBzoBxLs2+UfYeElnW7CcdlEmVDNG1z0g+YUAQJqm0uon0qmSn60yMHqBt63ryaQG/p0DjqR7atg8STW/juusu4Pd/fp45KxdREk2gZHP4XXmyTpUnX/45p82/BlfiRCIjw8TJIKaiXHL2VahGGW14N/3joxjMkMtLLL9wGc+/9BaCSUeQTQzki/z6g1e4+6Im9rzcj8uWQ8uaCAVl3E0WXnnpLuaWrCESS6BKZuZPr6dtYByr3YLdYSWVTHLKgquI5u201Fayt6cXt8PNsy8eIDb+Ke9+UcOPv9dAaa2PcDiNR08xo64UwdXHbTfezeH9OzC5HZR/q5FnHnkWgy/HktlGvtgvMKtkOqmRGIcMMU5cPo2egpt9Y5Msm38xy0t/xxeTTlxqgTwZqip9jAfHvzaw/4p7Am3ANEEQGgRBMAGXAe//lysMRgoFM0ohS1N5M12HjxCOTDEyOM661zcQGx/kQFsPDnMZZrub9qFJ3tn2N/bFY9Q2N/P5kd0sP66Vx99+gvLaBmY3n8j+I1+ys+Mr9PEQS1avwR0o5aFPNvDeSafz7ZkrGIoMYLBMx+YzoqRzGAN17OvvIBqKw2gcNV3gSFuct9oO07LiPO69+0cYbDb6Bgc5f1olMyvKmEy3o1jCDCSKHLdoGhPDw6jmMK9v+YwMCpohyVTnGOG4giBkMXkbETQrg8FO7DYnLn+eo6PDfHhgjMVlOstPmscVTTNpqXWyO9GLHoug5Av4a2T279mP2efCafZyMBJnwjDFj24+ja1vv4dm8XHcSRdyIBjjkjtvor/jKCdOr2TlompimT5qrQZumLOIP1x9Ovf/8Xxe3/4Wh/f3cerZl9DWEcScCBMpREj7dabGgyxYuAjdplCIh9jY1cTLr7/Gp588wKefHaF3TCcnB5lh9uBzVzEYidBz8ABOnwUI8cLWz3jupdf4j5/dwLYtz3PHVaex74tr+ONDL2C3OphdW4M29DIN08+irCzHeKKLkd4jxIdEdCGG266zb3Mbo7EEWVOGgQP7eXfbB/zgscdYffZJ3PHQI6xYcTEz6zO4/UWG9gxzxalnMb9yLopiwKkViMgiH6z/CLOryKPvvgRSBn9JKf1TU0yMgQeJaf56UqkUVsXE6uVrWb26iRZLPUf3Z/nrnfdhMhdxpUyYi2N0TKU4Y+VKZsyooCpQirfSi1qIcsvtz3E0243La8EtyuwNe3BZFEySleDYBCaLgZPmncLm7W28+NbHdI99wXtfrGfL529zyXW/5Gc3X0YxrWGJdCGYrYieeaxvH+DxlzZw5V33cuDLLkanJnjisccYGEsxOqzy4bZRkrE4y1d8m8FiiuTACG+9/hY7935I66Kl6OIIM5ZdSH2ZiaxjCk2SmUzICMJ/ehIA/gUloOu6AtwGfAJ0Am/oun7kv1ojoKHpOYpiHlGKkMwWWLpqDe3DI2CSUY0G2kOdvPTRi6y88Gq+2LuF/niKvr79vLDjSW694TJCuZnISoIFZ15H6WIXBrvAG4cOEXebcFf5WFs7i2cuvhrVYuPq1WcwHJsknWznxguuZ0ix0hEcIm124qvRSeQLmB1+ZixvwpFO8+sX1vHwXx/i6MB+3nrkAaaZG4hgZH/HOEvLq/nuJat49u3nyVuilGHBkNL4/X2/whe38+b77+O22Fl43CzaOz7klPmVnFC1ELtJIh4UOPOM5VizUQ6PhmnfsZfNyQm+GMjjTGRZfeqZqIYc9936H3Rl4+SLKiE9y/jBDrZ8ugXFZMTknUtioJ1r7riaHV3tbNvczZyLb6Q7mGTzp4dRYhoTUROO2vO54Lo/8Ju7H+Lqa+7hzOVnEptKsHReE3ElyrTGVoKHutCVNFNDvZgFgbPOO4OjH7xJKpVj9944h3dvZ8EJZ/DmJ2GOZtppHxvhs45+brjyIroHejl+2Q/47c3f4/jTq9iwaRNvffIVsruZx98+wMbtaaoD5Ww8MMLO4QxHBrby3Cvr6Z4K8sGBbdx00+UsW7KAjs5DVJ+yhApXCd3DPYj5ES47rZFbr3iAiqZW/uPuZ7j/wXUU9Rl8a9bFVMyazcLFi8jbzYhKkKRkwBaD81adz2UXPc4Dt1yPqidRvXmC4XEkKqiuaeSF998jXwwQIU8wN8V3fnI7+8d1Tr/gFG57/m+IVhXJouM0waED3Rzatp0v9vdysGeSTFrmwp89yb0P30p9/TKSQZWxQhrGg+RVCTQZq82AxWzgkZcfxhaIcDDVxbZPv2TN8Sey/e0vkAtTiMUQldXTuejuh9h2+GN+/Og97OxqY0rrwVaj0mfey/apPgbGEuRJMTqeJqHL1NqsuM3dWM3/b+ksbD6Vtm0fsWTWXBbMaUKadHD+gjmImoNMRsQoFVBV9evz9014ldjtdOszZ7ZQYi/n7a3vcd3pF4KpwMGjm1lYt4C5C07l719+hDRlxF+pYLXb2NsRZMX0UvaFe5keKCfgtXDnd++gbcNWXtj4OemCSlFKYVd9fN7WRiheJJVL4DE6GcmGuOSMZdx92VWknS34pw5w99+fw4mXjK4yp6WSgf4o00pUSppb2bWrA01IsrB1JZedcy7GfIS9kzHWvf8W7zz0EJG+GHt72vlg1yeYLXZEsUCts5798T7IVvDmoz9i955hIslD/PGF9yhp9DARDKIXjLg9FqzhNPNbpvFKdw/lZie1Jolxr0qDrwYpPckJvlp+/cVX+C0efnretTy9/ilKm1rx2Sz4y0soq5rBX5/5C/MWLSA1PsZ3z13Brv5xtn2xhyuuvowNn+3A5SlSbTuJUxbUER6w8/7GdSw/5TSs5UYa8iq2lpWYbSLhve9S3jyXcCKGQ4RAy0xSkcN8/5ePMjCeBYOMNadjpYqc1YnPWENKSJESDyIppUhOF3YxQVPNHKafuZaPn3mGCu8UaTmPJCkYRAuZZI7X/vIP2re9xyvtz3NF/Q8xBgTCmoEDX37C+eeexaFQnPau3dTl61iwaAYvvvIGdT6R0aMS5/9wGfqEkRkLlxAOh8lKBqqsArc/9SsMWp5wqMjcwDRKm5czMvo+Fzes5NmDO5hMDHPnmT9lUt3Fro5xpmKTzG6pIilrDHaHyWqT2ONuTAGJ6aUZjuTBkrASzApMq1pAamADN3z7bp768GU0JU4mm6fWIJJyBhgfn8Lh9+ISHeSIYRIFCnKKQt7IwpOOxyX58JfOxChkWXXGGXyy5VMObN2IyS6QRCAy1ksqpqAlVYxmiaVLfAwETQyHI7gtBnJKnkRSYPmyCha3XEJFMYel3MvezzaSkZzMmz6HxoCZ3Ru+pGpVCdv3hBkd70bDzXisl3A0Ty6v/qfjgOH+++//vxz5/7+Hf/u7++sC1eRMBpadcAbvvPsKDquFZE6n3F/GvFlrWf/563j9NlRBIpNOYHdJjAz2Y7LZGRnqwWYw8+mHHzMp+pAzRkLJboyalbRepLRlBR67j4DfhWpMctf3b0cLB+kYi5OOBTnr/NP5/tXX8MI7b1FS1sTE+DAmqxVriY+2/YMEvHYeeOAO/v7CRlxWP2ddsIb1H32KHp7g0iuvpqCLDPXupm8qTiSbIJqOEi/qjHZH8dpldoZFDo7b2dOhU9Myk/G+vdglAaHEjhy2YTQ6MdCKIMTIZyPERBGP3UqZw8bShSsQ8TAc6kUt2li6uBH3tAYEg4JGjlPOvIrPdmzAY7PQ1XUESbNy2qqrGJkYpn28m3h+inwqSiYJC+r81FTMZM/enSyc48dtgCWLWsmHC2zZ+gRGUwpViTM2rtHXcZT6aaWIshUkE2993ks01MXpyxeSlrMEZlXxnSU6rdU5mr0iNc1VTA94sDNJ/2SIsd4j2HQNrzlOKBND0RQcLjfpWAqDReDlV1+isfZSFi9ZQ1mLmb+9+A8+797NeEhl467tRLq+ZFVtM6+2b6ZntJ8m5yxixjIaj3NTbphNzUzIFBQ0EvR2t2N2WgjFRpmYMJDR4cYLT+GTjvdITFVwy72X8NHGj4glDHz/+7fxj/VbGEuOcOPKlSTEEMlomGCsQHXVCs5f08CnvWM8//Nf8sqGz5B1HVEQSGQi2GqdfLinDaMhhhq18/g9T3DFBWex4cstJAsSRV1Gl3SKRRmPyYtqk5HMASY7BgnHxtny8QaGBw5xYNOnCGKOVDZOKJZnIDjMLWd8h1/8cA2xdCdJyY1TMjAcDKMbIDYZx0YRkygwMBEiPTVFxYIlFHWRhvoGGgOVpMaO0Ns3zHHLz6ZnIEZ/og2jTSSZlcirWbLZAvfd94tf/mf5+x97OvC/0TREp5VKycyLjz+IZFIpmPK4ausJ5sd4btNPKRSK5JUYNquXZCJPVs+S0EX8MQlDsZyJsErckCUdHqXUm8VUsCMm8nhdVXz+3ic80vkr0qk4yVQYnznEyctXk4rlQTIQKC9Fl1zoMZXpx+kMpR3IFhElpmEuJnn5+df56W33cf5FrXz6ySesPX8VH23bTJXZz+iwwqsbN9E52Ek0FcZnsLPlyz6WnLAYp9dIy/Ib6Oh6C13qR6eIqVBKSqzCZAvj0C2MWEZI4WEg9k9+eOqlTJ/l57oHn8ZvtRExJjAHfJAOc+XVl4LRwAsff0kmOMHpK08mbith5+f76e7soLTEiSaYuOTqS/jzP/9KIRuhpbQWU9HDD6+6mOc/+Iglx30Ljz9FdXkas93FZGiSnq+6KJlmY46yjFK7n4miHxGNWUsXYClxcqg/watvPc7AYCfg4IOdB/DbPUixBA92DfHQBWt5+uMPEL3TkZVxaiurEO0WMnmd3oFxBMMQRVnHqBfIG03Ma51HTE6SK8vzed/vyO7XKcSNZOUId1x1A16vD4/XTyiYZcGqRfzx/VUINeXs6t9PzBxj3ml3smfjFxztTLNvuJ1rL7uNadWz6O3dwUBfH8baUrRBjQ8/30VAdLH65lP5w1+fIJROI5gyPPz87cR0AUu6yGQsSDabIzVpYlGFlyPxLvYnq7DEZd7dsJ1mu5U4RlLRPJq9SFVJOcHcCNKEn+cffQhHQwVEI+QMRkQ5hibr2N0B8pJKWE7gNft58IHHMOQLhEP7qCg5D4slxGPrnuXo4GE0VULOZbjxlAu5++Ef8O0rT2R4MgspgcNTGTBIFLM51p52Hk/85F4+ePNddu9dx7tdQ/zuT4/w4HeuJ0klB0aOMnt6PWeuOpu2T9/EXu7kJyf/nCfe/A057yS5rANIf238vhnvDmg6uUSKXMBCMZPDb6lGle3UGi24fWVUl82jxO0kUcgzNDlJ4/QGNItO6x0llFxkpHiiRKHOTWngZGS9SDjtpsJWx4xFi0jkZSZTE5hNDkTdgOatw6QpRMYzDCYzqKoVm7sBV6CSy686jQ27hrjshltQ4ibc5VZKyhzEQ0lKK91ceel1DA92c9t9t1JZYuOaa1bxt3V/YMeXnxCKh8lMpLnn2kt4+Hd/QkQnYfDQ1raRQroUISmTCalEQykqAx6q6s9hPJgjHxOhkKTG7EMx+TEaW6m2ygQjkxTyIdp2dxMuTjE1HuGZR/5BdU0ZkaiMrcSDyyDwwetPk8uEOef071Egz8mrz+ZXf/odn39xmN889QQXXnkSAvOprayiv7OPT3fuQvfWMHfhCqa1NJE2pwgNQdOc46lzOmmdWYmn3E7BZuSz9v08+syDfHXkIKh26kxgEnNo4iRdkWE8xQqe77aRcdaRDPUix40c7RtCz+gY5SShkQNUeOzUN1RgLfETMhhoP9LNQGcXQx39hPoypKbMuCwO7rz6JjDbqG2exc4DndTNa2B32yGcRg+TwTTjmQRKVmDdX3/BnOVVnLB6LRedei1NLbPJpQw0Tz8dq8mDJZnD77TSH+xHNyVZPuNyQqkg+aLIrNJZVNjskFb43rXXcGhyCKtvJounz+SiVUsoZsN88dERfFYTt933JM8/dj/G2CQT6QyiYkIuhDGlRQKlTUQ1G0pa4sMtG5AREWx2rP4AulbEqEoYBBdmk0Z/32Em4w4KqsTY2Dts+mI7e/sOMhTMkIupbPr8EMvOPJdLVtUznlIZSxsJJZPYiiIxpUC55OaWteez559bkLJZSsqWsXiGHZtS5NVtm+nrP4jdbmMqOMH2XfsoOmYwHg/yxDtPobokIpNFPBYFXde+Nn7fiBIQjAYMVhNiRkEWYhSLI2RVjYLBSMFgJjOZwOmyUZBKMBTzHOrrpH5hKXlvE7aWU1hz/rk0XX4mTTdU0d05hV6cZFJNE4qkkYwp5IIORRVdFqnIxPBVtBIqhMllElRYBSKTU8TG+li25AScVvh4w3pkJUPHSJBAoJz6WfNxlEzH4qnhqWeeZWpggmQiytOvv8NQZISy6lKyGScNi1ooDUzjy6/eo6AYcORD6IqRfDLNyNQEk/EBxkb6SKdFOg7tZE6zGatNRJIkDJKJzT0f86u//xZzoAaD2cLwqMbk5H6OjCUpt5ZSUSsS7OzF71TZ9NFGHC4bP/zZQ9RXnMzqM1p5+bMxLrziKhpbjqNjMMm8OUu44Lwfsuy200noMH/tQorpJO293bz/yUaGghli6TxNy2dgqfIQFK1s+mI7U6LIk888SWu1ld/d/RME2YiZKFvX3UuTCoWkiwpVZponwu9XmNFj3ShGDVEPoxuLXLnCTVW5HVXVSMZT2CQrklKk2imSluMUDA4qPVV0j8V58Jd3sea4Jv7ZnmDJrDoGB4+ycN5c0vEscypriYpxEB34jSJitsCHG4bw1c6j/rjZyCYbI8EprCVmBLsVi9mOJnhIJTJE02lGx3MMDG8mP2HEV2LjvOuuZEopZTARYfXFFzOtvp7Bzm4uueYCKpqX8fBN1zG7tYQJR5LXXnyRYKyBn/7mPwh4zZRaDQyH7Sxd2Ejz3DLSygB//3AdW3oHKBd18vEMmVgMp0MiL6TRhDjRlMzZay9h/sw8NksJXw0G+bzrEyxEuHLFJbzy6qs88cs7eXLd3QzKAaJJA3pOoigYiJp1frj2StbOuYBkOkHcnGMgl+Hqa+/j5ose4pZbz6JSHuPtbf9k645/8vHmTTz59L38/a1f8/FnW9h5oJ17Lr6XR2/+NWTTKF9/X/CbcRwQdIFkPI1FMjJ/zQVMHtrE4ZgJi8WILmhoLpDyJsrsGla7ldGxPGFrkePdc2l0zcCFTvvIDsZSaRqqLVRUtRDu6CGYDSMoAsWcjiIJFIo5XGUWGppnUIhPYommmVPpxVVaitdaSveEjkcUGO0dwGLW6A4VEItOrrrsVAoFgT03vo6atNHUWsfgwCSZnJEKn0oxEsWUGSc+KfKDRx5As5eSLY5TdE/HIERJKylQZCTMyEqckbEk/kA5aUXH47JjsptRkwVykQy33nQLz778EvG4AcluRJFNDOcSDO1ZT8vsZfhNedZvDeGxmolmjATb21hyxmoO2eqIhkPs7uqkGJng4RtX8ty2o0wc6efON57jwZ/+jffX/YSe4SByZIpC7TRKWpsQcaFbREBmXCjy0scb+NUtPp58/GFGOgeJmvNYkCl3S0S0ct77y5sYTGNkQyNMaA7MkTjP3/QtghNhZk2bxoyTTqK7Z4AlTe3c8cJnaAYTsYkMk5MF7E6VVKqAxW4klE7y7rrXmddip6dzDovHDtKTNjJ7/lJ62rsw2CSSBp0ywYndAv15mROPP54P1j3D0b7D9Pc1U1buIpGcwBWwYbc4MVodDB7tpbbMS84sIktGsqjkhTwjfZNs+uxTugcHuf/me9i9eT3uCg83L7gNo12kZkYT+e1xqtQkI4qRdf98Ei1+I9NaqzFiZTwZxSSaSOuV/OSOW/jqy618/NE2Sqr9BHMqbm8pJaUeMrkpzIIflx16B1JIFh1r6TJWN57Fn1+cTSSfxKIu4OafXMqVV12OzyFRlMxoeZGh8WFEyY4uK/zt999hx0dZgtkw41kDC1vnoEsR2trbUIO9uHIurrjyDs7ojzBr1oksOm0pH7z/FGaTj56jGebP99K290tOW3k5L6z7M0vOuOlr8/eNmASKapFSn4eqqmrSvR288+HHyGoGTDAyHkE2mIimMpgEI7Fxhdrmudjq/ZTuP0J6xwY6BtLsCw2RLo5x/SXXMzQxSD4hk8+p2P0u4pkMxnwR2QzZfAZvoImK8hmMhVW+GJ7kgrNu4a4fn0lucjvfvukWZEOBVLHAmfMbScQmieSL3PG9H3LXjbdz9XcvIZXQuPLck5GzIRKqiZFQFL+ngRllLr5//mUYyGBxNuE1VhEa7Oecah8PrDiOF89axJ/WLGS5X0KOjkI+RzZfwCtIpBUVu8PL/b94Ej4BJYIAACAASURBVItZxW4uomhxwqkUZVYTaxefytaNG9l7OMIFp5+KWgjR07mf4xevZM/ugywOlDG/tYbnH3oTu6OC6uPXMnA4R66qmYu+dx9PfLqB5jNuZEqwUDAa+NE9P2LW7HlEswK72vv45b0/4p1//pVf3PYL/JUnoqQU2rt7WP/6+8yf3shN37+byZEjdB7ayOvrXke3N+Erq0FzldI4dyHdoxFyLg8de3vRFB27KJPVcgQCFhQ5hUHOUYyn8bmcGPUizfUziCbHSGnVXH7V2cxZthy/VaS3p5t4poiaSjMVDJOXFAZG+lEcIl6bl+Ur5nHuWedQyMbQFDNV0xtRjC7+9vYbGOwSddXljKVjZOQsOTVNtUNnopjF7PQQTeRxGbOcvfYSdnYdQci4aJ3ppaymiYGhQQIzl3PxZbeSzimYDQXa+nfy+788iN0tUbRKGOw2suEM9/z817zwwnOEsyk8hjjZQhIKCTJyGl3RMVBAVhQSeY2RiUEmxnqZdZyTeEpmaijNTbdfyc23fxu7z0c0pdPTOchYZBxV1ZjsauPTdz+lquEETrt4Cfc/ehdeaxLJptG6cC3NMwK0nHEqMxa2IOkSnhmzefbAa9xxz22EJowcORqhLzxE264gNT4fwaxE04KLkfj6UeAbMQmIiBTTChOFCZZozTx03Z38dGqCzOgQhVSMsJLAaTdhlETqm6YTCR5F1ANccPxfECwiRpOA0bmcfERlf/8BCgkVT1kaNe9iQetyxsIykyM5iOUwBCwk00mYGCE50kN7rp3Pd25nciTL088+wY033sizTz2N0WRGN5lZuaKVwx09DI4EWbl8Bm+/+BxyLo6negkLW4c4crid889cyWBOJ2DVOBKVMQbmI08N8dL1F+DxXU6s8wg9u9rwTW/gtXcPc9mJK/jTho2kFJVMViGXljHoGorJj9k1zmjIBChIJj+FRB6n2U5oKoyuWyjKcZ59bTvnnXUKxUyE0666FCdTqKEcX2Xj7NnyB3rOW8Sll/+Ba773C8667wJGBwvcdc6pZAseLj7nIn7xm/t4+IkXsFg0EhNDdHX0sHbVOVicKnPn19M+2M+iiuPQ/A4K+VFyFoW3X3yH2ssXYjQL5Jwm9vf00f7ZTrKKg97UAPPmNrN142cYBZGm1mYEz0xEaQMZGSSLhDlgxes3M9wfo6y+jIsv/Q6LliynmI+h6VaWnXQu+9t24rTYMFXYKOYiaHqOXC6H6ApQyKg88cjTvPHaMwRcLubNnoOsiiQjCZ594TGe/sOfePSp3xIdzWA1Slh1GxmbHd2oIsYtmB0ymXSSwck8qfwE/aMRDu3cQEvNPBbaj6Pjy51Y/G6cPjfnLJzLW3sGMTl2UN5Uw4HPR2l0WxgKRdBVAcmsEc4UcRqSDKbNlBm9BKUIZXYL2bhMMDpJaZWb1ll2HvnjTgYH38Li8pOI55kzp4nnn/sdfoefzoF+0vECFouBU+ct5OILz+eNVz/A4SpBkDOU+wJsf+c9GqbNxeTyo9qsEEvw8Ueb+NH37mHvl6/ybtcQRtGEr9FHf7aX6c0KNa2VdAykqZ+/mMRUgpGpPDa7/b/I3zeAhkbBkEIIgV00UrfiBOyKgEnSMRlAyBUwIVKQNcZJksoaiWhZdJOGySSjCTqqaCFhMDEaL+D3uTGbTMxorSOaLnK0/ygD+QhFhwmzYERIFdl58CBef4AHbvktY3ELVpvAitNO4fGnn8Vg0SkoBQbHQsyZXo+SL/LkS4+T13W279qHpmns2LeekgoXot3J0GQWQS0QMy7n/aNBJiaGGe/rYP6CpRSHkhjtDbSsWIvBXM9lK09g2dIF5EwWFKUUiySAUcHmNvHyC88xt7GMREhmVkMlkqxQNFjYuWcvu7v2YZeMSIIZl5Rj57bNBIfjdBycoHbBFTjtIvaJGDe/thWjNUBX5CD+teU88/InPHDOPE46cQ3LpplYu+Y8Tmqto23TRrq6uhANrTTOW4WxsoHa5kbe3PwV7QcGeGP9VsIDKcprq6mpOw1/rYui2YlqtLDvQB/jw1G8Thuz68tZ3NrKwGiEbpMPa1mARF7m6XX/4ITGUnxWEcmkoqo6xbSCLhlJZvJUujQ+27YFVTKhaE4M5izNdRUYjHnS6SncNhtGYw7J5kLASMDtZ8OGDXgC9ahYcZc08dDjf0ITZH55z+/RrX6splJSikBB1bCICo7sJOs/+IyElkXOKwyNTzK8f4xHnnwIu8vG408+RV4D0eYiL+VxGEsxG2ycvOpCHCmFlOAiGk5iJkNlrQtT3klRSKLmChiyOrfffDv1BjehbIJCTqBQyKG6BSpL3TgdPswSHBl+kmQ4jCJnWXFiC7KSp38ix4EjXcg5BavFyIevvMMFF36bljlz8XlLMQt5vKW1+EsrmD1/Dq2Lq4nFcqRCURLRNN+/88d88N4r7D48TiwyiMNeRanHw6r62eS6HDSXzmFkMMSrmzpQPW4sgMVo/tr8fTNKQNOw2Dy4PRZsTgd/2riLRsWASZUpCYCzykPRJGPRkohxCw3ldlrcc9DNCqJDw+qUEFCQ41n8Bh9GSUNXLUwG41TU+rGYplFlCuAxSUhmC5t3b8CUHuTeB+/FU1FKCV5ef/1Fmhrr+HzvPiIJHTkp43M7ERxefGUeKqtKcEhWNF3GZLAy0jdOMqQj5ZLMOG4VilLG4PhRlNAE0ckQPleAaHaCKApb3niSbM6Ky1nC4FiEbbvbGBwN4rB6MAsGipoRNZPmvQ+3cTAs4vcbUUQZXbSjigWMRjN2PEiZPKoxi2oSaJ5TTqlF5+0HrmXrU9dw5Q0LePSOy7j6gqd4Y0MfXyYXsnbFpdxx2kl4yu1sfvkBOiemONIzQigF05ZezpJFl5DXNCwmN/Fwhq7BLPOWzGf1WcuZefwilk2rZ11rK+WhPtqDVnbvGiOTj3Hx6SeztrWRppJqKl0BFrnLWDOnjnP8DlKKSl2lj15bOR1DJfxlxVLSuoVak4RBtOBTJVw5KweCUUoCVv7x5nqO7P6IXVv246xsZdqi1SxZ/C0C02dRVlpLtihQTCskk0Hue+RnOG0WHnvuT4Rj/Vx03rn4S73oooHejiMc6toFZjMNtXUUDNA/kuXLvUcwqgKS1Q2FNM//7TFCsRSHd+9nYGSU8iY/E0NdLFp6Coc62jjceRTVZ+e4ZSLBEYV81k5FlY9EUcPjByUBubyCzRtA1KzEjQL1ZRbsJqipcOEWVCaTKtnwFOGpFKIuEg6luOuWC5gYCxMaKGLWFQRJJ5dV+PGN3+HjP76I4Gzl/X9sxqDKKLEUemKCqbSBVEGnff8oWiaMqKh4Syz8870XCAFqhY2bbrqcn/zoDpYsX4WvpZYlZ55B59AwXoeLsYFBov0dxDNxvBVVX5u/b8RxQJKMuO0erF4b/iqRi2asYtOGzQiFQwgWKxNRA4m0gFEyIphyBMoNCGEbykKB0ZjAwX1H2LGjA8GWoqbERjYXpyhKOM0GDh8exSSmSSZDIBZobhXJ7cpx00+fIzxapGa2C9UUwmyyUTBbsGZ17JoZX0M5ipqhun4Ws+eM0dfZxc333INYFMkZMvjFUoySD9eCs/ly7zClJQ5Cw31kskVy2RSCpHDx9bdw+3VrORKFutxBDn6VIZuPMa3+FKyurUQyGv660zGYO5GHrDz9+98gCCkkTwmK1IDFMYA1byBdNNA1PkJtuRWDwYlZTGNKFVnZMoPyhY2888Zr+CNOqnwCPYXf8syvH8VjLRBJpXBVVvLy76ez6oRVWMp78Jk0nP5ZuN0qodgop5w4A7u9hM7efsaGo+zSDmIyi/zt7/+g2lvO742lyLEouaTEs23D/KnxBKrrS4lIUbqzRwkOJlh5/EoqpVJ6TSnEI0Gu/8PHlJWZGSnGOeONOj44cTGvfP4Fb5eBmjCSzSXoGh4gMRlj2cIagnEBp5Tl863vUtcwB7spQ2f7GPF4Oz6vmZGIglk3cus113L3g3ex9tRTGBkZw2t1YTU5ENI6sq6SkzMUZTPh0CQGRaekoZSCksdg0YlnJvj+9T/AXWpG0NKcfdHV2GWRfTu+5JRVJ5OJpll54kpySp6CpnPdpbfR+9iTjITHEAsaoUgev9OF0WIkks6jKCFe37EVg8VEPGfEZLHSPzKJgI7NpJNVoYiFFXWL2JNr54V3PqMYLmD2mjEVNJJJePKBhznzisvobu/H7tYwR7xs3b6DM868gHAkSHDj81S2noCqyfi9fhRFoa68gWwshK+ihvY929mzdRetl8+mzOUnpZtR0Fm07AyWLDHi8nrY8/GrGHNGCvmvf0T4jSgBRZFRFZmy8kZ81QsQSyu48Zrv4C77Lr/5+fWMjI3jtBkRVBnJUsqAFuW6+sWEu6N8+ddt7JRUVq9uoa+vj4lECI8jC2EnXUODVJfWoshFTE4XiUSKxOQINmczot/LJy89w0ebjLzx9F8QRqfY3T2Alimi2/IkhxJY5pt4/JGnaG5pIJtRKbU4Sbis2NQAvqYKMmkXNjnC1EgfqQkT9rJS5PAISiGJ2RGgbaQPRRa46OwTmGrvISGqRC1mHnjwQcxuD8VEgoFCisbyVry+BLHMV2SLJoqhQaYtOhHFECI5ruFQJXITKmG7hdaMTHsGSOYoGrz0d7Qx86QrmacqmLUCoVCIkZYIFfUtjI728v6eAQxiO+l0iPG9Jt7s6OGyS+6hIJUTS/TQ15/EVaKhCVBa62VqKITXFiIXitCVBb+nwJXfOo1YWmPdW+t4b0Dg8gY7JXaRpSetRVFENEFkvK+dtqPDHBrPYLBYGUjUQGEYQ4XGpR0xfLUn8Mul07iz5zcYDHb62oOcd+tinLYA77z/V1ob61i25gwefOAeHnzgOfa2vcie7sPIBQ2fwYfuLfL2hvdZtvQEplXPRbRKmHULsXiO5OhhHOW1TKVMlDkFxmMaMxr9qJjpHBnAqNuR4zI+Mc8HH7xJIpNjXoUf1VVJpUXEYTfTd2SIU89cw/69Byhx+rjnd99HzYoIgoDokqgtrWBqIohNAJPFgreogpIgEi0Q6x9D8lbgEZ3opiTZnE62AKFQlB/c8j2uuut75OIailegWAijCHlcZadyYGiAt6+/g/lLjsNplCg3FHCXl/D+63+gN2lBd1dzSUuebDrNSDROc0UdqUgMiWa27tpFiRhg4fz5xJMaTS2tJAt5JElCF0BHQtNznHLNjRSUIsVs/Gvz940oAYNoQBBgKjhMxN5EcjiJrEZxBT3cdOc6zrl8CWVmGynFQIXfQlCQqKibRef6PiqNSWblHFRZDHwVmmDl/Onsj7tojxQpL3WCQcbusDIeSyMaHeQSUebUlzOzJMB+HWKKwvav9pLzWakuxtDsBQTZiOqE0GQeo5xjln0+vYLO4bEBzPZycqYkOfUk8rEoulpAyaUIKWmyaKSTISSzEYNswGzx8elXPVyxYinV012oapJfPfsiJpuEwSKiW0Wc+QIFeRBrWSUWvZb0yAS17iriWQldkzBbNGyAXmmDZIYePcO85moK1aP0ZcbZ3zVJlfNDzrv9borjGvbABGWCgCmt42x2MrNuOve8somx4RQttbUc0IzEomk0ywg2k4FUykAho9LTOYzZaOHPz/2C0TEDjz3v5vxvXc6zLzzHzT/4J7u++gmSwcThfXs4fGQPldYM08qacZhk+qfStA13Y/I0EZ4aRlRt7Dn0LEsXXk/n52/h89YSdFdw16HPmbbwHCYmdtPQugLZPY2CmOWSay/jq893Ewx2Mh4Oc+V/3Mavbvs2+/sPMplKUV9lw+MMcMGp5+ExWtGdIoWsir/KTGgkSPPCRUxFBzh+YT3t7SGsThO5rIjRBloSZGJc/a3zOO28c/l41240TUE1m3HqacrntnKwawBXo5OX33yFqfERvnvF+QiyBckmoskyZsFALpzknut+zDOvvUx6IoNcYqc+UMPY4Fd4S1xkySKIVoqagWwEnHV2ptUex2133kI2DU5rkZ7+JHbRzbbDo1jLPPR98iYl1kN05wcJ7T6CXFApMQYw1XqpkMKY5Ribd+9HEoo4RBG31UpxKE6+aMRjszESztHsDFBaV040kUQyGVHQ0HQoxo8SjpdTWePD5tMxWZ1fm79vRAlouo5qNCAXVCSbBXOhiMtXQjwcZtfhFL//2TP89pEfIOoqyeQU005ewqym43myTOVUbZC66nLmzJvOmy+/R1dyG2EhTo21FFESMdqcxFNJhFQSoy5jMWncOn8a4niQ25ZNQ7ZK7PziFWoCDRgtTSgFDSuQRaW52s2mTR387q67KKbGqawuw+dQyUkncHT/Lkz+MoqxKAbJgTmvEQt2YXbYyGVzBBpKyXVH2bJnHwcOHEATi0xqdtwWE2lFIZ/N4/aaMRt9jPQNMnBkiqrmBkTbGCdeejdiMc743s/I5XVcJQqtXpH2IR2TriP5YmSjMf7w2Z95p3sHf/n5Lzn//BtoqmthmttMS+NsxMpKzJkMYoWJxGQ3tumtHL/sBDZsG6A3k8CeMSGJBkzmPAtbG2msbOCiC2/ilJNPZ2xyigrfXO7+3TvUlZfw6WebWf1aFEwiosFMMjzMhEln/2AaTfh/mHvPYM2qMu/7t/Ped04nxz7dpzMdSE0WEBBBBwOGUTDHGRQVI2Ng1BnHUUZHVEbEGUVURB0DDApITk3uppvuPh1ODve5c9w5PB/gfWvqeYuZeZ96PrCqdq21/7Wrdu0P/9++rrVWXauG70soMRmvOIsUBBh5lxNP/AafftdriGev4E/3LPCK0+K86fWv57knFsjFJxju18ilkshhgrQyzPkXrqEnneHbX8vxlWt/QSRZ6EachKFRb1kcd1wvu/cc4ozzTiOKYhgZiemjRfoHCjz19F4axX0UDx8lluuhVbGJBBun6+DicvzEVobGR7n15z+jWJvlotPPZvfTT3Dqjp20HQ9DVGkXK6zpz9KbEfnsVz9OoIEm+hRyCdrtFoP9Kied9Ap+est3CXoVuk4JWegjLsQou13aDZvAa5JIh7ixiCQioVjC8iQE36VRdhAin+v+/lPs+c0vqLaKHDea51jlIOevPYUHJw1aYo7TBvoozu/n9HNfz+HqKuVn9pPfvIPRDVt5fOoQhpplafkII6k8ZlTnxptu57pvXIFZqxPLZYnH4yAKpPvXk8iLdOp1VFVAEKWX9N/LAgKCIJBJxomCDoEtIsV7kQWbRs3FcU0mjtuO0/FoiCHrt2yEtENC0Ln2LyZZ3rKG1ef3MLRmnIET1/D4A3fSP5al3irjIZGRFJBk+geHWS1OMyp74DYIaguYlk3Clzg3nsAJ2zz+0O9I98XJJHPMzbRwmrDn8aMkCxmu+PDH+OEPf0igDVHpSER2i1YTRNdF8B1IyMhCglgiC14ZMRpm81nrkawWc3vuRxEMWu0yYtxADBWkMGJ15hihaqB6LrGMjq969GQ2werjLB6cQTFSpNJtRmIxjq7MMrShj97BZb74qb+iq/rEYxt561ce4ivv/iduy17N8twSt93ncUvxINlVFSUd0WGS8y49j9C/jx//TiM+Mc5aQ0fSE4SxkC99/AP8+jctrr/p1/zD964kIftg21j+81zxRoWa1eGkra8GWeK5bZNseeY5tFgffmChCD7H79xFZaXKYqlIFAnoQpqWWSUu3c83/+VJ/vz0I7zi+A3c+VTE4aVFPnCFzh0PL3DBuds4Z5PHY/feiZkdZHiol9V6nbH1u0ikbuBff3s/SV0nl8zS9DyeePop3vnmL+J0HSZHhlg2bQQjiR+pjIxvQjADlNjjBF0LTSqjGL00aiH5bIxvfPd6PvKOy3GUOomUxo7NW0kVJmh1TUYnt1Oe/zWtjoMUV1mbG6V3KE39yAp9g4M0Wh79eaiEPkYywb/d+EPe/bGrMJfzDAxPsvuRKURJpL8viedGqGKckTEVte5SX2mxVG2RTMi4usTDv7qbG3/6M2KM85pXn0u98iS71u1CyaXYaFa545lnuPDjX+dnP1zl+aMhG7acwNFnnmbfEw/CI/exZnI9D8/OU27WKU0WKGTPYd2IyN1PHSAm6QwmBJphl8FElm5gYXk2hd4kgtVFFF96DeBlAQFRkOl2bBJZg64EqaO30Og9n9//7nds2rCOXEzFsbtEskLQrLPsNrjuB9dTW1iisG4tS0fnWAkCwsCiFUkoy6skMkNIIgRBSMOByuJh4mmJ6XaFtqgRd0rkhAj0iNC30RCZPnwQy7GpWhaOYLFW6UHOpZltlZg/dIxMQcMKz0NwHqSTVEh4Lrbvgiyh2jZ6WsfttghUgaV9t1E9kkBIxhlecy5HD/4RLR4n8AWMZBq71UEIPCLfAlElFFP43TKWsoVyt4iu9lJv7SOdSGLk2qQEn9/89h+pLbkEUhfdFjnW+nvecNJHeObtO7hs84fYW36Ab976V3zi6rdwz0qFd5w/yUWnrONV33iAb1z7r/zVG9/E0GAf55x9JrV6xA+/fg2jOy6hv0/A7JRwaz6x8X760sPc+qfr8LwcPYnzSeoH+O7aEcRA51/WreXKY3MEoQiBSyKTYPfeZxFFA1WKcVLU5subTuDMuXmIGrzynFP4yt/+FRddsB45ZjOS38jR/Q/xk+wkQ5v/mpuvPZPdh1YYHhhjeqbMbK3JNV/9Dh/74CfpyocQRZn+bJaPfuKFfQ1J3+RPjz3G9m1nMTCSxlot0fHbFAOTSOshqXucvzXGvY9KzK5M8RcXX8b3rr2Bi978Kp47coh9e/aiJHMghfRkB/nDT/+RNRPnsOukGL9/4BF2bDmBVqNJ19dxVsqM9SXQdIXlhS53//lXHH/yK+lTfZajNrsfe5LBwTRH51Ywo4i+vgKS4NJZqVKJKfiuTDKlE+Fz16/+TBB0+dIX/5ZWd5HSkTLDa4+jvFLDt5oM9gzxsfcez43f/QlJXWS2eoSFhzp89DNf4qaf3srW7Zs4uv8R1o73ErQT7D9yEMk+DCWXf98vsti0ySX7uPSEs6j0ZLju93ejxbIk4ikKmTwt239J/70sICBJIrFYgt6hMdyWxQwnsKk/hSiY1GsrFIbPQtdHabQWyRVyHJWPMZzoZ6KngCN55E45EVl02LhtK3vuv5+BoRQVByoLLXrzDiodVC2JLkvExgeZPbqHvrFTSIZxROJ0BgYRA4UyzzCY8ygtOgjJGJYVsXR0ip1xBy8dx4ufy+zyM4idEVLNLp7RInK7uB2LyMjjNbogimiuS1eQ8A2wa3WOtf5AGPiYXQ9dS9KprKLF0yBCwlAJbJ9AbpHKr6fUnOL2J2P0phrkdAPXa1GqJ7n+V59hevYIaSON5ynYXo3bHrmFY/MOm858L8tP/IjNrziNJ27/I2e8+o1csGsVLZthVslz5kVf4osfeQ+/+c7vufy9V9MtVTnupFdy6WUfZSCVx26USfWmCRpzzCyISNQ5dfsW1q4/DnXoAFvnE4w1m7iJkJ2hzZXxPN/q1Djx/Ldw/32/Rgxk4kZEZNb4+s6NuE6Nf1mb4yN7y/Smarzy0o9xwWs/wKZteXJJldHe4xHXZKg98ktee4XP/be8lrlSHcdxicfjTJdrmLqEZIqgZGibPnVfZU1hI27U5nVv2Max0gH27dmD1wnYedGZBE/dTb5/mJXqFA88VkVO50jFPX50w408+Kebuf6nv2Qkk6U0cDyeBbGYiucukQrj1LpLZM1x3njeG/j5jz5Jq9rGYQA5WaLuVFG9BHpYYLR/B0f2P8MFF76J/T++GbfdIpYK0XUdWbFwvQ6r9TairyJVRHqSIQ3B5ZovfRurukwi18+eB+/HNWQWnn6I0TXr6cgpNmzZwl33PIyxOkMgivQnCixZERuHVvmP/3iYkXiBmBkgqpMsVjXW9Ol86jOvp9Y6SCw1xKu6RdIxmVagMDMzw9H6Xtb0uEwvPoPZClle0Wm0qi/pv5cFBKIgom1WmTQ2sPfwHFnLpBPz6By5h6+8/XMsHnuI5w8/w8TGUY4eforCiWmihoGZrVJtmch6hN82SfcOow1G+GEM2gLZ3gFsAYLAIBIaxIMy52cGmHjFcZitAL1Hw59dYSgtYM6ZjBsSB5cMAkPFafpIKZeDzz7IRGEXi/f/mlKg0TUVapUphIxI2C6gSSGuouJ2a8j5PsDC8QUkXcOQEmA0OeGEs9j9xNMoYUAkyRiZBGariaa6RGI/kQZ212Z5eRHRD4nHDNxuCTkep2cwwfEXduksLxEKAVXLpxuuEnoCX/vQHpK5Ia755Af4zDmnMOPM07JXSE+M0nQOkhq1ef/PVfLdL5LC5mcP7CJvjWIYV/Gmyz9FvT6H1xBwgyZeGCIqEnm1xUOPT7FlxxZWFlaJTJlfnDfJ9OIiqijhp+O8IWpx5fpBdtz9MyJE1uDygXg/O4/PEzQd4pLKjshG8kKscIg3n3oGi6kTeOKP38J3c6ClaR4+wOiOHpTgQU554wrve8t2Ljp7LRVTY98Te/nU5z/BdV+6imqjg+Ko5HPr8Owq+WSaxdUSGX2CwgkTLLSXmBge5ee1kOmFeVo1E8MV0RI+atjHwelZYr2DqFHE01NPcN89M8wtzuB0O3zpmvcwddDnc1d/BE+KMbphHZ/56i+44IKtBJJPIqOR0GPU6z5G/xhPH9lLTAw5/eyz8L55PUYmxnLJRhJEElFAvRrhOj7Dg7100hbl1Sann/VqxoezyOkBVldncf0GG8e30Cwdh9g3zoi9yE++dS2DPTlqeowo8LljZZF8qPDsSggDNdymwSXDBv2DARdt3Uyl47D/wJ94+N492J02la5IaVVCTBj4SoxEssDYxBZeefYlxMdz5MQW00899pL+e1lAQBAjYkYazZjAbDZZLE5x8dat3Pxv1+N7EutPS7N2coi4nEUTupheglu632M8OousFsNoZAjEFgNJnaDpslTuoCeHKDa6JDWHuFjHNGT8eMDjYrIDaAAAIABJREFU5Taluw5xxtln8vCeGXb1Cjj+AJJ8hLVbN9F9foZUvoeKV0fV4oytOYUn/vg93FwPzWMlbDFGIAmIXoSbaeFXIqKwiyDLKIGI7EVEySSBL9LumgSBzCOPPIukSSiyRigr2F6LpB6j0XFI6h5mo4YgRnRDH0XVKahZhkYKKEEDPVbgA2//Dq3lFo3wEBYlQiVA9CPstoGlduk8WkK+YDMTg7388vf30lNdJXnCEJlNo1xw0TKP37rKfxz6CIszTY4q9/CF9/ySwPZw2gaOV4dIwg1d3MjA8tuUynWMWAqiCEuwaZgdtJSCEBMoBCksUWG/KfDLdVv5UXOFNyoKuiYyYvVSD6vE40mUdsT1a5Jc5QVYko3W+R0f/9xWXve6ndx79zzpwU3Y0hCSUGHngMkVbzgJJTZO9+jzrCyuML5hDAwBJdIwxDS+YpKMZ3CELkpMJmto7J86Qv/aMVQhQHR8epJxpE6LshAgNOocXjARPZPXX/JKJK1ALt1DcblEEAQYhkEkqBR6IyrlJjvOPwVBaPBP3/gWvSO9tJwIUVVomwFtG16980QCycLt62Nk6wBfvu4arr32WqTVCF2PSClgCVVc4syXl5DaIZYX8o1/+DqO22ZudorBXIEKIUvTsxjpHMcO7eHcE7Zx+kmvQMtIzJSaNKsrnLB2O2rMwRVCikeLiGGG9MZtFMplGi2H3MgY45PjnLjjTGRZpepNocspunZIx7aZmTrGniemqD6xj59/f5YlO8vS0eJL+u9lAQE/CLCdLtt3nc4vb/4lZx23lXtvfYBTLz2f/NpxdlxwHt2Og9zTjydl+OTgF5myltATWSQjIJ1OYWo2Y1mVszZvZu2ggqr28vRKxJOHl3GDIdBmGR7qobTa4b5npvn+Q7NkUhI/CSOkKEYyHxAKWYJKyKJdRo0igkBjuttiqqnw+FPPYfo+omygqOCWyoihioyNE8pEsofbrRDG87jdgETSRo2yeFELzw0RJR3fs1HECMXVMBUblJB2Y5VYKo1pdtGsCC2VQhY0jhxeYsvGiEs/NIxVrOHLAYqbQBd8pLCEqVkYrkbgSAR5n6dXu/TnE6x/ZS+CLILR4KL3Pc1v7347n/jEezFnTTpBg/e9eg8b1myj2GgjayXmG10GCwlCJ0JPJXjooSewayZaaOGFXdygQ7XZRhNEbEnEoYXZirAjhWRB5HWhwWheRbXTuFFATDGo1tukXYOorVCLSvSQpq93lC9/5X2ctOGjZHsGGHSH6XhLpLMx7n72Yf7u1ku4/JyARARTj9zLuy45neWZMooRI55aoT8o0S+s5a677ubsi1+N2ynyqpNP5OFnH+fRoovek2Vh+iiarqPrSXqjOrFYGdFqoGvr0XMeyUyWrttEV5NoioCWUmkcjLNu3flMTS8yOzvD6y5/Cw9eeRumU2UkO8pqxyKXy2JkcmRHx1AlkZ70Vv7iwiGu/fK3qHU9sgmVla5CIqciyTG6nsyG4S38zZc+z8P33o4o6YxkMwSSTDozQbF1kJ7+FDtPv5xff+fvOP6c8zFiArftfYS3vuNN1I4tUuyY1FebrD3zQm7/8Z3EFQ07JxGUO9jzKyjjfZRqc7gdk0xvgWL5GCPjW5CTOqed/gq2rT8TI93lMjmJRJbzXnXfS/rvZbFtOCIiFvPZv+dJzjj9XI4V5/ne7gf43De/zYWvv5imK0CQpb9PoWsuUzMjhHQWx3GIQhXFaFM8sJ+bf/ojppYbPDMT56Cznj8+8CTxRIhmQEoaYqL/dPastNBSOQo9AyhKhoagMN2eZ8+iRX6gQ340gRzaSImQXCGgdHiBYrlFejBH/0AW0apS7dboHRtHUF0CPUIQPQxNw/Fd3G4dIWpjd0R8dwXPbROP5zDiEdtedS7nXvImIkUCQUMM4sQz/cTSPeT7xxjZtAUtZlDs1sj2rQXJZ9PgG0ERARtX7NINK1iqQEibnlEDx2yQ2fXX/Ptzz/C+G7+Dm8nzcOjy7u/+kd89lCdUdmMVy3ixkELfFlLpBDPzLbqixUpZYGIiQ73dIRTg/Ze9lys/+A8Mj2hoxQYpR+V9cQU8C0VRcSIFrIDdGmweMvDsiB3ZBIIl4igOQdBGV0U0RSDKCqzpC8h7BlGlTrBaIq3H2L93kXPP3cWK5yOLPlOPP8dktp+7fvo9fnH7Xdz1wMOoI2u4d/8UsqKhhD5uW6dYgqmlg2zbtpNqsU3gp5hdLNITy/H7n30LIejwl5f+JdnEIY7fkGa53SGfm+DtH343yZSH0HT5x2uvZ9+h/dx312/405230VzOcObOCdau62F8dJRzzr6Ae/7jDlzJJ5KzHFlaJpdSUIUqUV8OSezghA7P7TtArWPy7ndeRDarkVQTCPEkkVJAooHrdPirKy7HbbkMr9/J6Np1CFmd0BR56vHbEfWA2277A3OzT1G0KzTLi8T6JznztDRP7V5gzdbNnHfONgYKKoW0wb7lCr5XRwuSGP0Fqp0OrdIq7dUiawZyTO99HKvtcPDRh/FXKoQdl0TCxXdVJEmm2VlAll662vDLIhKICEHQ2LjmTPYc3U1uaIKz39WHGAaMeRuornQoTrcJ7BZ2S0UQJBQCQilCFiAQYGhgAkGMk0r1MT21nz/deTMXnHUC2XyWO+68l7GxPhIZhUx2DK89T7WawLVqbJgcIzs4TDonsOfQLP1o6Ik4+VhEpbjM+BqLd7zjB+ze+wxnnX4eb7joDYh+DavloKVzRFYDQfRxPRtRkhA0jSiAQAiRZA1MG9NtIVUaKG4CyZIIFZ2gXSWRSOF06tTMBloszqrpEC9kiSkRrlvjI199JVIU4AURvhdAGCAIAi1nLyljkmPTIqf+yxEu2ngld79boe3Z/PLO55heWuamu95G2dqHquygX5DRbZFcLkW3EpDMtREFBSlZ5/CTHoXxGCuHV9hx1iuw/D1ks2n0VI7BepVLx5KEgYQmB+iuTVuGi0MF0XGZFtL0BEVS+TSeLxGYJp1qB11X8Y0YSqeBr8yjDO5gqVXkyqu/ydsveRt3/v537Nx6MUsHZtDXjlGzOvQmBJzuKsVWDCOTZ9/+gxipGJ5pE4kqdz35NKrmIrsgGgY9SYlORyaV8nGCJIurXdYt1hkb3sJiU6HeNekfMCgvBgyPpKjLYDdbnLLxRMwNLn4gcujAzexZsEmkYsheF1HU2bv3PhKigqyGOG4ML1SQEMEXKRZttK7DTx++mQ9/9N2UqjYj+UFWKiVycQUnCMlnM6w0W5xy3rlUV1ZZLdYIBNC1Hu6+/99ZO3kax+aPcPwJF7IwV6XRFXnqwIPsnrqPXsPESK3ld7+6gfklkXPPvZTNY/2MpgOqpQUmx7fiywJyJKGls2wcHKfTbjIyuZN0OknSUKlWqyhJnUCUkW2bwPMJQpX/qqDwywICIjJyukm1fAjsNgMDgwyufz9H9v8UhwAlobBl8zoWjjYZGutncLzASNCD1W7g+x66F2IXslRaq+QiGW1ikKJr8+f7H0LSYzR8n9Xd+3n6yYMIisybL9vKwbklRHGc6WNTvP3VOzEV2L5xM88/Mk3QapNWBORkjJngD+xw3sbEup1c/fmvUCqVSBcGWGw+SySoKFqA70Qomg6qjqprdG2LmKzgWx4EKlG3iyD2IuDTlSR6hgeZOzhLGBlIsTy6LNBpVVASMYqLC4xsHiceS7Ct77PY3iH8sENTWH4BeGFAOtjAE1MdvvDjDN+67GSyH03hdDwMIyIXC7hqz6uxOm1EYT3f+sQfuPGWTzBfrKCFHqmxAcy5g8QGJpH8Ar2JEpWqx1PT81z7sc9w9+69ZNSIHVaTKyb76BlKUJwp4XU1HDUOZpswoeL5Id3eLWS7NhVPwG5XcIIQP4ww4nEwTVRX5b612zjjcJO43SFvTDK0tkT2+L8lszqD25NgBA0zamH6Ae98/zvoNGxWirMc3XM3D5QtshkDNyXw2r/YheJ3efjPd5Pp286lF5+Dkbb5/N/dRDrVT2VqP0OXv4qHH6vS7MoYQpxYSmbDWIpm5BKX0/T156k7NdRQxgkC3JLK+970HkxbIfBEgsDkyWcOkhvQ8Ynoi6cod0wGUgOUj87xvX/8GnLPKKeeuAnVNXnk6T8TT44wqEWYjQaqEjG12GEiexz7jyyhINE7NoxgioQxm2xvL08fPMBVH34Dra5MsZyltvgA3VYLV/ZJpMZQBJuRwhBjowGRe4Rf3fQcb33/qaxffxaJZIxGo4GeyWM7LUKvC4pGLBLpOi6BICHG0gShRFg+wFInydPPz3Ng/0Ga1dp/4b+XQ4sCvGbEn/c8iWIkGF0zyfTiLMcqTdpuiBor0JY85D6T/JrNzM6ssjCzTLXp02n7yIaE6XroRhY1ZmAkU/Tlx9mwbRvJQobhoV6UQhpJV1D9OoFkgSzRbVg4rkClC5al0HB9FM2jp68fQTVIaCKymyOT6ee663/MkUP76ZlMsbS6Fz1eQMDG6rZfqDAbBoiA0+6i+AFOt0Xo+ySyBWRVIN4nEMkxmq0qcT0BgYosqYxPjJFKFUim+on0NP0ja8gpad7/iQDHeZow6uL4TcLIxgyb+HQJNIfLz/g3xtcP88+PreGRXx1h71KVHmOMUm+VqGUSl1QQq9x16zw/uOWXGB2Pi17/byhOFzezBcWRqS6VWAoqOLUyp22Y5LEn/ogZ7ebcpMbrFR+rU6Y83USVVCJZxPO7aLpC120j+BFLgYcdioSRRbkBlgPJVAI8D88ykXUBKfR4dmeCriLyh19+gNedeSopbwZ5fAtpRaVsNvALKfpSedxmh5XZadyWyCO7H0TXZSRDZ1RP4i0u09/Tz6Gjx9g0Nspd9+5GC7O8/qzjUCdfxfrLPsSfb72Vgb7TQIF0Xx+ub/B8bY6e3gT9QxOEfoAiiKAZ6EaSQ12Hf7zhpwhuCcWQEAWF7dv7MGQdTSwwVTGRvRzlFY+77rO4+J3f5VOf+BaluSQd+wAxJUGr26FeLVPxQvyuj2P5kF1gx9Yt3HP3ozz31AGeOnKIqf0LnHTK+Zx37ilMLRyiVp+hVX6MVP8A+XwMMT0CXQdJz0BsDa6tIIoGY2vzxNw5br/1Pdz0s7+jXK8hiC6SHJJKK6SMJD09OkcOH0bXddLpNJ1Oi9m6zmrtUfbuv5tGawHvvzhZ4GUBAVmWMM2QrTs2MD46Rrfb5TVnXoqcUJCiEKdWwTdDRF+jf6AHQ1YJdY0wEAkUgVgsRuh7yITElATxbBZf1ikXPd566bvxajYpLY4QBqwZLqCkRQb6CtTrdXoH8ohyhC47GGEMq6OxslLFDnSU5ACqAdf/4Eau/sT76dgmXiVGPDGOZoAoisRjSeQoQvBtQq9NSJfQswgjB0FR6BnMEYoB8fQgq6VFKsVj2N0qkgDN5iJLy/OYfhdkkKIGtWqbTqrNqzZdSSAJBKGNE3WJwhAXEwuTp5d3s3/lMkTVRk1m+Matu/j2HRehjeX4mxvegqz1ogQyvhentFjjlutmqYQpTsiewWo7BoJOvWOSHxll3bq19A714Poyn7zqEmwr5Fwtji7GGVR7KHfbBEGAZ1vY+FSbLWRBpGVaHHJMWi2XpYUGkhaS1wwEz0EQBJRQwojr+F2XZq3MhNXiuz++CRWZZvUYkjBHOpEHVaV2dB6UGMfmKrQslyBqQeihEYBZYXGlTFqSGBjo44brv8pXrv0mTa/FFz5xDf1qSHF1jkFJZ2G1SDydp7TaRg4UAq+EU+5SXFzh6LFDxGMqyCpBECDgUz18hGuv+jSSrNNtdrHsDrPzC4RE1Jomir6JbKaX7NAYN99wOdd9+QI+fPnJfP6ad3HrTb+lkOglHxPxhQQDRhxH8cn1JLDbEpt3reOMM3ch42MIFh3HR5F8bvje9Rx9rk270sHq5qjMzNF24JSxTcjpOLIsE9eHiGtDuF6GdpAgdFVCYyeVcpNKtU6lvEoURTiegJFWCCKDk089FUmSEEWB3r48GWWWnKqSj8voMQE3fJlvFhIEmf71O9m/t8FJ79iOs+ry/Rs/TSJjoSk6LjqRaDHWn2N97xbcUEGKJBy1S+BGWJFPXI1ToU6j7SMrElLgImhJfnHLj3HjAk7XJVJCNq7dSv2IhWn6+H4dUR2mV+hlpV1m5XmHUAwRDAFFbrBYUjH3ylx12Zk89exhcpk0Lc/DOVTBCprEJYEIEUFTkBFxHAdVlgmjEFGL4WGTjseJByKZnjwhAZarIYg+shThewpmo0YuO0DH9FB0i1RhkC1jHqYbIYoaIR0iGSRPQRU1bEFgc+9xzDWKaIpK5NkktRyD2yb5/PTNXNY2EG0FRxbRRZla6FLZX+JXN3Y5XFylL63itjuImTjFhRW6nRb5QpLbfv9zulNLXK58j+fbXY7TdeatBoamI2sSUSSABQgirujhYuHaq9SFLoEAgeviEQNJwHAlwlj4wknSYUitI3PbvjlcOc7QxDYcVcCqGhRb89hOhXhKYXHhGAF1IrGF7Yf4yDgyGFqcdD7OlV+4hvQ/9XPyuj7efdml3PvoY8zu28dx20ZpPnoLy40JCulxTKuOFo8R6hppbZRsTxMf+OMd9+K++D3NTpdIiRgdOI1Hb/8doStw+nvfgSrLOJZKIDioYgqvbTO6axf11X387acvo0fVUKWQrgmlVp1Uj4ugT5BWmywuFRHiIq1aE0vqsn67wVf//kdc/09Xcs8DD9LqRqhBja9//Uu0vBiRt0KESKRAJpGk4wRopKi0AsbGchxZOkJ/fwJV9ckZSZqrHfpGxxAEi5GxrShyjK7VwXUi3CBCUmQScRXLDLnm6ndw2umXMFiIsXNTH4/vaSGgvKT//ttIQBCEfxUEoSQIwv7/pOUEQbhbEIQjL/bZF3VBEITvCIJwVBCE5wRBOP5/AoFIiCgtW9zx82t583kn0rtmnPRIm1BWQIwTxCQkTaHoCThCAsf1sX0TXRaJySpmp8p8eQWzYRMTQ1rNOqqiU+hJEYUyaSWHpugM9A6z0iqjjkpUhAZWV6FPyTNT81gp2xyuLXGktMLcVMDeOZelSsCu0VdTb7ps37YOVZFoFsukBzMktARGLkUgCSCpEIaomkIohSCKeKaN6AbMLpSwfJfAsanNlLAaTcqVCk7kc8FrLsYLJWrlBZygTejDQG4TX7j6g4RiiUBcQBAEQlfAwcYJbDRNoiM2iccNDDVJTE6hagq9ya38w9euRg97kDURXdLQogIL4pf5wMc/zuJ0i3rJZnZ6jpXlOcqVFYykBHRwLJdLXncRvl6hV5WJB2DKIk1RpxsGSHKEFItTsS1sN8S2IhQ/Q09xCdkBHxkpBHEkgdAjsb+4QoBMp21R9mWOuCYnn3g1nuVhNYpUl4osLO1B64nYuG0b9eUmyZzIzm0n0JcWEPwiw0aMQkYAPyStpDjjzF385F+/xaEjh9g4eRppZYVmfZFbb7mD3/7st4ykNRZXZtAJWd9XIBOLCP2IXWecwrodFzN1YIpmw6RaryHgkQhDDjbmKbk1fnTr3Xzk08+S7lfozSVJahr9/SkmNsSpWhU6nRbpCHRNQ1NFdLFFJh3SbvosrRSZqzaRdBsjGUfSEwwNZnC6SXadMcIz+5/grZe+iTUb1vHcwTK/v/sx8tkEjUoZUXRJxxRyRg9BaGOkCqQzcYozTzE+dirZTIzhgY04oYTTqjMxPIqq6qyuLDN/bIqlmVlWlpaxTQvPcXHsAFnQMCKb/U/ewX27b6VZnue4yRiS+NL/+/9JOvBj4ML/TfsscE8URZPAPS/eA7wamHzx+gBw/f8IApFPo/VCTTlN7uNtF29kYG+W/rkc+mqJWN1kebFFq10mIEJTZTRBwJUE0ASiSGMknSaWjejtK6CoOrFsjnhKQ5QEYrKE5LnkEyrGUJxjj67QOODQlx/Ha7kc2jPHytEGrdUiWm0IM6lTOaYh6xJ/vu855o6VMTsBS5U6HhIrxToxUcNpe3iWhybwQogZ+IiuR+jZyGKE79s0Vg7h+yFt0SOTS6HHXDrLRRQUxvqGMWQQjBh9Y3n6Nm1EYJa+7CCKoqCG6+kGJWKKgSKoJI0MS9UVrK6NFKmIkYzgxpElhXYddl5Uxo8WkHyZwMuA6hLK0xzY12b6wLMszD9IYM/imPOU5p9ntbaKmMzSbjQRw1V+/skPswmVpGBQtSxURWdY15BlkflWnUiIEGUJO/Qpt+ucZ7q0LZO4H2GksxQHT+JQ4WSC7CDVdgtUlbmWySHfY//TN3PKrgEGtm0hPTxIsm8tvpkjbeusOXEno4lJnI7L+MQ2hnv7eb60jBITsCMZ03d5vq1zrAK9+eMZXavwtS9+nZbZZdU6wje+9W98/xd38pa3/CWz9RamFzG3tEzbbVNcWOU9b3s7o2Np8oUEmiGhhSKZnhTNygX8qfpZvK3fJrNhO/VDNim9l0I2h6HBsZkKCdmhujxHvdvGFiQUVUfJxEjmeukbmMSQZALLQY407EaXnBZRrhexhXmOHtE55ey3USk/iNttcNLZp3L+ha/B9T1kRaSxOoerDdEWE8y3YpgMocXXs7RoMluaIpJ7cQ2JZM8EhYxPrXqQZ/c8SX9PPz1DYwxPrCGXSZJMxdANhVZnlUee/ANGwqFesRgxdFx3GYljZNOJl/Tff5sORFH0oCAI4/+bfAlw9ovjnwD3A595Ub8pemE9YrcgCBlBEAaiKFr5r98i0loooekymt3FFDSUk09gbX8P9WYLLeEy3A0Z9ONsWLMV1/XQVANPqtI1PWrTs5giDGdUKo02XpjFbpWJbJN8uhct0Uc+mcb2lhnQ+nj2yAK+WEKPCgxnNHJGjlK1w0BSIL1mkP5WjWZQJOPKbJ8sMDgW58LXvpZcwaVVAiXuYeoRbsNBVhU6toWqqbi2gyQoqDGFwAdVjgg9m0gWKO1+mqIWIHk28VgOU/IY3nkG1o++w/D6k8Hp4M7Ps6rVKC4fQld7aLlPIIY6jlRHQsO1miAKiIqCH0FckBFVFQKB3/78MOe9f5WYMEooynieiWMq/OnXKQ5NPUqrA0MjW9CVBE7g0bBtJMHCt5q0LQ99fJwrJjPs3b0PU9LJxgT8wGKP5ZB0BIRQJS1HqKJA4Efsi2c4NedQKkMqAWokMFp+mEVnE0GzihcEuDGRZmgj2CKv2aohFIZ57v4HEGQf4hqK6fLYqsTY5HHMuIu4XZ/F6Xlu/+130D0ft62QSkngqkztuYMvfqFNKlnn/a9/H6vyKu/+4Ke564HfcO2Pvszvnv4X+rMpMmKTg8U5uh2X1VKJM09LsWn7Gpx6hXalDXIH19A59lgRq99GnL8dqXAi7dk9PPDgDJ5fIaUZTJUMJieyNE2XZEYglYgjeBCLy6hhmnmrw8yxCpKmkS7ksLwKkicTGTq9cQPJ8Tkw9RBi8DbivSdx06/ewtve+XeoUoTgeRhqgJjtZ246RqlSpbQyS++QzZrRASxjO4V0HltwSZop1EScbM8AycwwkiITSBJC6BD6ArYfELk+IJCJFShOP4gYJHGtKpaxDsVuUa+1kJWXTgf+T+cE+v6TsYtA34vjIWDhPz23+KL2X0JAlmQW51eQ1QBpUKPbKpLqRITzFeKhRLjqkrO7rOh1bv3nf2XNmjG2bt3G+HCW/kyK+dpPsQIRUe4wuO4v6UpV4qkxZsvH0JvLDKTjLCy3ODxVYnTEYGxHjXLJoD7vcLSzysZJkc25GE1VwysEePEsmQyUrCRyNsny7DzDPRHp1EZi3hJ1L0E+l6HqziOgoIsypt1FSSaQJQG3bSIjEOkxxDDEd11kSUUIPVB7iTSFfHaIz3/hs2zZPknD8ogrA3SlGj0DffhRA13eiCpuxvQbOOEKgiQgCCCIIpbvI0khgSKiSF1s2+bb37uOk//iHLLxJEIk4kg22d4s9/3eJ5spoMY0CoUUvifi11eQ7BcMLYUR+zoLBB9+E3vvf5S2HCcpR7i+QEaTSMoKLTsgK8oYEmgJBcsX2S8NcbZwEEVXEH0XM6pgHzQYDZ+koXYoWTrltoUli+zpNGlmRol3Wwg9eRLJAgJJGvoq2yd3sP/w7WBmqfkdrrvpb0lLWRTdQtBVpMBBNmxEsxcvWsWq1WnHJfoL6/jZj7/P4NBavnTVe8kpGtd89XrOf81rCRYaJIMa6ZRGccXnwldeyfU/+CZDWQvfBssJMYPnGOw7ja7VZmnP56jr57KnfSN1W8SrBgiGSa0sk4wg6Aa0wg6FvmGabgffd5FkjXw6xWJ1kVbH4bitQxSLIs36EvF4Aj2d59JXvZWlxRKCFDHcO87OTaMv1JSUfAxZ54+7l3juqUcBMHqGKB7ZT2X6CEIAVWcTe3yLy9/Qh91pE0QpSqtNFpZsXNtBU1WCECQpIgxDFEUhCl2mn3+UrFpAkQ0em9LYNrCZZw8foNOt/1+HwP/boiiKBEH4/320sSAIH+CFlAHD0HHCHNv66nz6HX8NsorV7hDLZhCCAE+UKQUSsY7BKyZDFHEaYbHB8pESz9QrLNdq2JHJ2OZ3c+Se++m2qij4OI0y088eY643Q4RGj97PEbPJwlEBWTUZOnktyZRFU6uTLyS57/szjI/3UKlU2DaxDiUT8dTuJt9+7tO8603v5K/f8zY+/OGvUJt/CtNNkpXTVBybwPcIQptElMRxfOQoIpRE/FYb5ABBEgn60iiWTCR0kI0EPhGnTpyM5+5nyTRx5BbJwXWUggMY0gaEsI3vm+hSAtdNI4lNIklltVaiJz2Aosr4QYCAgefamM0GiqLjOQGOpNHB4UcfNTl+YpjlskS43GHx+cM4oo6ajJPOOvgWCLbB6171Hv5oTtENRIYT4LsKOgGRG9KMJORQpCV0yKEgujayKDAfeUTtGGroE0gytBUcKWQlNBH9NMg+VuQQegKvOeVy/nn/g+hpCX9wPTQs9EQXw8nx7N4/0ZvbytB4grvu+izmdfBbAAAgAElEQVQ7jk8SdBM8f0RgzlomnS9glpp88ON5Fo8FaHo/iZ4RTLfJxOROwqMlltpw3KaTyWxJ0uqu0puSWZFVZCuJoHSxu0f40Lt2osbOI6GG1KNelN4T0fQ8dgIyiRP5/NWn8bvv3YQvB0hqHF0JEUMfs7pMpCcJBQvLdEEMEDxQNRdBUZHjCeRWhdDOUSou4Ctx6rZAoVChNrdC/pITeObQYfbt3082HqNYX6Fc6xJjlunHHgDPoRko1JaeJJ0eQR0Ap16nM+WTzKl87rtFrvvIhcxMz9Pu9pIfniSW6PLEw39Ell0EYZIdW7ZhOxaW9RC9Xi9haBELfPSBfvSKySknHceB5/a8pBf/TyGw+v+E+YIgDAClF/UlYOQ/PTf8ovb/aVEU3QDcAJDP5aIobPH9r17Dsi0TBh79WQ2n20AMXRKKSqaQwm+biLqMG/i4bpsQgyAyeGzfLPV6ndHpfyIqOajJgMXFGqJpM2/HKS3Os379RtaObcUQ21SEWfqI48w4nHzyJoqOhzXncfF52+lYHVJpEUOVaGBTWZ4h5ur84le/5s4/P0vLcli3YRtLczWcniTxikEoFhCEJs3aDIQCnii+UCsgdBB8GTGmIzga6ZRB4CfwDJW0rhGKFkvFCsQLZNIZ6qVlTjrhZDy/giUlccIOIjYdr4osZgnkFWRNRdLACxwEEWx0JCnDGeeciywLuJFAPZij6ygEVh9hLIWnW4Q5k0alQTY1iqZ52EKaVnuRtjmHN9XkU3LAB3qzDJgabdGlEak0bZcw8AhljT5Fpy9t0BFdZmpxutIMc5FPryvgxkVark2ATEyQqeJQd0BWBATRozB3DCMzQBh1GbBCplttAktDiFoM9a0lq4Knq6QUGzeKcGWXk/9yjOO8AUJHZDwzjhlOs244wo+aBJGP213BSEgIJ/kM9shM3dtl//wiq47JcH8Wp1hkzQmDKAmFU/UsfvoV/OEnP2DzxuM5fOA37Bj5Gw6v3klG6ceM23zzGx8lE3UQVQHHDbE8h0w8Ip/sYXFqlUZMoWV1ePPWHSwcXeXR+X0cWqijZ2TWD62h7oZocYlOTUQdCekRUxzXt4a4kEANRNaMrsHzfHKZAbSEi7e6xFUfPIm3XvE1YrkdqONpqs0G2opIOpTp1ksITg+C2CLTl0U/MozeE1HIFLjqQ29mqRmwfdt6xoeO8bWrP0lT28ybzutghh5C02R5KcQYabCqRYgtF0H6v19Z6A/AO4F/eLH//X/SrxAE4RZgF9D87+cDQFYUYq6LnRwnLjXxIh/XF/FFFy2RxG13CZSIkJCo7RGLp/DdgJZvEqQMLrxoPUeWEzz7zDJGRiGZVpHlJZquhVoSmPhfzL1ntGdXeeb522ef/M/p5lS3clIOIBDBQsiALQS0HAbj0MZ4bOhgM3a3MdjYXmPj0E7dmGT3gMl2Y6KQhQBhQEJIlEoqVamkyrdu/Od4cuoPl7VmrVmj6Vmr+4P217PXPut8eJ/z7vd9n+fJF3HdIU+dvY9feM21nGv1MI+/iKtnnqBXM9H0BD+DUJGURwZWLk+cCrYf0lnfOUUQhpiaT2djQOT7uKWbMIs+ujeFXxjQ72+QxBmmMUcmfETiEI08FCmRto2m2+iRSyzKiKpFJYyI3IB2cYBVmiYRClqSMD+7wB/8/gcQ5kdxIpeKfpQw7JA3TTxtwtjtEKcanV6Xgl0i0yIM6XB8/8/w736rj5/dT5gFZEhyBYeJ69HduMo4XKe1PqaYq7Bz9QTSKqKGgryWYZdXGHXafNZM+Y95lVPdEQPPRUpJPtMoapJqzaahafh6xFZH4Z+cLq+MLYShI0qCiqrjRTFpKunFLuM4Bt0gThNkKrjlgEPzkTNUll5MVDWZKzYINjoY+TIUNPT5Azz9wBd45esO4Q57LO2vEGs+tm9iKRahv8UwcJhplOiNOpi6yepsnaHXRbhFsrDJ/n2301gN2Lx8gqeeOk3Ztmk+t8WNL7mOuXrMlLHB/p99Heuey2/f/QaKxRZPb/fR8jmSUZsn/zll2LWZq2Rc2e6SmBmxViKIXaI0olSokfd9ts436XV7lOdnsSOBGSi0Oz0mJZu1jRLVfSazMuDK5pCDv3MnTvsK+1avYRhWSOOEWA0pqIInez6/8ad/hp9pKOPTPPhHn+b9H/8kZdngNW+8kff80d8T6RnJ1oh//NI5bly1CO0GbrBOoVqknLSYqy1yZP/1LP7GMqvL1/HZD/4qZXuBbiyxZ0soYUJUqRIlLdLkf8KBSAjxaXaLgHUhxAbwuz8M/n8QQvwisAb8xA+3fxV4LXABcIFf+B+dD7uiIks1k8mwg23rxB4ULQPHqKCkASJW0IiRjRqZ5+A6AzQhaLnPshFfQElmaW+lXLn4GLXqNM2NmGp5L+OJjznsM8GiXKhj6BW+fnbAkXsP0Wu2mV9dYH54PcUZyXBrG1OL+OZj32PvoXk6I5+KqZEFKUmqI7Mq1nSB5T3zfPORb7IQuv9/Pg3GA+CHSq/D/7tcclUzuF4eoigFZTuHpkjyruRvPvYh3v6LOcraHrzgClLPoaUmg2CNi61LqKZEouJHE2JhkagqFx/XmDu+w/ktlzh1yFJBxbI4tOc6noqfphauUr7eYdAfMRls44c+iigTCImVCkShys5rKrQ2JxycLpOkZRSZkmS79001n6Pdm3BpZ8ymmnJSmeaY0uIqKmv9gCmjwFTOZOiGJFJjoWTQcUIGCApI1iKFam4aZdgkFAUCJ0MpNPAthbwyx3OP/hP1+iwTL8a2K2y319E1mxIJiaVwtdWlbjUY9WJQavhNFyux8S5rXBwN+Ma3HuL/+Pf72HlmnbSiUyzoDAMXzdP5xhe/Q54YTWvQaGj42Fw9lWOx1GJuqsZcfcJffe5BbLPB7LRNrJpMsjUINHS1R/NCyM/93N08d2aNmXAWt9fndOcSU6s3c82+Elcur1OpGsRGRNoLyYYRw0pKasC//vl/w9//8a/ypn//Nu6+5Q38/P/+cRpzNW69PuPvv/ANmhegWqvjp/Du932GG/eVeOyJR7n1zms4viQ4cHgPr37j79HbOIPfn5BlDuPROfq9GI08X3vkCXpxyFx9itzgElPVWfJ5i0RT0POzoJWJ3TG6WUSI/wl5sSzLfvp5Ht3x/7I3A97+Pzrz/7mSOGbp0PWUKiqjvku9WmPojSkgyRSJ0cgTjB0CJSWTGqlpI6XBLfVbOeys8K2zZ6hNLzNVbGAWpkhSj1G2AW7EZLqC4aa02k3snKDfVTn6IypTqxWicULHu8KOL1FrJkVpcOsr7mI02Ga2LOiFF1jpaZx9bBM7V0B4Gv3LayyELrMzc/iV/ehBxMMPfZr5hSUeuP+LvPnee3HDiAIKd7zudhSKfOXBEyhzdfKySDVn0XZG9M59n4JeJo6boNkkiUaoO/zNu3+LJ7feRSYamFqdkDFpmpJlgjAImK5PsdbsUCsV0RMF31vnS5/7Bq/dd5XAG5NoAjLQ1Dyb6xsY+TJpz6c39hg7ffKlKbzuGmpO4vkTZJLx7C0VhvEcRr2H0Ae0Nzw0U8PUdPw0ptPyuNr3WTMS+qMx1cQjkgaDOCZAsDPxKLgBCQky0zCFoG7rqIEg8VO+vjFklEZMaTkuXj292wXqGqB5jLUtFqxlBiJiKicJY0HBruD7Kv1xQLc1RPo63WaTWqOBFbqklsaaP2LmiMY+X3D4jh+nf7VJbanIzk4PLxlzYGGZA3NV+s0dIt8k6HXxUpWSolGe9jHKKl15hbHWINbyaHHC5a7ATraxiyW8zpDiTIPpqs7V3lX2vFSlnI8ZOAa3Ztdz30cfJYrLeMmQJJ6QU3OkaUq5XMS2M5xQMg5DhG3wtl89Ro+TvPSoi1Gs8FfveRyztAehqPhJgPRjPv/Qg9x1+1vJF/P87Uc+yHQu4dkLj7H9/vPcdtvr0YoWRbXEAw/+PWEc0bx8CWulypnvtXkyzljbc5Rc0KdQLlGbqVLMNbjUDpnPlUjUNVzXe974e0FMDKZCYdhu0utFiDglQaAqAqEIDDPHZOQi8zlEr4+RM8jUmFKuQqe7A+kMqwdWeOiR77F8eAmvKRmkQ/BAyXymzBoTe4zegusOHWJ7extNi+m2WiRqiZzZou+6LJlVWpkPasqkHOE7cO30Hl78ZslzL1/CzFTuf1AwZ5Zh7WnW1x4lc2Bt+yLnn3ucd/7iW3ngoYcQWhkyjTe841/z2le+gVfetsztn/kkH/mrjzG1nOfcWgcj2h3h7HeuUlAzdCWis7VOcWaGl7/xx/j7T/wIiTNBCpMsFQiRkRFj5g16zSFFqRG6EwKpUTYO8pEPfoBDP3sjqiIZTzw0YtpRgTR1MB0TV8QU0Ii9jI1uB1svICY+U4Uc47GHdy4hLkcI28IyVSoNG1UzOH1xm21F50xrh7wwmA0tPMXgxyKPQEnJKSkNmSOTEUKxiWIfPVFpZylTbkZB05G1jPecvwS5ffTSkNlKEbtQRKFAmGWMnAGdfI4GCa1OhJL2SIMGke4hxYRaSUHaRYaRgqOEdCKXge8jyhXMnk9fi0m3fW6ev52HvvNNIkLU1KYyM0WQL+O4Uxw6UmVuqULqZtQreYb+NpYe84GPPUguccjHRbp42KHDxFeoVxr4SUpzLcayHHqbIZcPaRxYBllL6fuCuQWdjbWQOAgY+Cb94Qi0Cakr8UiImMGaucIjJx7BXw7QBimipCPTPoP1bcyoiF3O4fYdFBGRz6poeQvHzSjUUy5sbmG0J6AVuHDlL7h+7yHqy8cZtC4Q+xGjLKXoaSgY1MpFgtGA2WodNbHoNTtc8Neozb8WN3FJHIPBqPW88feCAIEsSVg8uISwYnJJgVEQEPlgqhnhOCDOFPKqjl6pomhgqBoxCoVShSzLOP/tp+leOYdeqNGL2sQyjxQRoXTo7LgoUwrlROHSuEMlC3E9DUVYqDIjEioLVp1uOgIhMLCoFExGaUBLjlHGCaWqipr6LMzcxLizBkBh9nr2zr2Iy5Mi737HHZRWF7gr/x404yqf+/zHeehrD/GZv/7PhLqDiBKsrMqVrsnKwZfy62/9EXjb3fzET9+F293hU5/7AroyjRld5PLV85jB20nxCZKAOPFJUpdOcBZTt4i0FIUUJdUI1JS+56P6If32FqZaQlFA0SEZzuKrDlFYBtUmSUIixaZUm2LYPcfUq14OzzyL3y3AtE6n00OOTcYTDz1nkCqSi+OYceRyR72KkVrEacQJ3+BHi+ZuayqOCSOFTAqEEMRmjkEYYMSCgRrSMEKUpEF5folQs8j6AcNAQag5avMKwyvbTJqbRFdjDr/yTWTmvzAZagSey6C1w1SjQepLdOkQGAFapiNzMCsKjJMRSr1IOTLxOnkubD/H9tUT1FdehFks0t5pc/bMGjs7LTrHDuF8q8mRfXVarZhKpcKe1QV+/s2v4f7Hv8lyuYoTj3AmIYGfsuegjaYfpb/TQ40Nttd7ODsu/cYYbWwxHo9pbZvY9Qqnz19gul7EtiUNUaAfCsqezcrxOeaXBOfzDyK3NUSYELdSMDSO7c/RCQe4QxchJUoujy4bGIqKqk4Yj0aUDZtuEuKPNvHjOo88+RThiRP82F138rn/9nksrczA6aGmU2RWwtxMlerBYwjVImOLaPssQmiYSg7HGGEXXuBqw0mS8YtvfhvRxCcyJLEXoQCxSEhT0FQdKRScMESNJe1JSMWOGUw88kLHCgWKWibwPWxpEeuS3mRILV/GzVSivk+oqzQUk9gqUigERMGITGr4XoirjtBSBVsIKBlMhh6mqZIPImIRoWoCPwvxW9vEyq6768zUIZrrzyKKJr/3O19DNaso4ZcZT2Kuu+3HefIHX6VKQD80WDp6Hflkjk98+YPM1us0Lz0MwNc+8gPiUkB1+lqOHjxE29lk6D7M0NnAlHmUTKCoIW6Q4OChqwa6ohKKGNVXMPSUx+/L8eKfW8LIlUmzCKlpWIUSz3wKskAiRUSUSuI4pF6vMxp7TPpgrsP2ZsY7yy1kYYk95VX8ZEhlpOKEMHIiarpCFmY8PZygZRMOVPJcFgWm1JhJ6JIqkiR1cWXGKFOZjAKwdCw1om7m0KXGn6+dZ+raw5xbG5LFIYXaMm64SfNkE9Qqt975Wp5+8kG+d+L7XHdnAdUGzVBpFFaQZkI4VrAVwbxu4gYJW9luLSaOU8aOR6IkoNhcc2A/g6vX4yUqSmmOZ88+xUte+goy/RL9zW0OrKzSGw5od1uopuC+r11lOjfN0o/WyOsmxdgglSZjf4fEj5AyQNZzFNSI0rzBVs+mbDqkccLcah3NizDUBjNTZaarFdwow3U6KFKQqYJRc43bb7mF1I9Z294kyRQMAeMw4MirpkjSCvccfy1/9oGPcObsFj/62tvw0xGO7CFjQcfzSeMEEp1g7NHMIlaWCvzz1x7j3rfcw7cffJhxkDEYKCxPLbHnxpeRK1foj3uYZZ/6SEezBTvtFmYuRFFe4KIiruNjmHm8wMe0i9iKi1DLDN0RuiZJdY3u2KVQr+MOJpQKIf0kY1Yr0S7ByfPfYftsG6MErbGPZVnYeon11KWYpqRRRjJbQhEGod+kalh4ap4gUFCViJFvUy1oDCcOdthFx8Y0VJxQImSBQEhCJ2MryMgZWwAIzUbkcpB2SU2NcLLO3W/6BT73Dx/j6Ufv553v/CT/6idWePnNt9Bfu0TffoKvPfE0C2aff/qHM/w34DsXH8PvP8gfvO8PGW48wXdPnWdqH3jKVTR1HpUiWZgiTBchi+iJIMt25dB0O2Diq3z4d77IP27/Cr3BY/hjF00zmHQdTj0TkRETjjykMaFaKtLZ2SFNNFRjmv7l03x0qcaRa+dRvDGt9jpVowEVk+LEw9YsGvmAWFiMQodIqbN2MWTdVtkeZUyKMVtjh0DqyBAiI8RQM4hT4hRiAg56Hk+4klukQU5vYxWXGA9HhOMW9fmj1AsBznDA8SN3IW0DV5xE5lT6kU8y8SlkKrJYYOAnlLwQJwNF15CGQrVQIJv4+JhcPN3hlhtM9h+4jrNnzyC0lMVGnrPnnsJIa2xJjfPbWwwGPXI6bI+2mF7Yx7mdNgeb+/EXWyiaTr4QE4kCej6jnm/gJU0U08b14dpCmazgEiZFFK9HHA8YDXvsP7CHZrtLHCmY+RJKArHvcOsrjrExvIiSaeQWa3i+SjSKQDPZuzeg3Rvjuk/zb99wA5N7X0dhEDLYcXjNi27hzOk1vGQTbawRlIoM1s9j5vI884zD8mKRf/jsCe553Y188YsPYhT3EhkplqIwGfSYtnW2cpJQWmidCWkmSYVKHL/AWYSLszV8X5JJAyWISW0bmSToqoaUEqnqJGZC5gaEUUSlXsfwY+KiZCqJeNev/SbuZIgbuCSei9Pt0xz2KWYe/SRlNHGYTEbstLZwU4fs/F6WFkyeuvoUxqLOfD7Gtmax0AhtMHIWkT+kWjRwo4CYhOm5ZWY0j667a/E87rRwAmfX2WUyQComn/uHTyK1kKPX3M4r7zhIMXV5+Fv/zJnLa7zzHX/Af/iZO7DsBTKxaw65enQF6afsXyxyaKbIbQeP8pO/foCGOUcaFEE1iYlwkx1MX2AYu++OE4GuS0pimZf/TJ9O81sUtDKBFeMlIYWSQsmDritJSyrlqEovcrCqJulGC0VYiOEFbr91L5vnhhT1lGJxmqizzWOXQ/qeyZSU5PIxpWqDONLZHk/YsEYccn2eUVIKPQ2Ri9EjgZcm5EMFXVcpR4JenKHg8oVSGVUZoxFzoDjFU5f6VBcaqFOz1AsN1FKV8eXLhKUm55/b4PofsRj2ImwF5hanmIQ+sRthiRSqKqarIDOJpsXEmUI/S8gZDk5rk+b5S2xvjulO+oSez8rMNI9daFFbMag2IQhT5qcbrF3ZoVBrcOXyFpEb8dWHH+OVb17A1myCSKDaBUzdpBMMUaMacRyiGzk2nR4Vr4yThJTzs+h6QMsZ4VzaIVfWd3kaXoY0imQYlFZKjJ0I26xQkHkm6pB6xWHrskPXG1MYS5LQIsssCrmAh889yovuuYdgPMWtLz/O4dEOQgv45N99BbtUIDFUssRno9uhYgo+9P4Bb//NN/Lpjz0Ci3UyS8fwd1u0USoQboxaV9DCXfPT9Pn9SF8YIKDqGopMUHwJhgKKACVP3i4TRRGGTFHyFmEM89U6MRlpMmS2MUNrYwvdMjFNmznbor0zoFpLWVVixtGY+TDCTlW6wRjLKOC7QybBGNUJua76KrTBkI1qB0tTSAsWaRxiqhJpKWSKCVFAtWiTJX06ox6Yu4HoZ3KXDpzusgaDWENPHOzpZVwkv/TWt/F3f/RuVm/az1KmMUpbqLIGSkYWDgHIpfDmdx1Ez6mkFpz4vx7lnje+m3jbJBY+UglAjwkzj6JRIspCFEVBlRFJqlAP7uRPPjTDlSuP4IVjpowKmSrRpU7gKXipgztpY4g6E7+FVFV2wg59P6S6fCtHn3RRwzZ74hG/X11h7mCdY2qAahRZ31nnYk+n760RRyWMcMxnvA532x4+KlJoFFVYVFUyoWJZFlVL0p4EzMcZfW2W37n4HAeWZ9AUydlmm8bea4mdLkJNiTyfzOowt7qPILzI3kZEmpawSgHOGAaOjmlLRD4hil30XA7dSkgyDVXTUEnJpy66ZVIt7WOttQ1agan6MuvrT/P9cx0MvcROc4wvYiZDF4GJNG12NjsEoYtuFhi1BJVGnryQxAiUVGLqKqmlkTAkjlIMwyJv5BmMBsShx7g7QAQTUjfCEQaqG2PnVfqTjFLBYNDtIWLBoN1G12NKZYMDxjw59oBic8dKTHenjYHK2KgiCgVu/9EVem5C4EnccB07X6Pd7DNz9FpuPrTKqRMPc7pzGUvNEycaB28I+cpXfsDd91zDiVPnuHTuPIvzOSYdn3DnWQq2JAxj4kRBsQ2i5AWeCShSwzZUpGIgFQWpGiRRSqokWFIgNQ0/CtFNE288AKmgmirNZpvEEMzOzeMORsQio5CzqJTKdEYDGrJMGIYoaBRFwGAwIrEVZrIaIomRUpL6LvZ4kawT0x0+QzozwssM9KJO6OQo1SRKIpAiJq+VGYa7Pf8kiZCeitQhy9lIaaMMNbzOmNvecBsPfOUT9P0OD953gdMXnyKNDRABItFA3b3Xlpc9ytMKuqUSK3kOz78GLUp5NvkkdrxIIV1CsSx+9Mc+xWf++sVMz+2hS4iVmhRFgR+77Y186Hs/jqqmqFoORagoikohX8aYq7LkCTbHVZrbMaklsWOJEBrTUseeLXPz4gLD4QI7T5znXYvHeOzrX+bLK6sU5saMuyEvOVzn8uWIPja2mVAwl1hQ+uj5AZ0gIh4rPBn7mGTkvISSYnF0zqI/zvjV7phSeQ9WTTJyHfxQRZm4WIaJoqkM4x61YZVuuo09Y3LbnQXyZkpBt4kbBWRSod07hZkvU28skQVDmu0B5eI0tXwdN2xSz82QRRPa5S6GbOD6LdLIIV+rYRkKnVCSBAGVXIGROiRLFaphGafSohrNsj3eJFEr5I0a48mAkqayKdrMJjYiUglNm1AklPKLKJMNjNkj5HWFARPOPXSSohmQTDJEquB2Evpjn1xZIVV0Hv/EOda7Ga9+/Yuomleo2oKcPc+Lb3BxxjYzSynNuIaqpJSKDU6d20bHJvGHVOqzuEMPTctx04F9nDnf5LYf/ylu6G8x2bzM977/KBcvpDRmu5w+8xx+x6VlX8QKYOw75IkInJj84gzVgk67O0Q8f0nghQECkBH5Drqm4QYBMnTJkpQoEMgkI2Y3FR5PxhiWiUgyoiiiXK3Q620x8tokgYsQAj1vEcmYQr2AEiYktkaiGCSBRsW0Md0IXYUw3eX7UyiTb0CYjimN51lUJW4YoPktCt4Ax53Q9Uco5To7ze9ipLtVVsswGcVdUi9Ayoxk0uL2Ww7w1MaYcbvN1OwCoyTkre/4eazq1C7BQ2bE+ESOAXgcPV4kDS2SNEFLh3zrgSc40zY5XvptvnP1r7mlcisnB1+nsQb/208/wwMPVSib86Reyijcxjd1CrYkSlWk1BBZghQ6nucxcdZIRotcvnKS2nQFXSuwfu40195yJ89duIw0bM5tD+m2hmTCxr+0zsrSPPc2O9TXdvj4wcOMhc/sfJUVt0MvKnKPN2SPKUmTPAtpQJqH2UKOKEyIdZs1f8ykJ6g2MvSrI+S+A/SSqxycqbA0s8i5dQvCPlmsYCbL+KbA1AWuF6OYMSLNM0l1VKePpw9YmF5h5DqkbgctLZHFEkPNGDvbOG5CTEitbKMqAwajPkKFrU4PbAXfbTEztchwopHJkKliDguDTtmnQZEd6TEcwPJsTHcHpuZzuOOYUSsh0xTMgkq71cKLIT8+wk/d+rtEXouL6yeYL83ylZ37CbIcnh6BkFQyhcXVHH7mkLc01kYecSr4wXee5a2/9jKGskSQVNhst1ELJjnrIAW9gNPb2r0epB5u5LG8vIiiGmiKQ03VidOEPXsPooqYYWmJcq7E3QeuI/UdYq/Pgw99jdn6KotL8wyGLQxRZSRGmFUDRZM4XowTByj/H6oBLwgQEGL37+9HIZqqo6gKWeyjJKAgkALiKME2LeIkRqQZRtHGcyeIDIKhi54KMgFpHDI1P0+/1QEJeDG5cgE/i1A1HamkECfoGMi8hhPGiCiikGsQGSm4Q4qGTsAeYjshl4I26rFy+Chm/gcEugojiIIxmiJ3uxdS5T++95eYmj7MGzG481W38Zf/5U/50mc/wJvf9GpmKnvo9jdI/BAhMjTpQwx33nUdUpbY6e6Qqy7x+usF3/jMi/j5T72VjbMnmLvtU3z3ob8msL9A6qi8Zv83+GTvdei+ytLqPfyXrxwjSJ/FUi2yUEFIIBN4QZ/1ZydcaX0JKykxUhcRUUJlpsLVSydYmDmGYaX4To/zZ77K3mBu1h8AACAASURBVNXXEGSbbK2NyGyfllXi9vUr/Of+Xl6xP8UPizRLVV5OB8036KcCD5uL3T7/0u5QtHPU9YQDZQ3LElSKFR6+93pe9v0nmC43GIUG505fZGKWKFsVvCwhb44xIwMpUoy4QDU/g9+HvAJRVqGY5EAE2LaNnxoYMma6VsIft7GKVcoVQZRZRKEg6Iw431pDSesEkx6O6tOo21RK4AQJg3aT2akSUkY4rZBxAjN5BWV+GstSeeST3+ZNP3kde1ZWOF5dxdd9NjfWmCoVyecsOqee4O57v8hf/tXfEHp1XE+yurLIk0+2yFcLZEnA0orDszsaucI0hVKBXneTTOTQchab2TTtrRG+0kQzUmYqCyRiTDjskKbQqCyzvHiMc888TUKGrhlEypD2zg6lfA0/CTCtMlkQUSzXuLLdJJ8zyeIlamULFEmv72GrJZTKgNHVlOFwg8X6KW69/jiNl1/PfV96/lTgBaExmCYZiqpiqDq6qRNFMSkqUkqEmiEy0HSVKA5RVZVMKihehCZ1LKuAbecwNIEiU1R7V3nFT3wUVcMoFYhChyhLSDMFWzfQNBWRgaqq5HUdy9bRsgyFCLVcRDVyGJZJpZ4nVy6yuG+FA/v3Uy0VmVJsAKJojIwgFBG+M+I7D6/z+MPP8bcf+jBhVuXyM5vUi/P8yZ//Fb3+OmmcoSgQZwlJvHtG60qLZvsi4/6Av3zfp/nlu/4V7/6Jl2JEgkK+wWN/8TA3rbyHl9/+WkqGSTab8pP1f+L85pBP/OEzLB2LyCkmuqJjGQZCAUU3UKwKzz37BKtLtzNV38NQeHR9FcUNmaQloqzPNz//QR574AtYS6+FckQpTrGqKiI2CPwYERv8m+EFbj95lvNOzB8NJK2djHObTRzHo1zSuHmpyh2Lc7wob7Gowzh1cKKIdqvL3z30OPvqJcZXnkWM2qhTKYv5OmomKWplCsU6ikxwJiEeCd3OADUnGQQuwnRohR06LR9ijTgdM/ZcTL3OUvkYeaNAc5QRDIdoioeXy1ASDaMSU1/YQ6KGFBSddrNN4mwz3ygxcRIwGjTMKkVTIRyHLE0XEcUQx5HU1RL+yU2ufucM3/70/XTOjfBPDyj0xly7N0djVvJrv/4OAsWg3V6nM5igaRFCh3435PzVhCTJyII+iRjz9p98Kz/72hdzcNnl81++j04WELgpIlW5snme555bx08EjZlFOq0WTtdnu9fjumtvxjI1pqslavUiaiFmrlRDV8Y0WxeYTDrowe4QXGXK4FW33UEIlDWLRqOGGVogAmamFlmYHWBNwR+86wNkyfNXBl8QmUCSpQyDkJyhEqcqVrGG1CUiy0iiGDwXoelkUYJIIQpGRLCraKurBKMRpq6QopIFPZQM7IJNfzgiSRKKpo2mKsRhgKKrWEaFMJzsZh2GiueP8AMfNZMkUYaSCgQZMtZRBAzGHjvdPkMvwP8hESOKXcwkQwiNP/79t/PO976flf0H2TN3mHf99nsxKzbLMzbbzQ6h62GoFpnUyBRIRAAJ7AtvIGhNWJA6b5ifY3qmQu+fH+ZNP/MrfP5v/4xnHvgew47HDx48QWQ6pF2TQs3gt3/kQcy93+G6t7wUS9TpNvtcvLSGNxmjaQ06zSaVY7vy1CV1h30LLyMYbrJ5dZvFhsnVbROrchtHDk2zvGTTvnAZUwHUHJEa8OKjR3j05LeJc0Vc3+JXNj2G6Xe4N4YiMO3oeFvrxKnEzwRequOrAWmkIpQxernCzTfsQ7YGaLLMoDXm4C1TPHcRAk2hZKSUNJVRJlECh0EwptwoM2NWWdtMcbQU6XtYBQOpmGh9l6YzYv9N13P1ygWmZkySJMObZJhxkUq+Ru7YIpevbhKzRU6vo5ZDpnIRanmRsDvCEzGTIEBqQ0ChWCzR73epWwaVqWkOz13LJh3WLw943Uv38x/e+1lWZyy++UiTm44eoDdKGUy6/N77/k/uff1PMVtcZWl1h5OPZlhTTbykgKlp2DKk3RlwbtRjYXo/luLw2Q9/nVtuvI1BFDJjzWLognX3Ks3WNqPeJkaxyKR/geXpKufOniMTKuVciaOHVyEVdCbrhFtQy5n02htITDzpMWkPKCgJsWsTGCpOHJLaZQpWm53mOYQ8gLp+gdJMH9F5/vh7QWQCiiKwrRLoBSwzhyYU0jimZOdRM4lpQBK5qEQM3C5CKmAamEaeglXGEDVKpSUsq4JlVSiWG0To6AqoqgK6ShQJMkUjGLRIQhfdMBFSJSVD000UFFQh0XQLzTBRpMSLQhJi8naOhx89jyIjSOoAyCzBEWAqMbfdfjtkHlfOPc7eYzcSZS7/8uUvUZ+v8rH/+lEUTScVIIRAxO5uLQK49rZXM3vgGqbK8/zpe97LuHWeKwOf4OIF8oM+H33oq9zz0z/Lq99yjLuOH+HaW+dZWq0jZ+uklyWPPLLDQ/c/wfqVXV7E4RsOkmvYfOP+TUrDRY4dXUJJhtxUU3nVjXsJnYRICOpGk2sON9g4cwo7gj1zU9QrRbR6hb2zOZqXNlH1MloUE+sxw3gbXa9haBaBbnDej9kIVDqKzVBqoFmUi/MoWYCSxeC7THbGGIsGaT4itDQs06Ez7CPCkLTr0kks8naBxeW9HJ6xaG5PeGZjk6HTI0slufwUveGAkdfEM8GyLO771pcY966wM4qIJiP0XIlua4NJJ2DQ3wTyXGz2ae24ZL4gn5unEIBVmOea6Tm80Q6KojJ0Y5wgxNACUiMjn8/zrcdO8oOTz3Bsj8XTz2zyjp9+JYevWeKXf+luwkwln0YsNyQy0vnCfZ/mqc1nuXBxSJhbJx7NEk0SIj/CVSSKIdm43OLchec4+fQlFkomH/vUP3L85ltINUF/3KdWr1LW8yh6iedO7tBYuZ6Fmf0cWd2DLiK2t1qsrV/i3NpV+msdNLXMTa+4k6WFZewk4Y9+9y9pbV6GSoXLV08y2brIhUtPM2xf5tylFlJIxk6PJx66xOtfdjca/+upxP9rV5ISj3oUckW8zEVkKpZlMOwPEFIlU6qYqY/UVAQWiq4ThDFGXiGKEqpLJQwB1XqF7e3tXYuvKKEbgSUUoiDG9R2ErrJ333E6nR6dnS5WziZXqOB7IWa+RCJMUn9IIlSkSMlQCVyXttPlHf/ut8jtXSGmDUCqqMSxTuS6NPsC0owP/9f7+cKnPouTDMkZMftvuIVML6HLjASVOHVJM513/Id74Y8/wePrD1MSRTSjwKXNy8R2nivPnOLU2oAzQZ9zDz1AGBukQiHJCZTUQjfKNGZv5qV33cp/est7uOOld1FcnOXqZodKts7F8xdod1JKPMn8DStk17ye765tMzjtsHrdHjpbI8plg1K+xsyx4yzoGutqDUtC7HUQdhmRH1POdNphhB6nhNIkS1MyWSLKfKzKLJ7bIUwTpJC44ZhMr2DodfTCIlYyYGu8g+WapCLP4nyFUyfOwriOWlUp1OfwBs8xqNQw05Ctq6eY94sEkwzTNFF8h4vNdWp2kSQQqMJDKibLjSWSbEjvapNypc6kv423kZEaO6jBCkZ2lYKUlOYMStNVdF1FrQrq2ZDYnGHeM0iDDF3JqFoKmbUHxQxojbo8fcHljpuO8/DjTab2VLlycQ20JZ74loIRmEwvVtheVwhHQwb9mNU9dS5c3mZ51WQy3C1Ya7qKosXEzSFraoeB6bC5JVme3cNP/fKb+eYD97O0vELs+5RnZlErJpWiTUFN8CY9/InLKHBZWD1GsbuNbds8ceYEYy+hGA5I/Hl8chy+5WW87/gCZ599kqdOPo5QHHbGl/EjlTTMA2MGrkVVC0mCFpWVebLAeN7we2GAgBDYukYYBwhFI4lChqGLpksM0yYNEyQKiqJg2RJIUEgQiYAsI/YC4ixm4jpkWUaSBAShRxWNJC/JsoRatUoYRexsb5KlkkLeJEkS/MAllRnPPPs4e/Zfg+9E2LYFUoPMQyg56vUSS0euRwQx7s4uCCSxQl7C1JLBh97/Wxi6ydt++R5+4t53cPHUk3ziwx9hbXIFRTcIJhMyGZC3NCbRBG0mAGDdvcQ5Q2NRM7l2o8rpr38DedPtPPnwB6kZ82j75+h1AmTYRrMnTHoBCk36Gyqf+eh9PPPYV3hq7RJcjKi4Jp3l42hLNzK9Z4fW2XVODGJGnTWqlSliPaLV6mHmTbRURyGmEriMirMYQZM4cDCFTeBFWHqRrJLR2hjiE6NJgzTLSBQfTVeY+B0s3SQKMyQhWqGIqrskUUQabJAW59gzNcVC0UOPd/X8l/ccYGvQZDL0SK60ye25jnStydiC+X0lTKNAwK5uHpFkoT6D6/oEfgqaR0UtIQaCwBsSGylnv3GFK2GfqUQQeiqu3yKOUoIkplEVdDc8tD0RB+pVprUyp9bWcWOVYZARqYJh7FOgB2mefDEjFhq+yFOeq9HeeJpytc7wyjp6JeXMRYWndtYp1xeIzSFaqNFqtSgaGUaaUU1ixmOfYRwyPzNLReQ5dOQI3mSdY1KiZz2CzoBSUcdxulTzBVpXnsW0VJRkL5eaQ1rnLnLdkUPMWg0unHoSvV6gu92kdf4Kq4evY2bvElGcsffAMYLhkHrtOMcPzZB7qc3td/440ajLD773MI+feha9mCMlxUmbmIUqp09cxNBf4N0BRSp4mSCvGQQCTDWPVBXSNCZLMgxdIQxjSCBRIMnANvJkyq7EkzcIEKqKUCWB64CioBdKEIeIKCQTkmG3jW5aGIqJG0akkSBTMnJGwmgyYHXhOkgks5UcsYhIpIlwFGIjY2Z6nkT3GaQGRjGCMZhZzCQecPKrz3LtrdcTpBF/+Cd/y5fuO8HNr3gNj57bYWXPmGQSkkkXUh0/nqDWFulOdmcNlGKVkjthRw14ye+9hT//w99i+bq7Gb/3N0kqNazNIZpMkEaRcKhSsPJ4aYdUdrGLc4wih2uO3sDlCycZTsaIS99HiR5BCgU7jfjw+x/hzb/0b2kIjVhJcVSf8Y7H6h37+P6Dj3P82A2oyhY51WA76uHHBaZSaIuQqlFmrp5jszcmCgNULSOJJZomkbEkSTxiVDKpkSvmKOolOh5AiN+5zP6X38z5p8/Tb0sac3nmlsscOSToDirouSKBv0UgChjxkLkjBUZMyJkKCIlnqzQil+m4QRqauBs+U4sV1jtt6oX9kBWZ36dRqsR8/Kufo2J6FAwDU68Q4FNoSPyrI3Qxi9+ecLLQYZRIrEKBwB8SJjGZUWKY5NHaI/besJ9R7yo9b4H9+0c0pq5nY32deD4hly9xx9E8N7RW+P73v4/oWgwDi3HmUswUOn2fWOQgMQitCYbqsYHBK47PMxhN0+qvcc0t9yKzjFldJwtU8saIxbkldKuAl0ZE4RR7p6do9x2+t3GCm190C3g+TjCFvTCFE0U8d/oJTGFRrtnsdB1e8pIX0+u3mS1fy2DnFJalc82Nd/LiV7wBp7fOxz/7MWLZ4GRni8Wly4ydyfPG3wsCBBAKmm0y+aGGW5g6qFLHNE2SNCRJE1RVI01jZKohlF0CSSYUsgBQMjxngqIomFaOJAtJQh9T6sRZQpZAahjEaUbk9dFzFpNwgq0X8DwHXdfJ5/NEQuB2+wRElOeKRH5AnMYIIYlcjSwa4fUtAAI1xdJz7Du8F8s2+MRHP89/+os/5PEfPM2j35wwu3yE3/j1e0gZwA+JQIpeIWfuMFtcASAJt3AHKWZN4T3v+1nOxc/yS69+KTJnIHIFJsGINI6IhyHoGlmiEKeQpYJgMGLdmdBYVhm3+hSqdSb+EAVBmmakIsfPvf0tlEKVf9k+TylSCcMJwmnyyD+2qR+Z53vf+jLHbjpISVkkkjpTYUbf9rAmBmpOMlc6RLN7kljPiJMUS1NxJiPMXJEkUjC03S5H0B7QK2SIco6anKLVWadRbjBeOs7mYB03jrh0oUUYmYwHQ0gC3Mghnpxi7zU30HlqA3nQ52Kvj6/ZVMpTnG6orOQvQ5LROLhC0oxYmNnLxA1wPI/R8DJz2jQDX8GLFHQR0PPHrMzAbN7kdCQQGx5y1mTZKHIxTIllQsoIqzJFWRr0AqjUphl2J1gyz3e//VUW33AbZtlm2l7lOvVaLl04Szby0YMRr3rZi9jsrHPqtEdnGGKZY5SKzuZmQr4sKdX2kARj2jtN5g6tMHrqIuXyDHlivvvICTba21TzU6gVncRL6G+3UBTIVetoto4iE1bn5mieuYxalEyVF7jBPIwQIY9++yT9wjTDIEWM+lx5bgZNy3HxyglmZuZp9yTLe+ZJUSkU67znd2/lG1/+KFao09zuIcTzh/oLAgSyNEWNYqSlEmU64dglyjy8gUMul8NxHUyjAEKQhcNdQw5NI0sTBCoCMA2NNIrxfRfLyhERopg6QhjINCJ2A3RLI0EhE5JydZo4cEkSBd+LiCcbFGozhFKgSOO/M/fe0ZZc1bnvb63KVTvvk1N3q9VBrRxAIIIQCDDYFskiXMAkXxmDAdmAAYMxDwHGOGAM9iXYxiIYkG1MtiwZLIGEIkqtVre6+3Q6p08+O1ZO6/1x2ncw3rvYfsPvD9YYNapq1q5Ve9euNWuuNb/1feR5juOZ6LnJzf/6AzpryzgNiTpzMy0syrgEMrJU0Utilk6v0G63ecvvfJQ//shHuHTXE2jWZ+gOVzFkBRH2uP433s8lrQuAH3FO/gycdsDhxx7ndLjKMDfQ4gGFEFtwaRRBqvAcj6jICNMOFbdNWfQ4e+coB46dJOlvgGEwHA7QNEmhFKZmkLsOydEV+jKhEvQxpscYtcc4dmQT2whY+oM/4KHlA7zmre9jY/vWG3hJxNRzg7jUYABmFco8RMgtMFJepjieR5KElLqGlgY4jkdiO0y0x4iCENM2cEemGYQBE2M2o6RsmzsbSy/Y07K5/cGYLJHUPZfexpCD997ODV+5g6lmQhFnVFtVMiun2DxONiw5HRyhs9olrc4Tx5tMNWYZDAWVvI1K19m1Y4ywv8l64FOfaTAI+4hM4/h9S6yP1FlcdlhpeziNGqc7ISOtvXS6q/QyGBmts9JdZq42w2qUs/OcSaQ0kZlBmZSc6gW0ZyZ5eP+jZGoFM0ooUWzfJUmP19C9FieWBmRWjKlNIIJjdPsmqpQcffwhLOmx5m9y8PBjFFmMpnIWjh9lJp8kUBGtyQYnTp+k7BVomwWxPsJY7QQrKzbnPfFi8rLg1MYSl114DU+/Zpr+ykkGWczo+VdgGyWPHXwYq9JCCI0kK8iUwdrKMnmZcPbcHHsveTYXP2Wcqi358UOHf2b7+7lwAmkes7R5nGq9QhKDEApLVKhWPSzLocxNlCgphEFeFDgVE8dpkKUxQRojhCL1B+hSYAhJnPjksc/mcIBumpi2jWmYqDwjzxPSFAotwSgy3FoVy/RI0iFhNMBQJVKaeNJgkINGyVf+6ZvMjYzTWfURlXUIICsFpYKHHz9EFsKLX3glL/2VA8zNTfGCFz2HQz+5gytfeA2eYyKVJEm6fOMrNyFEwpH5ewCYmNxHEXW55NLd9DoDxESDz950O55ZUGAxyLqYwmAYD6laOkGhSFMfWyv48J98nJe/+mUsLyxwaP4+Ltr3JBy7QawXyKKkKuoMKznmWo8o6vGtV/wGf/gPf8LLP3EVv/faf+CVr38D9Uuv4uo3XsePb76D/esnabkT9IYldk2jiAVp7vDZG2/h/HPP4dv//Clu+L/+jCJJQGnYegOtLCh1jazrk8YZ/bKDCE2e/OTnsr55B1li0xx1cI0ed9034JxLqwxjgaW1yNZ9wmKMWi3ms/e/nn0zUwSlhXVMYDsGvbKgnYM0G6zJNcxKm/HaGFONbVwwtpMozMiTmEcGf8VgcISJkTqeiBkGBbbR5CM3vJZsZY1Dj+zndDrP6pEa21szjEUeBTXW4wg0UKnN8tIG6ytdXvK0F5PIDEsqKm6FfvQ42DVmtk0wPfc0KCS2rnHy5GNs9G6lkwkmaoJwMKDsGejNBrKW4vS7nFq5l/5ih0iNcbqoMlEbp+I1kFJnGEHH94miCE2ZJL0M4a6jSNkYPIWLn1Anyha5/V8f55df+krWTtzND+59gCueejnaIOLoY4+RkHH1065hdX2NlJhoaT8PngzYtvMS9uzay+LBg1TdNpEsSQpFWfycS5NbhsvMzCVkWYZr5mQ6mKbakvZOcwqRMez2KIsMKSx6QU6WLuA4DkopTN3DNl0MxyBNc1zTBK+KY9mUKsf3ffIiBTSUZWAAhshIQkWaRYi8xHGq5EWEpmkUqmDx5GH0iodj2Ty2/xHSIsWsjqAn6daX1nLKoMO1L3wFzYbD0flFLn/CZUgRcPLxRa646Kl8+StfpYwFpm3x9CdeSZmCEDbTExcDUKZdqpU6w7TAUjXmjx5EpCmTcxez2lkmi0tyFaNTEAxjpGlR5jF2e5TTK/OcNbOd7sY6P7xlHqVJcqBUEgwLPfMJVjdJgwS9PgFxl4+940/5xJ1/xtxonR+2XYY/uo8n28/isVMLGLqN7w8pipKg6FC1p9AHi4SaTpQKPvjej/IHH/7UFue+1CmjDrGp4WVbyL5C19F6HkUr5eShn3DRVJXaVB/VmsQohuyajlk41KSTa0z21pBn15nspwTeBLOdktDu0pxsshFGhL0IzTFIcPGH68hMkYglloIKnWQRdfo7mNUG4XyHdL6HMD1GqgaDIGdyW5VoRDHfXMWdaNDe+2TOM34FrzJKzW2TxLAvXUezKmhlA5Evc87UDqQqCIKQTqeDoZWQaqjC48RjS+iWw/yDR9FMDc2QZP5pNkOdE0c3mZisM16vcyRVjLsanlajiFb45t8dotmc4qILLNqzNqeOLtIcGcM2dKqWzfadeynjFFQOrsWD94R4bsFwcJpOdwTHVkw1XYaLx+kM+zz5kiehSwur1ua8PRcTDteI4x5SzzCUwZ5zLsdZPYVlJAw7Qwy3jmWYeLZgY2MNxc+5EwBFoiLKKEFoW4OAKlCgNIQpUAhq9Sk0TWJIjSzLKUROogrICixTp8xygjiiSGLyRCANl82NNYosxau42I6LUiWGcsgLxZGjx9m9ax+265DGBRXPotfL0S0LVRZ4TQ1NSZI4xrMNGiNnobKc0AE2FpBoTI6NcOToQWanp7nswnOZntvFU568l9vvuJMxx+Plb/hVkrUMlS3xtje9G9NgSzEm23IkwmgQDHsIsc7qqQf44B/ehC50wigjGARk5QApDFAgNEGZlRRlxHBlhM9//ovsOvsyxifGqDYKyAWmoSPSknAYko1VcPwYo7KP+z96LQce2A8by9R5NkUtJzp2irTIePDbx/CLCMNsoOkKkQpEqhiKJnNTDf7hpt/iLf9yEBKBkAUCEKIgFzY1t0oa+1AW7B6r8uDmSV78/N/nu9/8HHOvHUcXbXqdBEfZ7DrnPB755H7skR3I6TGkN0qidShXVzhyapr0kS5T40NOLm1ybH6Rer3OC64/F1WmoAxy3yAhZlEdpqE3IF0hnu8TOJKpSouqE3KqYzHpZgSDBEfpiLRPJjJOiTVU1yZbS9DNAstoUAYlmtBZ7y3xkxUdpQRh7DM+Mkueadh2C7faRo5sp1WbZmxsgjyJcawqP/nBX9Bo1JiaLqlXBaQ5dTtjtKoxiC3QWrz5lb9EvbqT3ILlTocnPrEBhsfYSJ399z3E6YUlRtpjzMzOoYse99srBPkIKxvfJF9e4qk7nsO+8xtU6joLCwM8o45ZlHz/9ptpj0wxPb2HaLLAsBWnl5bwai5plpEmJa4V0gs3mJucY3O4Siz79PyVn9n6fi6cgBSSJM5x6hZGYaDiHnGc43kmSpU4bp0sy9CEIox8TN0iiyNMaRCFIWFsYhoGcV5QcRtIckzHxtQNkiTCtHQUEsNxQGmQ5Jx34eVoKscfDInShDQxCYshRS8mK0o0w6TiuqS+T6U1xurKEqOjI+TZFtBHlJJbb7mN8y44H7cywe6zZzl8/Mf4vXNZOnmEuN3g1pu+gTLB7/t4RoPX/tobqNSq6GpLF67WrCJaNbJ4gr2VfcyN3sbh48e4bM8M31pdxJEWiVRksY9RbVB3PD7/yc9y5wMH+PQn/4hXv+KtAFx+2aU0xicZ9rtQCqQtqfTmGaTwwZdezB3fu5Xucs5Z/Zhn7N3GF0uF5VWYmG3z2CNH8NqzJGWCo+loNQfbNhFVnUue+VJEmnLj5y/ljz/wSk4d3sA3dEwD9u7dzv4DD0B9L1Y5x7nnXkU+cRFf+as/ZbzdJJY6KxunIQGURlgMMN3z0e0+i4unsDaWqGzfxnXP/x98+6FHOO/5PokRcE7scom7B0sTROkQ0y+wXIls6diexYifokkNQ2ncttDBlBqGW3Jis2RpKcYzNaanmhj6kDgEaWmEmz2UY2NrkiKLiUSJXuhYRoNKYxZHKbIiJTV1kjJlGCk8c4luUCMLclYTiezoZHmIoVco55fIBz183yAKSwxNsq1uktjnQXAP3sSQx4x59GQBITR6KmE8s4h6Gl1nL+dcdSE74wJDN8myAlGMcMP7vsZwuMrcjrOxbZdGzWU4DPDDkKddNcrd936DL93yCZLxnHV9kaOdmzGXEjS7RhLndIc+jl4yMzPHTzZT6GU8tOIxMWWw0vcxzJ9zsFCeZ5RhROxrpKZGJhS67dAPIlzboUwTBIqskNjCIswzpFuhSDIMzwMlISuwpY7IE4QhCTcHKE0nSzLIC9IsJD8Dn7YcEy1UVLw6umVSMS0oBS2vQugPcW0Xf9Cnk66TZwnBoE8SdsniNt3BFk7AMgVvevs72H/fnXzgk3/P+rED7Lvw11g5/SgTExMc3H8cv9dFeTZ7Zs9j7uyduJUKaV78b4VYw7KwpIbyaqRxxic+9ddMVmzKXp9bbvkmgfC2CFd1DzWM6PUHpMOYxx56BD+NuPvu+3n9G15DVujYUhDpGpSgezYfuvrFOHrMciekgb0v1wAAIABJREFUk51mbvdeBp0+U7aBv3ScfqTxx5//O157zdVknVVKQgbCwZCKrspRpeSmE48iwpxbPm3yJ81n8eST3+BrX/04yUaPQXmCowcidlkRD68d4gvfSPASg+dd8xyuf/87eNd7X8fszhGqbYFp6mwMNymdIZ5usql6BL2cfbUrOOdpV/BY5xG+8zd9XvumOqmnI4qSvp5SK2KySR0ZSdKkpNs7zdjIKMNkE4o2riFJcp+4qNLrBGyfrlJxMgw7ICnb5KWPq6oYZg0E2KqGH69QlhEmJsooKfIuYakj9YyGaxPFBVbDx9QmsUZCFE2KKKLAwjRttDjHmdqJK04wXM6Zqin8WOdA3Ofp3MVd6zkVt0WgUnQN4mFOkkSc1nVSTWN48h4WTz9A7mk40mU4HKJVDfav3chGomMfdFFZiiZzwjShbjYpydjYHFJve+hK4JoaNU2wPhhQyiaWN2Cs5qFpks1wAymbDHWFnSYcf3SAZpVkP++kImgGZdUGJRCZRqPmEEcFaAXkKaXlEvp9hEhJ7QYqz8nXApQm8aoeqaao1mv0/CGiLEC3yIsSQ9cQtkGma5iqwHEs8jwhlwkkJaiCLBxSJFuz+nwNEDllFiJ1E81w0JVBkUvqo2exHq0TszUbKxj2+fGt32X4u+/lgr0X8q39d/O7b3oV17/5OrK4TU6Pj/7Re7jhj/6S4ws/4dlXfohk6OPaW7JhAPFgSGa7hMEmFdukVbWgTDm+dogPvvVtDAYr3P3oUQ7OL3DBtrO5+peeR310nOVgyMfe99v82ls+wuZ6h143oDfsk0QZmqFTJiVv/uo/8YN3/Sqv/+qX+cYbnkunu4qRK06tLpJmPpdf+jx2TE7j1hskcYDUbFSpIUow9AZjzTpUfFYW1kjzJjectcjeHeO8Zvel2NMXM3vd6yiuqTDWC/lfTzR5yb88BNMF3/z7z3DTN76JjWS/F5NKSZGOUhh9RmoeuT9OMhiiCofDd/4bL//+15irhWxrTvPVL6yy98lVJqfG8NKYDV2jvqKILIEhPUwtZSmIicIhxYmMiRmPB/aHbB48SZEprrzK5Ue3r7CzaNOuLOPJGnEQEyUpVcdGWhGW7SGFTRSEbCZrlImBV80xIkVQDBgKyZzjsT5I0dxNPDcnSwOomahUxyh0jj4+YOfTnsDj+7+FoapsazssHQ94MB5imS4bUYRVNymyglrNQos1SinITVCJoFuAp0WEMkGvG4iyy0ZhkOQJxQA8QyfWbdK4YDE8gatP4XgNwuGAQrookVCu2+g1Bz3vk0YetikZJH0a9giIgpFKjY0woRgBJ1Vncmj/5/Jz4QQkCq+QJEkClklnM6Bm6mAqpNRJs4goTfH7Ayan6yjNoNBSdM8lzktMpfDj4dYgn2WiZQVOy8Pv9qEoMW1FUgrMrEQoByM10QzJZreDZuqkQqEDmVKkQcJo02N92MHV6kzumGIoMkwtQc9T9DOYi+1n7SZfPMEX/u4mhprNQw/ewXW/9kbG6h6D6CTTXp9P/dlnUUPFeedewnhTEpY2ka8wrK3bXupQBH1sUyMXBcNOn6Ym0UKDbDBkEAp2jsyya3Iau5ygu9ljomXyO7/xBvYfWeFTn/sbLjj3bCq1FlmusBwTVUDhD6lPTPHIsZDfu+JyTopxLpkd5e6HH2AfbSKjwSuu+01+4aqryYSgEBq6kuRZgTBBy31+752/w5ve+W5qXpXrXnc1n/n7W1gRBstzBffe8udsCx9g9a6bKWSVv9yzjVUvRJwOqLcmGG3VWVw5TBJokBloVkwZG3SMAcKewTJ1doxOsJD0MUuTF+55Dr/y1D284/DXeMaO3ayvaOgljGzvcGBjE6cc4LQMlBaiDnssLW0wM9cmFDmt3aNkqc/kWbNEocPcJQKRB2THqqw3usyMztCsQidN8HsxRmlQij6261EtbVI7QRU6UZlj2SZjQhBnNdKsg5XUSdIEZY1gFwOkULjOdh5f+grcE1ARNsdWN9hnjlO4GWXexshMinCDtPSxaROEMY6hY9oOg6BL0zNoKUlYKKSqUDoV8rhA5jllXhDnAZqhUzEaaK6Ba7QxpYmle2SWTlSsE/s1NEdg5ikqc4llgmnpVGWFODbxaiVZKhC5QGYGYRryHwQCPx8TiEAhHJOyLDH1LdELak10u4q0KyhdYts2kzPTKHLCMMKyTPQ8wtFLCpFujaLLYqvrkBVkw4hMZUhTkihJmhXkhaQ0SpShCPOQitciCArCWJC7VXThYrseSZxi2w5l0WWjN6TmtnEThW4a5MYW5DcXGV/6+pf56699mUfv+Dcuv/QKKBNcp8IgzskqNS6+8BK275zhVS9/MYf2309WZjiWvRWtAIbSMAyDLFUUicLyaqBJBt01Ntc7rCwuEBdD0jwmKHrs3rGTf779Tp7y7KtpeBnXv/HVpP6Qr934F+hSoGkaSpRIzSALh1x/09dpb9vOpS96PgfXukzsfQYf+pfvM95q8/E/egdxsoqmZZRlTpLECAqSJOeqKy7nwcPHUbbN2OQUJ04vEOUR9YlZ7v/RraDrTMy2mT37HPbOnE2lOQn+BhVLILVJ/L7k/e/bw8f+8gnccONT+b0/vYj3/PFlpD2f777+F5m/+XP4nRNIOc2ec2Z49u5JDiwf5vy9c9z8vWM8et8hNrUuR+YHxOsDrhhvE+43qCazFLnkmqfsoljPeN4ll3Dudp2rn3M+s3qLqnARKyaT0kYbwFRZYXXpFH1TkSUx7ZEKpq1RpII0LDG1FEMVWKRUqw5+npEWGaG/jKklmGVG1aiSFUMCX9LfzDg5fz8yKTl5eoWNUFGNFZtk9MJ06xmdrTDolRR5lSg2MXKXsrBIh1ApHMQgYXV1SB6UDIfryGwJAx0bj3q9Rm2kgW1aRLFPGg2gHBBlHdL0FFGxToFFYzSm2gqx2n1qYzn1ikaeQJZDa8qg3xuSaIKm12Ku0Wbb7CxS/uym/p86ASHErBDi34QQjwkhDggh3nbG3hJC3CqEOHJm3TxjF0KIPxdCHBVCPCKEuOQ/9QFCUsQZZr0Kpo6wHZIkocxA5QpH6TiGQUaBbpo03TpCpDTHJyl1k1QWmG4F26rj1ZuYFQ+7VadWb6J7FjolEQWmY6E7FQynguU1yFFMjLQxdY3S76OLAsfx6Gc5ubIIpcntP7qb/mCBQFjEwRAz3Uq1LBw5xNraBtv3nsvK8iaf/tKNvPKFv8zS4jK9Yp2F5TXue/Aoou7y/du+xd0PHEcvARlQsJUdKHIfSoElBTJLiPsRwzAm6gRoqSTRTaKsRDNNGm6FiX37+MOPfYhWQ+djf/FZnvj81zKz51I+97c3UhYGJKDnGsq2yBKT+rjN27/6RfpRwNS1L8S5dBex5nDpBZeyurCA5pj4vo9QJUIX5CLG8hxe9YZXYMkq7fHtPP9Jz2GwnmFlBqc697F9x3k8+8rLWPjhbawNM7JWBS3Xcc0aQZFTOgoNg1leQXLoUor7Gxy4eYlxw+F3/+x53H/wbu76w0/w4899DPSQZ110OUcXD7I+XCANlpm7FGYvtJmelcy0JS950lXc+m+LbM73qUWCc54wyfyxjM6KpD906f0k4PavLdIOJZWGzrYnjeFNmPQXBiw9uEayv0d03xKDlT7Lp1bYTJbxGxKzDmmiCAodx/HIwxC3tBnkGwjRJC1hGA9YTQbEsU83HRIUAxx9EmVPors29VEH0ayQDkPqVYdc5ZyYX6EkJxkOKYtVkmSRIDjNgHlyaRCVNbRRB/ImaWIRZnWCIESTBVqUU/QDKCsYdoPRWpsiqqLiHKFaSOlS1bayZUXqUPhtskCnWjOxmyWNps6w28EyK4hiSDfeJM5ylvuLCO1npwj/K5FADrxdKbUPeBLwZiHEPuDdwPeVUruA75/ZB3gesOvMch3wv/5THyAAoeFYFQwh0FSJpgrQShQ5hS5A1/A0E1UmSF3g1lukcYoudRw8yjzHcDVKFGEYkkQRRS4RhUkYKdrNNlmcQpFgCInIBVq1QoxGpdrCGZ9G96oo3WVkbJqq4zLWHOfb3/42tt1CqpQoHJKqLcLGt775OkbGJrH8mDRM+ezHP8N1b3gzVz3zufQDuO5lrybNfB675y6M1OSaa65h2O1tObdiqzsgdY1SJKQqoiChUjOQZKwFXU6oTZqmzujYDH7fZ8NfRuoFO3bv4a3XfZyzRvZx8I6beev1b+bX3/RbZEmPTBZIQ0KeYVpD0sjl2P57MaMU1YuZmG7htqewRIYoSuIo2kJhFiUUIKVHkWrsGJsh7cVMyArOzCQrK2uEfpem0WLx6Elu/f7dtFvbifx1Hn/kIBohYehjaCZJsAqJjWZCa3wOb2QfT7/iNyl655Pe6fOd/iPsH/dYXdT4HyMmrYvP51A/IHzaKLPnTNPYPkr7/DpDaZBVPQ4lG5z3/Iv5pTc8gXxEEGeSyctneOa1c0TGEV547eU8/crz2P2E7QQbm4wua6wt51QmW+TsYmrmXLZP7OSqi7ZzzrYRRp0mTzBsDCdA17rM1UxK+vTpYlf61DAIs9N4RoJheqRxSqWi03QMmtUKadqlXq0wVdMRskRgEg5Neusl/UGE5plM1ltULAfLsJFOjYpVpS5rREWXnAEy0ZH6OrWmpMj6FFJxurdBJw1BFITdJfz1kEeOryGViYYJhIhiSJLlKCpbaFl9yCDsEQQhiZ+AFmPXwKonVDwd29OoVjXG3Qb/AUzgv6RFuAwsn9keCiEOAtPAC9gSKgW4EbgNeNcZ+xfO6BLeLYRo/LuM+c+6RpamZPGQzO+j1SqovMDRLeKiIE1Taq5HLiFLMqTtkuQZIhWUFARBQM310LUCpRRRFOF5HkkUUyiFgcBxHBCKWt2jELC5voHneZR+RikkUupkaUzejzCqJqbhkhsGSug88+qnc/Sr3yEZ9LAtkyRWUMDrXv46vnfbvTz3RdfQPb7AP37rJn7xuZczMzuK9thhnvS0y/jCX32cxfmT/NNX/w6z0qTwA3KhI8qtfyRNdUzTxI+GeE6VIMoxzQp+P6SaKsSIzaC7hiE93nnDB7DGx6iKOp/59PuZPGsfZ110LhQxczsuwXFdShSRSnFch2CYUq9EPHTgIUbrbXJ/iFYU3Pmv/8Rzf/HFSCmRQoGuIZIEkBRpijAtFpdOE4mMftJjz9693FaxcGpVmpO70LsnaDWm2Ogtous6ZrPJoQOP0RqZJEl9PnzDJ3jrG19KGD8br1bHcjNMCUZlGrvyHNzFTZ6470qe8rpXUdc01Hs/x/W/MUmPAOm0aBRDcqnI0gyzYmHpklgpHtg8QZFqaIMNCpHhGg7Vqseh/BgnF9cJPJ9gmyLKfaZG5tAHA2oWBGlEv1/j0ZuXEbKOLkr0bRaNyZSwUaEXFuzbMUN9dY3Ta0Mspdg1UaWXK3RKin5K1C8QUlJSZ3F1jbiAY2shRSwppaAUKXk2pN6qMzna4kSxgXAGlFmKhk7JFsGrY0IRJQgzR2g6WR6jk6OEwq6VW3wTmkTXLKIo4gkzLVKliAIdQUmaSSJ/SKUosC1BPMyxvBqqVNRtjXgYkmQpumHQz2JioVMjQ6/YKPWzRwX+P40JCCG2AxcD9wDjP9WwV4DxM9vTwMJPnbZ4xvb/rOs6IcT9Qoj7gzCkNjZJfXqSer1Oc6SN7ui0ajUqpqQMYgwkKktJex2KcIg/7KAinyKMyKKA/iAiD0HDoCwVTrWKqVlYFQ/bMzCQlIZBUijsehWpOagzRCKZlJSFwBxrgjSJkpg0HZKnMa982UvxmnWakxNI3aXibikQffTPvsiBY4eoVqv8wotfyNrKOnt3XcAddz3M8sI6/Q0fFejM7djHq9/yDjZXFlBlgEgCjDOhmVEWBL0NXAkqiah4JmmRU2m6lMIk6ERoaCSa5OCpFZ77jCfxua9/m7XuBhurpygzG+Vq/PPN36VMfIQmsDQPUQosw8Tv6CSnByyuP0xv836Wl/tUR7ZzYP4YhdSQCmSWUcqtHLLnNcjTAVGq8MM1yppisqrhVUxUmTH+5F0MBvD4kQETc9sokh71RhMjZ2teg1PhnHP3csN7PkyrOoXMFMNhgalM+t2Y/npCvT7Okfl7cbWAtz3lUjr+KSYnLqalpokOrTBYH6K0EukWxJT4sY9ZCnSnwLYCnOok23aMMTtdp9lwKVyD0csmMStb4CtHMzCNPl2xzGkWoA7peJfxS9t4F2Z0x0+zZC9zeCHg8KMLPPrwYW59/ATHgpLZmTHas9MIOUZT2pjLfbbZNi3bojfQCBG47hhxtMmwWxJkEYPNHsQJaWWMpKexsHAaUaSYWQ2/B0VWshZECMMkSwVuzcHTHUpDYBgSJUy86gh5uYVl0TBJEoXQNNb7GavrUMiMXq9DUSRMTLdRhkGvN6A0TYLNDoWf4Q8Sev2SZOjS39Qp0xaT3gy9SCNciyn+/3ACQogK8I/A9UqpwU8fO/PW/w8Cjv93UUp9Vil1mVLqsmqlit/pMBz0iDYHlFmBkhppnqOZFvboKFa1gnSrtGemqbTHmB3fht1os2P3LkzTpNnwqDUMvLqBSnP8tTWEroj9ASoOCPs+Yd8niwIoICtCdN1is9vHkBkVr4ZCQwiJ1C0sq4lh6DhejXyo8P2Q0tQosgyAZ11yFq+45lr6gw4vesFzKDQYJD47tk+SqZCxRgujrmPaNlKBMEpWNwOCOCIedLbuaUUnN200r0opNSK/t6WhYDWotytUTBuVJ/z69W/BrduM1ya57lXX8ZXPfBW9hMxf4DUvfzn777oXaXioVKGICdMuqlDMzdnEokcRVJGMI/OQIl1nZX4/ORm5yikooCjRpEkSDmk060gNnnT5OdQ0iVZpc8VlF5GVBnJV52Uvex210Yz5+XlKYVAxLErJVh5/s8PVV13LxU/bg3Qs0DWsUpDoYAJz7UnOnRihPl3nnLl9/NWjjyKFRSzGmNQvYLb2XKbSS5lZbDEVuRh5RCIdCpXjBwKvPkV1JKU7TFlYS+iGIWEpEMIhTRR1r4KydAbDAkObQTOa5HoTPxYkUUgaZLRHz8LOTcxRE2esxshUHcPv09QdeqHknkMHWezGrK4LpD7NwnxGS9/DhSPjNKTk9GNHkHaDVA7wuzA95+FYHnNlwkCXhNJAtGpAnfH2FDVtjKbu4YkKFaOKltmEPoTdgjCMUEnCsSPHSdOYQRjRC4aUhU4cxAyDGMtaZ5hKxsd3YNs2Qa8EPWVkdJJRz6XSqGHVPLyqpNl0cJsFtbEYo5KwGRzDqvjYNYGu/Tf5BIQQxhkH8GWl1NfPmFf/PcwXQkwC/y57ehqY/anTZ87Y/qP6sSxrC5HlevhRgCwL4iCkzDMy0aNRdzFKgzTamiU42OzjVlwGvT7VZotUFUhN39K7G2lQKz3iQmA3muRpAlZIxfVIwhBN00mKGKFKxsbG6KwvotQATInrVsnSjCgcohkaWdCnbWQ8vnQaQ2YUugHABc+/lkMP3Em7OcP9d91Dw7N54IGH2H7WTqb5AWuDgI0kxU4jao0qUT9ldMxBLyFKtzIM8cYGO88+n2MnTzDabNLd3KA/CNHtkqGfIFJFDkjLpW4b6DWFOXs59z50hHe97wN86e8+w75zL2Dn9h08Nr8BQpClGYa2Rd2FFFhuHZGWDIKQL9z6TdJBH2k5lEWOVPzvMDEno5QJ73zTe8GweeP1b+d/vvFt+KnN4v7tqFLwP3eN8I4v/y373/Futr/nt5GOxA97FDLf0ossFUZjg69/5Z+46vIn0mg0MZQgzQuqFZvuekgifEQZ88hglWBQ4LXbeKlkamYUZzNiTbcwi1HqhsLoHCBKFR19E5nA6mAVt25QrbepjEeI3KXUBJtLHVpVh6LUKYQNZUCBj14axGGXqVFJSYVarhjGICVoloNSA6xhBeNUxvrBdRzXZCSf4Iffeox02OXCiy5gEIO/ssSBxx/FdGx2zTXoDEzWSw9vzCCySpb7KeMtiUoC4lwn6Q74xy/+mJe+7CoyrYOrC0wEfhBRmBJpKiq2DbrEsx3sikaRmWQqw/ZsNtf6NBoVNOkglEk2TNnINtBlgUZEEiYsRSFjVg0pFCUGyrDIkgJpNinzkqZloOwttuM06P/3FIiEEAL4a+CgUupPf+rQt4DXAB89s/7mT9l/UwjxVeByoP8fjQfA1oOYJwlKM0ijBNOw8KM+pu2RRjFNxySIcioVgzxM8aOMMEvIOhGhFGRFTllmJFGKYQp6UYHn2pQohNtAWgZ5HBIohaZKMlliV6pIBRk69dYkVtXCkBr9oU+r1SLPM0xZkMSKf/zK3/C8l7+UtcUNEFtB0InD9/Oxj7+bRx9dZfzT3+D7tx3hgovbnHf+bphoc+kTLqS8M6RIUgK/R3OiTREPiKMM260BkAmDE8ceR0ugZ/hMT9c4uRnz7N/6XR562Uvp6orffPt72Nzo8eWv/w233b2f91+1j0cOzvOlL95Irb2DH/3oRyytDlCGSewPt9SbNJuyyJg+6wLKoopp5ow3R7jl9g8hNBNpVyiCPkophNAoStBR1J0mL3vxLzM/P8+vvf4PeOCun/Ciay/iyisuo2Hb/M7X70KLc576nj+iOTbDoNdnpT/AkYJMs7BVgi0a2GaTzXiIaRpojoGZpBRJilOz6OYZO90qZSZxjAzX3kGqQgZDi0ESMVqrkSQGnu1h1tr0NkN+Ye9OvnfHzfT7K8j2MpvLB2ids4v5pcPouYFdrVMdmaazuszYSJ1ulOAaNZIwJSNgPaiSxyHVikvLESSpS1aWrNyWUqn6bK4VGFJw9N6T9IMhSWLhNgVTu7ZRj1aYf/hBzpuZZTPJuO+RJTaWOyTSYXICdMcliDZJvQa7t21DEBL4fWZGmkTrm3TSmPpZsLh4imecv5vFcJ0yhTyHUpUMw5Iic2hWNFZThVnA+EQDfxgRaiFOWaNRNyiVg1ARge9jN03MypbwjZ5JUobolLhNMLOEXpoSFhZxUmAkEWmxhbj9WeW/0h14CvBq4JlCiIfOLM8/0/ifLYQ4Alx9Zh/ge8Ax4CjwOeBN/9kFhBCkqiCOY+yKRZoM0e0KmiFwGzaFkBiaRtwLKHVJr98nGwRESUoRhxgFeLqOrQtUmlOrOqjURxPQ66wTba7jeR5pmhHlMXHgM1xbZXNlDX9thaDfo7O6zsrSMhQpYX9AEWdEQU4pMzSnziX7ZnnRtU8kOSPnJDST/inBL7zk1Vzzyxfzmlc9C1mWHJ9f5bzZca5/1a8S+0N0o8Q2JbEfo2k6wtHxky1mIYqSbtBHaRmbq6c5stTnPR/+S15w1S/zncDhqS94C7lw0D2DA7f9gEJ4nLVvnLWj+1ldX2V2ei9hf0BzdpI8DNAUyDJH5BCLjKuefhVW1UK3PUYbFSqVChSCvIyQaEipo6TA1DQEJQO/w50P3kxmZYyNj/Lt73+Vj370o6z7C7z73b/K5c95FnZzO9P7zqeztoLCQJJQ4mJbFkWRoYTkaU99Bk1RoUhSups9kqyk60cUUU4RBfzw/ofI85QoSjl/ZwXLqdIdhqR+vIW1jwL60ZBjj85TLRUnh33O3X0he7c/nYvNl3NF/bWML5yLseIw2x6j5eh0Fh/FMnOETGkabTSZ47k2rapNlZyReoURy8M2HVoqY9yQ7Bwf5fSjOTumxtFKl4nJFoZWJcth3/RuNlaWqVsj1Nvn4duK9jjYQvH0K/dw7vYGnRg2O33asxYiUKS9GI+S1twMa4T0c590o49YcBi16xztdigzgZQ2cbJGmmokaYRSimGa0jJ1CktSUGBLyc7RERxHUgob09QZRj6Ga5H5IUZWYgoL3RihZphEmqAoNUrNQpQRbqXAcxKkllLGGvl/h3JcKXUH/EzM4bP+D59XwJv/s3p/upSlotZokqQxlmYTmSm6kPh+j2q1TlkqdMfYItvwU8xqjTLLMaVGbkjyXGLZNoaho4KEAB1pVknPZAisPGdjbR23YpF3MnTXorAEupAYOiilYZk6SZmTpAVYOlEUoIqIsrD44O//Ot+9/Q6qDQfLngT/BL/youfwG68L+MD7ruOuux4mzQbc+IXvoNkGf/2pz3Pk6EFs3SYhRekZrm6ByvCMOlVjS4YMkTE+OYFVmigj4pqX/ioXPPFJnDjVwZtc4lN/+yW+/jd/gOiv8LSrnoI8vs7Xvv0FHlh6DKIR0kQxP9/DKKogFZpukhcRdtUjETbHDp7k8p0zlLpNJwh49xt/nRs+8deUUZ8IEHmBFIoC0AyNj77/nQSbGQ898n0++ZlbmNte5+5/+wIPP2rxrg+8Df+ef2W1/zhnnT+LfjLlls//OW/67d8nETrrcQ9NN5BajjJDloIeFQS2oeEXIZNuhZP9HmNNnU/+/dcg7DO943x+87XPZfnUKiMjLeK4YLC+TJjG6LnOSK3BSncNm4C8n2I0qyRFzsAv8IwWk+pCdndmuP2Rg9i2Ru520J5pM1axOXQ4xrBMKvUSR+SQVxgpu8xvlCw8lqCngiqznLVb4/4HFqi3NB4/sojXHKEmUg6vn6abLHDvPREta4bdl8yhqQB3yuWHP1plz65JXv2Ss/jGjYeZ3KbYs8+m37F4/vNGqLXafO57HRZ6x6hUNRbTnB3SpsxNPHeUlf4qdaeKsiAJFbYmiVWCa9psZil6DiGCjWiIqRsouUGWe5QqohQ2BjaFnhIWAkdL6IQZpkiQhoUfpRiuQegHlGVJkgtK00KTP+cTiDRNI8syTM3AD/oYqiRKwHNG0DWdWE9RfoKUgkrNZZBGtGoV/CiCPCXKcsphRhYnOO0qeZxiWzoqzrDdJqZR4uqSIg8x6hau55KkJVKWDPt9KAvSzCXKB0hhYiJIEx8pFIZj8sSnXsKdDx9AL8GztoKn9WHCnl27OLJ/nu1T03zo7e/k01/5S0ylePzwo+R5wXDQBako8hRhQ5ZHWEUEurlmBxiYAAAgAElEQVT1u80qMlVkIkWKkl959WuRboNIL+idPs7aiR/R6yzzrW/dxDPOv4p//taHMXc/mR1jFRaSHrP7Jlg7tcDIqIAHQxLDAQyGYYDjL/GRD1zHseMLxGmBISpIw0aZigwbLe6BMFFljC4tpKYxtWMvBBF//q6PcPVLruX33ns9X/zMH1Op/4A7vv1Npid14qHDgfseoFY7h1df/x5CzcPNJe3KDInapN+PyIOAbZPjhBtdnKrNuFdnY7OLWZhESI73CyzH4d1vvI7H55fQkURFRs8oKCNo6Q0c02Ml6NKsjyAKE9/uY+SK4UZEpVmQp4Jz915MLww5f/cMS/4oUyNjzH/zICdUl7LUUcUyh3WNaHCMkeoelK9z1uQsrfMX6Z1MiZoCIkU1SKmZTS678mxOry5z9vYJhJJoesrOpz6DH9x2kF63ZHpbDXWoQhCe4vEjcHxlgY1QoHVmmFqcop8N+MyNh9g+Pkm952K1I/rrNdxGyHe/MY+3W/D8X7oKVbokjmK4vomUkjLOCF2PijnEKCvkhaDmJGRD8CnRqVMohVOZQ2V9Gs1RwmiNMsnwJeglBCk4hgKZIB0DQ7ch8bH/b+be++u7syzz/lz72r18+12f++kl5QkBYxLBYCSCAtERRJrMGEEBYURHYVRUZkCqCqLSXSIjReZFioh0UTqYMOk9T797+dbd+54fbtb702R+edd6V87/YO+9juM693kd53G0NJIyRdUe40ajZVUyHo9R6gbTtijyfX2A6WrElYrWKFTV/vZdlicYUiGvc8QP9+dlA42AdqtFWtZoFVRljO25BGEGChQ5zM0vMhpNmPozykKAqlGpBjQVZZXiugOCIACloeV6BLOQA4MDvOTFL+XixYt8+2vf4t3vehf8/M28/XVv5E1vexthbZDMhly8sMF3/u1bFGVCPtlklmZ4rkXTaGimRtEoqJVKWObESQCAVEq2t7ewvRY70ylCqdl++Dy2Os+54b0cWz5O4I/57Ic/xlfsLsXBKxhYS4xbS1wMb8P3x5hmh2Q45u/+7B0Ix6E7mMPWNWyp08QFiiwRVU4l4eyZi5DUVEWMqBSqukSqglpIbrj+SVi5x8lrTlOpNk0ZkQQZLitcc8XlfOdrd/IrL3kN/qrOF774F3TMw2QdAyUIybUasox2x+TI0eOEowytV1OrKnFeMEvGSA3Qdf7bH74aw+iSpzGWVtLoHooCeaLspwi1JE1WMEtGSHXfHq6rGzSyIahzegOTMDEpxZRhEKOqBZq7SC8e0QC9k6c5VKWc37zIXOcIo2HIME3ortgceHaHKj6PFrksHOnw9U9/jSsPPYmr+iV33HMGKnBFh/FmRc9zCauEbz74dYrGYiRNLu5uY8sWN15/Bd++60HiTZC6w55/jtU0wJmbcH37MO2lgMcdOs53bgd3scs93zrLzK84NTjEuQcvoPVrVjcTDDyOX9amyGr2hlNawqQWBUlekOQ1mmohxBTFMFCamjRqMFTBeNtHkQZCqqiaoG5yPNuhDtnflVFdaqFguxZ+kGI0OvVjPYFI1XRMDHoHl4mme1htCyUN981Em5KyzkjjBMVqESch3ZVDWLXCZLyL2kiUKkGYBpPpDGnYRHGA3uTonT5ex0YKhbAKGY4LMgRuo+POeZRRhq5IZmUKtU5dVqiqpMoTRv6E2pnjvrvu5MCBJa65+gqmOxOs5jwAd9x5K2mpcfjE5Tz92pOsHz1KXte0ux0020XNawzRID2HLCkolYQqiajLEkXf/yAzP2dge8iFLuf3Ym77X3fjHThAuT5GbQpaesGJBYuX/uFr+Ys3/BmHjv0MfvoAq7sxeVlThAHQI1AKwpmPW1iERo6ahegLXYKsJApC6kZDZAWb69vIeowiTUohUGsoFYlKzu+9/PeZ5Tv8zd/8DZQp+fkhkppGhMx1T3D88Ij3vfPdtNo5X/z6Qzz9J6+hZyxhWAMaqWDXAWGr4rk3XE9dz6hznbxqaAiRegdFMdHJedub/py///jf8bwX/xlEIZrdoqxGBEFM12sxzQoMVWE2NdB1SSZThlJQZQItr8gtSd3sC3HmjnbZXp0SqyN6HQ9ncQGxtcuw9Dl1+XUkVcDJpRbLT7gBIyupH5iyOVY4cfwAk84PeNrLj5IKFTWfcdxe4NwD56ln8yh6xnQ4InJKNnZDeodKtquGjXtGXPefSpok4UR1iL2zM1743CeQdyXD7W1S02Jna8St3zeYxTPsy3uszSZcfvMKP2HdQJVuk8UJmb7HYHEex1ZZX93C9AQLXoeLl9aJJxlVr8/p5UX8aEzLtZCiwzA5i661CEoVry3YCBMWVBs/L4jrgFbdoa0oqFqGIg12hzlznQFlU+CZOk3zGN8iFE3NwaPLqLZJHmmkSYrT7pHNpsimxHE7IF00y0QiEWlFqJXohoWmCiyhotkus6rAdCSi1GiEhiMNlEaws7fDiZUODzx8Cddyycz9nX3NtJgEE6S5H4IqDRMjbHAMlSovkHbFbd/7Jv/8hfuZ7BVsDQP+/F1/x6eAq6+5jkNHjvD1736dp117mCuOH8eQkle//BXUEnLREFYK/toaLWeeWgdVlezubNFf2NdVZUSEZcN9X36YslBwZUG3idim4QlXX8YbXvM7/NYb3sFb/vB13PfMG1i+7mr+6cMfwetI3PYJptMppmuiJhk4BrWeQxDgI3CEhqxSFGlQJQVN1vA7v/Ef+fK3vknbBT9XKLIUXdsHa9lMsdSG937wbzn1hCfzst/7PdZe98c0OWTJlM7pqznVavjM//N5PvSJkyAVagMyLUPJDSIHvHyeZz7lBrZ3LxEGCZ6nEPgCz1IQuopm2CSFz4ue/xKqdIJhm4gso+/0eTBco02JIQyaAjxLw5lXgZRknKBaKnFWoUsXqTa4tsHe5oSqipGhYKYXFNMhSiEYWHMkk12MTgeZpyx32qyPNvDsOWxxiPMPbjGeHOWaq23S6TmSQ3DVE/tc+VSF2USnlXVwezWjSiGfbLN5YUJdDbh0YJFq3efx1y1RFTU/feXVbJklah1Q6DlllHLJjulcofFQs85iPiA1CtYDnx1TMGeULHc16ryDP61oCh0zbJNaGfF4itPyOHx4gXE8I6p3aHe6ZFGOP1xHsxeRhkPij2m15yniVUbxCJUKpdZADdhrdLTaJhpOqXOF8WSLVtdhGPj832Q8jwkSaIQgKSHZmWB6Ho1USdMc3XTQNI2yTOh054gyH0VTEK4Ovk+71ybNM4IshShGGgZZ2SCEoDINorKkyhJ6LY9RWnPw8Cmmsy0MzQBREKcFxg9zCpumIg1DpGESJBGN0BjuxjRNj+/cvsmZjU26pkK79wQANtY3eeJ1T0Pl3+m2Bhw/dIi8KHjKTT9NFgcoVUkxy6nKlMatydIQRdG48qqrmO7uG5N0hE4pc/7ltrv5hRf8LC87egt33v0ddKlx9uxFcqFx+LLHU5Qxjpaw+fCIOt6j2z3FE179Br75z3/GIWGA1uBIE1EpKLbEqHWqImE4rBj0u2RRwCSIKNKC973yp/jEF+7kBxuraI7Gwd6AN7/93Qg1Z2X5OLrl8PSbnsJPPvMp/HahYQ5K1OEOVy4pfPpTIy5sXODHbvxZlrwl6lqilw1SMZBlgdoknNl8AE13wBYIp81Cv8NkNKauIox4AppB2dRUscpsMiPTJHE0ZWB2KCuVfk8nSEqMsuDsQ2exLQ2qmsJ3OXzkAEkcYLsux46fYv3SWbbygq6rMEVjznUYFmOKSqPfHVDrEsNTmcYztEYwjtZxHUF34RiyE7GjDOj1FijDhvLiDrOipKh32T0oGSslpG1q06H0JJ4zz5UHJ+iqjYqKuPU8Z49KFg64lGHB2jmfvXGKzDWmSoKtB5y9uIPtaWhCUu1kKCstRlFNGDXUTcK8ZRH6EE7HOP0OTZDScmza2OzNambxiH7LZN7rYbd0pltjqtEu66VEc2sGukac13RcnayAA90u49EGVZrhOCboGkkUUzWS/Xn9/7keEySgKApJFmPpEoHEtByicApITNsiKwRFVaAbJrZhEYUZtW5RNxIpdExlfyagOwZ5GKF7fTRRU2oK2DbkMZphUxQFNAZSKgS5QrvtMZvNUFAoqFFNG10oNJpOVJcsLC7zxje/CbM1T2c3pzt/mGG4n0XYbi/xqlf/Ntc+4fFgGrziZf8ZUwJZRDSbYnt98ipEiSDJQjRVIclStECj+GFrFlY5c90uNz/tyXz1y/9Kp98jihTWNlfx/TE3P/eFiKbkaVddjbdwBY4Ni/M9Hrn/bl7/51dz3ycFxSxH1BlNAcI1oCxQHBtNMRlHIZMkodfqUlUaSwsdLtU6P3X6KP1Om0LWrE12GEdDnFrhXV96H2mS8euv+DWe84znUYuaP3nda7Esi+88cIYLGxu88lWv5a47bmcgLHLLQJBjGRlBUVEGGY4zR+zvkBY2hfogs9EAR9HJm5JZrWNlJVVVYikqh684zbmNh1C0DvF4jCJtLmz7tBQbpy+55tofI5gNSWczhO0RTUNm8TaapqFuCXZ3fPptBz/JqROf3SzEtrq4XQNdM5klMePdCYWa0Z/roCUJslRRpaRvl2iypt/pU5Ql46pm0Ax46o03c9e932A6SwnEOQZLAyzxAJUZkRca4VaMuiQ49Mw5qllBHCbkUcaTr/8RJnGMqBuKJOCOH1zCaAycxqQ2C1pzB2jpGZlS4ZkapdHCUQrUVo0rDqFVBXUYc2Z1zPygw2C5SxbGDCdTEqXCqBXaHZeVfp+myDFbHRy1xTTcRhMKk2z/0JHCxNRdJhOfKq/ROzamum+V/mj1mCCBuqoxVI0sb1D0nCLPMSyTpqqJZlNoVDS9pkoFjaWiypq6gTILURXJrMxwLJsqyUDVyascTdrkaQbU9PsL5HmKrek0QkEK8CyLJEkxHZs6L9F1A12zybKEVqdPk6VUjeT973oPiQDPVOm5LXY3t+Dpn+b6a36Uf/7C5+k4FpMo4e8//T/5yz99B7rTo6XYdAYOUTDAcSJMXUFXzP0pLRXih6pD13XxJ1Meued26mzINz75LfaCmLrb8PjLr+G64zHfvf0RLFfwj/96K899zi9Rqwk0HgtcYDfNOX4QpOiiaDqGoqPoQBqgLw8glbgJJEWKUmUMd2N0y6Y2NAYdA9/3+cX/8B8xFJ1YVHzobz/F297yTj728a9x0zN+nnN3/wum1zBp23z+nf+Mv51x4rLjeN02dZFRNTGa0qKxdVpli6sWF4nCKYP5ZYKdEbo8Qf9Yl/W9TZIkw7O72IqJ3lSYlWB7cwfRqFCD5bWRVc2S6bEXRUz3EjRSLEvjZb/6X/j8v/4DQVBgGPPkZcZwuIfpSFQJC3MWq9MZOH3URuGKY5dx6/duQ7gVntQZhymTKViOjp8llFVFr70fOz8bD6EWtFsueVPwpX/7R4StEY4SgolOOfJ43PHn89CFMxxcTLnUPY9ZuaDHJHpB4zjUusKF4TqeaSPMDooo+ZGndLHdFkkEpjSYjCakiUGSB3grC7hNgxQ6Bg26mqPkJbM5DRHVmMJkbzjEzHNMA/qWQVCXZHVKkjtILWVvZ4TMU4SeMhDzGHZAUIVIVBrFQdQJTl9BI6FM1f3IvkepxwQJNICuNsRJjpaq6JpFXiTYlk4ex6BCXrvUVYCSqtiWRZrX1HVNUda4hkWZF1QS8ihCMTXGiU/bsTEtnWk4pQgzTFUjqTJMVaUoakxFIlSVPC/RTRelqXF0F9+foNkmcd7Q1Q0sU8P3faYio/Y6ADz15qfx7k9+Ett1WF5cYNDr8csv+mUePHOWdtehqVRUxcfqdcnSgrKuKRqwnDamsS84stsDKt3hlltejElN941dPvnZf+Dr3/sGb3v7m7n/c/9GYt7B988Mee7NL+HBu77FrKjYSi7w1e/fSTtXcOICd85D6A3IHBGryF4Hy7Ixs5xddYSXJFR5Rq0KTNVCr2w8MaMwTH7mhS9l8+F7OXrqJJbd56lPfSq/+Vt/yuN/fIWm1SWeNRzWbYTwee1Tn0bTeyrj9d/gUOcYsVqRWg1Lnk09qTlxwwlyasY72zjEpH7FsEjJRhG1Ak3VcHZyhu7yHHanvd+VUWNKF1BI/T30XptDSKalIAxSnJbJuz72IXqOw3Bjj5WVDrOo5qrTV7J5ZhVNL5Bajy4pFA0b4S7D26Y4A5sst2h3FaQnGYV7zB8/Tqp4yEsJWcckDksMw8GWBopseOTSjI65SFL4yCxgodtD1ROGexuIqGG6doC2mKOOA+ZXbIyeycX8IXTTxmmBnNPI4wA/ychFj5kvsYWgqAS9AwPKrMY1POxIMFUzWqqLH4WYer2ftyEtOq0WceJTmTaEbUb5EBFGoOuUtkYczqDe/9amKWkUgzsevB99pY2jt9GrEt0psJ0269MtDthzTP09UB7jtwNNUzPxAzTDJY0jRCn2TWpRUTSXvIixZY6fZZiqIMkUirgErdk/2fOGMIvodNtEQuApKlKtmIzG+4YRTYZumkzifVmt5TnkaUB/0CX0AyoVqiYjizNqVaHMUoIiwbFbjJMMEoWqKun1NJIgAeDokTkctcDzHKSiMxqPeGR1FcPWEIpKEyeorrmfC2haRElMXtTkNWjGfpSZLkzUvkdVlTQI/GnJDT/xs/zMM/8TX/ncF3jaM36GZ88dwBAKf/TfP8C11y3Rsg4imgs86UnX8dq3fZCV8iCtjodUTPKwRjctqrximtbUTUYnE9RRhhQ1RttFGiBESNEoRInL+sV7UQcDbv6FF5DH63zoU18gri9y951rtJeOU+oZ737vR0jHOl+c7jL8/Wewcs1pVu+4gOM5TKuMtQwW+l1+9OQp/Nke1JJhWlF0crwgRxqw2JmnjMccO3IURVEZD4fYbR+t7jPxM/Q8x3AcDMtkbOaolYfUdLK0RKUhCMe0F9oMY4EqPLbXL4HhkiQhWRFh2jolFRIHw5RUYYOiQKa7VHVFT2mz81CMt7zANBuRb0ryYIhmKqBKmgqE2RAYUw72DEbKgAIFpelRmhqLXptOZ5693V1mNKhRnzoAY2iAEbPUnkGTkg+gZxvs+SV5URHXEr0sKNUehgjIVZWZFkIJmYxoPI+iNBAaQEkU+jQC8t0Qo+fSSmvc1hxZLZBVhOYYyDokD3U8TTKdJSx0DxJlU+Y7OnEiSZIRee1wsN3G0yv01oCqWXtU/D0mSEDUDdl4Cl7FeHuDTruNv7UFc33CPKdrDdi+eB5NM/B9A9NziEcjOnMDbKtFSo5QdCglnVaboipRVZN+q00RpwzmlhhubmJoJkJRSWcpFBVjPyCJC5oyoWpqjBqSLMPSTJoGdF3dX2wqCkynyywIED98Ze9//wc5sHiUXq/DL77wufS6HZIoxTFUUEHTNcZRgIa2L1mucubm+xRZ/v8uczRCUqPu26VnMVFdoDouVaPwje/exvLRJf7qAx/EUhR+/b+8iLwI+MfPfZqW2SEPSrSywlluc+jyg8gioGgkiqpj2SY7403QbDyrxYwSDY0ijShicDotxns7QJuH7r/Auz/8B0y2N/joF77Mzp3f49RLf4kPf+rjeEVIMppiLbS46uab2X14SOvUlbz/D36X5778FQy3d1BFziQeYnVMFEtFxSPfi0htF2+SsHj0KJu7O6RRiWloRHFM1dTYdou1kaQna8rmIjJvaPSDVFGKp0vSmYIpBJZUOHToEOs7Y/KiwpI+ZaoRSAObFKEbdPWGrVlCR7NxbYskjZnr9YkmPnOWw6zJmVb7i66VH3N4+RB7wRht/hCrly5haSqO1Kh0A1NRmOxkaJaBLEJyINlO2JLQCmKsWqVUMtbOXaLf6dPvDPBcA71J2HgoQPVMnPY6tjfF9lT8cso4NklGOaXMacsWs2JMkFdouqAWJWFW0kSQEEDh4riHSKtV5CTGMHtM0xJVz0gqgzwHy3IQXYUZMVavpmwqjonThMo2StvC3V0gTmYUhcZ03iGLQpTmMS4WQqosnDqNptT0F1coyoSlA0coZIHSKKgI9F4HXQc1l0wzn9bxg2QTnyqfoUqVUsmZxrskfkpHN9hKc/q2w3Q6ZbozJdcLWm6XaLxNVet05vrkaUpVNBheFykayjJDrSVxltDqdRnNJuQzQatvEQVbNNjEyQ4A/+1P3sxPPuXZeC2Hb3zn+9zxnW8RBCGjiY+tGyiqitFIhGqQFjmd/iKT8TaiVKjL/W4iLSJmky0UYdBxPETTEA13eNazfhbdXODqG3+EQ0seD5y5xJte+0pufMazOXZ0mU5T8NXvfRcFwYkFlyLM0Lp9kiqlqTVqo4Nr6IThkKLdxxQxhulipxn1fIt4ustBuULQafOl285w6rqb2Vr9ay7cu4bpdHjWTc/kCZc/kbwc8z8+/glGkc1tX/0M/SNHOHjgMn7t999FNxnhXnOCC7fdi6oX1OEuhatiBAqK1tC355gyZGtcEsYFploisaiSmKqoaAqbZGvI2GrIcsHJnstwuMl2VaEvxvS6j8eeDal0l0sXd2hrUJkuLXWB0JgQRduUmk2WF4hcQeYagSgQtYooLeo4R7Y04iKmqDM80yNIRsxGe+SNQpzlROm+JoUcpKlSiYJJXjHfbVNmPntpzdHlFTbTTaymYLy9wWUnr8CfFvT6Fgtui11dImcRt59d56qrjtFQU4xOE2zuINweSbaDMVFQ2ndy8KoFHhlP6Dlt8miIv1dz+PACUZpSLNe0433jXLM1ZkX1SNOUssiQasX6XsjAdhFlSVSCYxkUio6XK9iuzX0PnuV060pu//7dKKaNpQr6iy76asaDmxvIR1cNP0ZIoGkY7fjkYkrHdKhraGyLqlBoWR4BNS29xnTbpE3CXDVHnpd4K110XaesGnRVQxENaRaRRTmi2J/Cdha6KEiKMiGYRCAMTFNjtLOJ5ro4hsHO5iU0xSAvYgQS1/ZYPbMKQF5EjAJJr9tmc2ud9IdrwK958UvYG+Vcfe012I7gkY1d5jtdJtEI1TAxVIUgjIj8kF7bJEtCTL1Lrvjocn9IoyqSdnsOUMjLnDJNWDh4hL/8yIf4qRufxujikC99/t84cuQIv/m6d/DIw7v81m//JjsH7+Ez//Oz9OZcnvyc5/BzN93AFz/wMVzVpcxLep0u22UFahtXmOxpBcVsyvx8i9B2cHpzqIMYXQnxH1rl4DXH0UzBB//2fXzm85/nX/7XI4yDhGR3yk/d+HO8+21/Su+wZHbuET7xofewNx7xVx/U+e4//RNFVeBIk1zqtDKPzWgHTIO6mEJtUaYj2m0PIRWiDILpmLWzZynDjFp1OX795VimzUYSIVQP11NRZxWjnQnt7pjcLvAvSPSVJarMR5E5RVOzuHyaNB4zIiFJYizHJMkbTAGlBlXboZ4OmaRTsrpBlSFppmP3O8R+jEJFS9EwqoayKLG7XZQ0pa4gQtt3CZaCIk9QZMO85lBFBkJRsTXoLhzFdGLkZsTSymEOHVlgb2cP1XLxZxPmPZfJToBmWCwdn+Puh0rOfk9ieF2OXjHFsWsCNWOlp5K6NXkhuP3MLgO7T7uu8UXJOBhx5OACReXwuIMOdaGSlhVlnqPIEs1qUSoxWlDyuEOH2bp9D3dgMd32yTWJNYJKL2FsEk2KR4XfY4IEiizBv3gbpQL0D+L7Pv1Bl5bdYjiboTiCNKjY3N5FVwVmt00hBFpWUxUmhmExGQ+xTZ2qacibil7bQpQqZaNgmh5pNGTh8DJNkZAWKT0xRxyHlFHCytwScR6QZib+NCDNa3QTNi6uY9k2cV1wae0h5tw25Wg/M2DZ6hJ4Ab/xX/+Axo9pspzAn6IKhSTNqYuSqqoQArKqpNPrsrs3xWvZ7KcGQl3XVGVOnuf057ukmkCTKvfeMebXX3yYz376X6iihnPnHqKcRESTh3jD617Jj117HReHuxw9epKPf+DvWbIcbKNDGPu0+j2CLEHoNZ7TMIt8pCnpORZKXRKGPmmWkSBQKoXtnTUufvwHKGqPwysn+Na/PcBHPvUVXvnyX+Ebt/6Al/7qq/idV97H03/253nRH7+MrVFAr93i917xMn7u0x/n6NU/zualh7H8lL08ot+fQzY1s3hKrSkYqksRJRRViWa4dA8eRWl1qKIcV9oETUJZp6hVRaMV5KlGmofM91oE4WEGoiFZvIfUiBkGGfPyFFWekVar1FlFb3GZKs/Io4yqnpJkNVVW00xKKhyaRjDzQzpmja7ojCYpbadNBRi6QxrNOHL8KGfPnsNtuYRJikxiKFPodtjY26NMMxqnoTM/YJKmkKvkimBvMsXMas7tbFKrJS2vw1Y4o+taJIVk/phFmZQ8fPYipy5rM50V5AkM7z2CYi5gxFuY17qkaUA4zHnyNQso5jxUKV4V4k4HjB45R+226cy1KS0LzRBQVQw6K7hqSNXozCIfY+oQRNtUqiQpFRzToCpqUr3E7jbYtv6o+HtMkIDltvAWD6E3KlklcI0WZDXryR5t3UKvc8K4olYko9kUGY6RUhJOIjS15vjKEXZmQyzLQhEGhm2Sz0qiQqHdMZkN1yhVi93hLoZtUEYlVVMgpERptxGNoGNb5HnNgXmFuIiRQsGyXfzRNtH6Dj3TIommlPX+9d59w3XMMmPzvn/nrf/9LWxur9EyFXa2L2KqPebnB2RpzVy3TaE47F7YIJc1pUxIs/0722GQ0J4fYEeSYDillJLV1VXe/+7XYkmFF7zk2WSzhGf/wsu45aU38vKXvp6rr7qepz/xMPfe/QDRZAs1c3nVLz8fI/J4zetfQy1qUlmSjSKE6VJMd1EWWhThjIsbl2i3PaYPrNJkCT3XZXnO4/7JiEaF5/zMVdzx79/G6nYwjIoXPP8X+OQXbmU82eFv3/chXvlfX8HnPvFdVnoz4lHJ1njKQr/Fj1zzRB585G6SjTHKnEWrUTF1C9szmaQJpt01U9kAACAASURBVKZgZSZ4NUquobUE5pxHUvg0oY5qKrTcNuc3R7RUqAubut1HFHtMCug5NzKdbnLMLRnLdSx1nkZmVKLDLPapRxFpnUNZUNQB0h6Q1wVCA1WWdE2PuNjDMgRdWyPJcvKyRmtSSpGydW4T27YZ7+5hqh5Kq0I0LWzLo23aLHQGrG5vMgzH9DybtSilp5YUuUu355IkCZ5tkUwb3DKHysExYWc2hrLEdiVbM8mSaWG0DfTcZCfwqaQgvKdFEpnMch9TWWO3tQp+QssyaRwF78gJFuYVWlmHWTjh9BUO1d48ooQL6zGuJtk7F7Mx2cayW2xvbNE5qiB2KyzbwDAE7jGXW+/MHxV/4v+mJPr/q05fcUXzrW//gDN338k0miClpLe4yN7ZC3i2AW6HHx6eSCmxLIswDImLBE3TMHWLrC5J/BAdBUUVGMb+74GiwHA8Iq2hLGpc02Jl+QAPPfIwttXGaevk2QypO1hy3+GlVErUSmGWVgitJEkiVCqGez4oKS/4o9fjTcb/n545mpvj1g99giSPEUqD22njj2bQSAynRTjZpK6nPO/X3kBr3uFfPvJRfuU5t7B05VV87sufZGG5y5ve/E6s6ZCjcwP0Tptk4nPkqitZP7eKPu+SFjmRH3DyxBX85M/9B668bJmtwKKoJf75c9z8pMv5yv3/zmQUce3Ra3j7n76Zl7zlr7jppltAgZ++vs873v4nfPPbX2Z54QDqQp8bfvTneNebfptJ7ONZOs9+7u/zvGdfw9ve+Tb+4g3vZW5gIRE4LY9gNEFVNWpVkGYhkv17ckEJ2JiuQZrGxLMAyzZoeT2GezuUUqJVEOcxGhW6ZlMVNYYp9jvAtKHsP4xftGjSeVQfTC0nywL6/SXi2YSDVzyOc/ecJ1IqguEWS3OLFFWOZejEIoeyokobpKuRRxXUFWkcsnLwJHGxQxylaHaL0XgXU1GhijH1Hlmd4CcRCMlyd5mRP8a1FHJ0XFmjdnvUeUgdVORJjdMymIyHCLuNZdb7g+eqYpoW1KZGEqbYoiBLNAy3IAsl28MRS4MY50jEnqnj9XKU0ZCOs8Da91LKYsbRqxex+qDXJsn4AF/56m1c9qMLXLz/LPXA4tSJFtmORx7lzGbbfO37a+yOwv+jWOAx0QnQwJm7b2f5+AmqM+exLAuRZqiWQVI1tJWGoPBRpMtguU+apjhdGzEVFHmO0Cr0pqHUJYbroVYZWRqTlga2tg8qked4gzbhOMRPU5YOrhD4U2zDJClKqjQjTEo6tkIhJXmqYTuCMk9phORpT30m//rNr5AkGd9473uoa4WijlAtjzopibIKz7Zx2g6KbqBrFopssDSbpM7oWg5xHJOXJaZtoysSJ8uxG29/7lGknDgxT5qmJNMI78gR7r/3u3TbKidXFnneC5+JsXKafz97lhf92i0kUcHjTp7k/CMF29gsKBZRHRFUJWLRoi5BVBKt43L1k65l7vjljOKCrqrw4H0PQBs+e8ddzLcvY9LcxfNf8hJKOeHSxe/wpc9K/sfHPsJ1V3u8/MWvYm11kzSZ8vSVn+SaU5ezG6eoWcEsynjgnq/ysfASpWwx9mOW+za5JpiEU1zPIU5SmrwC08EsE2TjkuUBQpPkeYppuDSepNNrs3Fujf68R55UNJaGic1o5qM5AiLBJK1Ry5Km41HtdDncHrDbXKR92RiZ30Aw7BOFIcMYdu64FVHGHFxcBDziPAFDwdIkk80ZbWc/pXq8E9LyHCylYWm+x9rGebqLfdI8Icn3ONjpMPJTMgbk/phQqei3OvjTkIujdRbaA9KyIJnsoA8Oohc14SwjySOSpCRUWui6gqwyykhQFxmtXo/RbA2rs8DBVp8zl1Y5cmyOPBM8MhzjdZZo8pjsez4HnrhMcOk88UKNcAxOPktFxn3quOD2b+1y5OgyhT/k5IkBa/ePaSyXa70+D961TUXC+rZP19hXyT5aPSYSiOqmodebp6kySlVAneMXKUqj0e7NEScJcwtLFJRcOnue6c6YIt/fEWj1ukjbRrN1Op0OjqrSaA6qdGk7Fqpp0G536XR6VHWN12uTxgll2WCqNkle0DFbOE6bTruH0lrE1ltopsDyWgTTnKKu+MFdd+AYHdotHYlEOiq65qA3OpZjM+h5eC2LOsvIxlOGuxvMRrvsrJ0jWltnb3OHaDalTjOKLCXOMzQUDMMiKVP0piYrcqTu4sz3MHSbv//E18jyiihSOXDiMmbjEfFsg3e+9XXUiuDy00/AXLySfO4Qd+/q3Jd2CCuNsjEo1YZp0bC73XCgexntusPqxYi3vusD3LfzEC98wct5+5+9he3J/VieTZYmbG/6/NMnvsmx09fyxY+9k9/9nXfyJ299NVecPMrRg1dz1t/irW98I1qc0On2KBF85jP/yNrGwwxaC1y4eJFUycmSFFEKKqVGEVCoDSLNkQiyYkYlVMpwiqxVZuMJlb9HOPbx2haGpiOlhqNWJEmApkI6rUiyCsdU0LUas8jIK5vdtMDkCsTkJ9B3tujYG4SdO7B6Fh2hg6mxs6syqBWaOsRUVOqsYWWuxzRNwdGwOhazLMCa99gqSqTQ8adTqqZALaCpJYNuBxFPKaWDVaukozFSlLRsh3Q0QwqV1txBDgw63HPfvez6CWmQ0XNddFVDlAq6bVGoBqCwlWbMdQbIvKLQVBRDYXt3j43pHnYrou2FtJf7NKcWubg+oRKHuK77iyiPLPHIl2xWLyjkbZsTT9WRJ6eU7V3Wp+vMPV6i62PujjfpOC2SqcnyokepBYRR9Kj4e2x0AopCGPokScHJkydZv3CJTmcBZ8FEMzU0cYCqFDhuhzDNUGvB+YsXmJ+fo1EVyqJAlTpNUSGkoMpjVEOn5UiKRqWoctqmR2xV5GlIt+dRpAWb4z1a7S69tsXeno+mKtiKRUaDaZqEoxkrBw+SZj4iT1Gkgt446E5NKkqE6SDlfpSYqlYIJNvTgLmFeWSWEktBUccMRzscnlsgLyIsR6Msc2J/jKObhLvxfnR3muE4grwWKGWK1Fp8/etfY2nF5aYbfpq//sAfs3TsKh5/4vGMz4boos3ywRY/+OtVVLPkC//0UUQp+fSHa973jtdAY3L8sMWx33sjL4t2uPHHn0nuRPzr85/OM6KjOFbInbfbFFmG0G36nf2u6Vdf/Xbe/Luv5aZjGc/65Vexff8x3vaev6RIA8yzBYpT0b/sSppwiKZpvPn1vw/CRk9T7r/vHC+75Vlous7FM4+gFDUyL/A8g6zKicqaGgXNshGmQZOkqBqY7jKCgrJUiPIf2m2PA3RNUubFfnZjllLXAiksmgakbqDrNtubGzhdDxSFeM+knZ2gdvcQ/W08d55mV8H05jDHEAcxWIKedGhZOl2zQ1bOGOgNu1tTPNNlFM7IG0nXabM33I9pa+yK2pJYpoHWmBRNSadjk0YxSscjlzVzfYMHH77A5QeXOL87pWNYLC0s8vCF8/i+z5wuyfycrmsRxhk7dUXL6bO5vokrdUxhoOYFozRjcOAA070RQoNBozAOJ3z7wQdoaQJBl2zLYLLjMaGPoa4h7F2UkyPmj3U4etkKsu6x/fAW9lbJgnOI00++gh/c/dlHhd9jggTqumZ3EmB5LeQ0wPFcRsNtpqjMooie52DqbXSzIQkShK7izXdQdQO33WK2s0cjFEpRoWsG/VaLIMopaKBsMBWVOMtQHJO2ue/Ca1st3LZLUtQkeUK71wdqFKGjyQYpKjyzRYpCPquQpsRrmVRTgdOzWd3exVE1uh2dNPEpSg2Eguu1EZT4ZBiiR6pVLK0cIfZ9hGjwk5AsT+kuz5FmCbqpAQqm56AbElu3iYIJugVPv+kZbEzP4rYEoFF5kht//Ho+9A/vpHBzlk/eROY/iFAdekvLDLrLjGdTNNmhRFDLNv3bv8nzfunlnH14yOzMFu9tAhR1jSQquOsH+842TqVy6thR/v4Tn8cxDzCwYXjPb1NpY7506+0gVfq2RaLAwNGI9jJsrcLUDV50y/N5y1vfQ9BI/GiNyWQPFUktNU5cfQ23334rVgGabpE2DbbUqWqJrmnEskaoOu68SbBdo+kZSZYhiwJXUcgQ1E1KVpss9DrYmsVeklAUAe22R1VKlhbnCYuMRrNRS8gSDc/pEU1atMYZZ9L7KctdKnmUJm3jtV3SomR+0GW4s4pht2mcAT0JSt1QdyRty6UJEzorLao8Rc5KLDKGG0Pm5w7sW9lHIXGYoigJOQ17j+zg9VySvMHRFYRjsjbe5srLT7O5torrSlazjFE6o9PzMAvJZrSHEmUoLZtcNTh1bIHikQeoywnzKz2qPECEA0Ttc2BxiQurO2TViLmeyaVJyEIFM6HhRCe56epn88BXv0+wNCNsPcTi5Yscng9perts5kP09qND/TFBAlJROLCySDENmW6t019eJm8UFhfmaHZAs0wMy0bImmBvhGe2MUqVJI0J1n26bpvpbA/X6TD2Z3iFQVbVBEmEZVloikEqUpppjOZ2GAUhuqJA3RBHGZZrksQxUlNRlQZpmZDlhE2DJlXmlpbRDQVDSC5F2yhxwZEjK4RhzDCOiDb2cFo90EsqURNGJY7VwjAEZVODIhFSQVNV0jLDbGzqvCDyx/Ra88RZSl1maIbNzJ+QpwmjSckb3/RH3PIr/5mnXP943mlUPPNJN3H42HHe9d6P0pcd4r370ZwudZJwwD1Cb36eJz7hR2mKCYptMFrd4pW3vBLtxElO98bcdXieKhQY0uSbX/kYeakT2zp+lBEkMX/3Dx/l0EGN7OE13GO7XLbyU9jG/fjjPS7sneXUj1zD5M6zJMToQkcoFacuv4yiamg3IUrnAHXgE+sSWxU8fP89tA2dIIg4fOgIFzYvUuQVuu2QqgLDMmmbOvl2jKUo1BhIQ1DKkrpRcZoMXR1QVDmmrhLHPh1DYxSmIBQUBBUKhqjotgbsJXsUPZN4GqMokLbnWW7PYagBC0eOcGbr+2jqGaZbRxltFVx97DI2d9ZIJwmOVRAHMYcG86yPxxRljIhhvt1nM9hjbmEeEUnmDx9ie30XfzZF13VUS4VKRZouUexj6iaGZlGnKbZnsru2SZQmTNOKJo6pXIvhKERNCzqmx8KxHnqe4ucxq5sZtvSQQkPLKsJKoawmVNJhbXNEY1moecNiUTOjwp7rkA9rdENj49KY7uJxZmGAVxwmnUqieg1bpJgLLaqyfFT8PSZIQNN0BvMLpJrFsYUuUtWpakFVlOi6TjQbUxcNjquzsLBIXZaUotqPKzN1ojxBGjZZXeIYJrVo0CqgEWg1XHr4LKpjo1YNtmWgI0iDiKLJ0HWTvAjo9weMx1MoG4oywRYqqmmQJFPKNCPKcjrdPoZqkcUZSlqSj2bYXpvuVadJihK9aJANVPp+HmJagapZ+NOAjuP9b+bePFiW7K7v/Jwl96zMqrpVd3376+7XrdbS2oWEhBE0FosGMEJgMMgYrIBxGAbN2MY4sGJsVo8iPDaDBxgWyx6bRbI2BBgEkhFrq7V0t7rV29vf3e+tW1vu25k/7psJxwQSxDDh0ImoqMxTmVkVFXF+8fv9znehSiq01TJe7zGZZgR6hSxZ0nQtXhAzX0xwlYNSCu1I7DbnG9/yzRSioHM0ly4sGHkW27d2WNt8iNYknB+OuLO/Q+NarJ0J2D+Z0DJANhVhNOah17+O3/vw73JkekyTKaZpuXntWbIsYzgcMz++xvd92/exfvEc921d4EVf9j38T+99nNePz5FHPtHGkP/5rT/KN33H13Hw6RvMrYbj7Tnh+RBjDBcuXEALRT4c8Kbzl8mkg2wN2vZwtUZi46/5LBdTZkczXv26l3H9uWfJTxY0boxtCVrlkZcLpBVjWUta0yCVoiVAI1Bphy1hWVu4loXnRiBtgtBiOl3ihivMlgXaCymTBZaUWJ5LXbUUVUklI7Ln9nHbTZZdD0tfY+PcOjNhY60MGGY1J7lBRDFJWRMLGN1/hdu3b1M1Da997at5+qnHObcSMd25Ay1oR2PLhmJWYFTAsl0iKsBRp0K2lWKRZpgiQfUiLFMhtYNbVoSjCAfJzv4e6W5NrhQz2aE1SKXJD5fkGjY3V7l+vGB15DNNZnitjfEGLF1F1Bi0LNnYHBJbiquHEyJ/TNQLSGcntMuM4fgFzG8ecvDUDLv7/DiBL4rGYFmWp6aXouXZqze4efsO2cGMzTMbIDVWMCY3BqEc5scTPNuhqZpTDQGt6ZRCOw4ICVpSN6c+BoONDSzLYnhmlcBz0Y5FXnekZY3dCxmvbhIHMaL12Nubol0H1wspkopKwWL/CNeJwQowTcviZEqZnSClYj45QfdsEA1Z0dDmOUk2Z5pO2b2xi9VZmKbFaixit4frewTjEfH6BnVt4WtNlh0Tj0b0RqtYgU8UrNCPRzSdwZINSTInLQvqskEsCjbCkuHQp0OCL4hW11G+5g1veAOB0xH3V0m3r6NXYjpLkZqEj7z/N3jvh97Hx37/V3js0T/k9qf/mKPJTbA8ElNCB2/91jdzeHiIj8fsuau8/MHLfPbOKisrFstHPscLX30/33b+RZSuh9WWLE5OkF2LoxtCL6Ztc/KTPV73da9nFPun9uj5MZqUJD+GbIK2W86cjdm/+hxNVrFx6QrjUZ+T4xTCBm/NJ17RNFmFMgqv01jUtFmD0gGN6iEdcOIYIQTatcmSBNtVdAhMFGA1itF4wOrZs5SNwNYwGrhsbvm0XUZb1djhCnHwpaw4l2l3Sy6uSo7nN1m/9yKboxGOn2OCgMM7txiunCOKNjB5irAHaLeHthWhrbCdHpblYUcRD736fhrXQcUWPd9C0NGZhp7jEKz1KOcZqjX4lubeF72UvPXIs4YoWqfzAlJ9mgUlWcnmaAU5HqD6IfO8Zi1suHO4oOc4zOZzRm7IfNax2h+R1oLE1NzKTqX4NjYCVF3htRajUZ9OeThdDM4ZZGN93vX3RREEEJLpYkmWVkjLRijNeNgjPZpw74VLzKcLAstDFgbLdzlazEmrHJMVTKcndEmOyStWejGR5VGmOUlWnuren8xxlUPPDbBdi2EQEIQudVOQlQU1DbZnoWwLW2lSGvxBn/kiQcceWV0gRYcb9gn7Q/zeCkIJOgHHVUM5z6Cr0AJAUuYN/bURJ+mCRVlTdSmOazjYv00yP6acpszKDGybwWjtlJWYV5AVmLKkqgu0clDaxXIHnL/vIr/+7n+H9h2e3bV53cNfSTRY4b/7yjeT3bzNvJzz5PYzPPvkp3n/B97LC/7aK/nEH38MR7t87rEnKYTN27/tO/mnL/oKXvWCV3HlSx7mDa/5BjzLpjzJUE7Aix58Bcc7BzwxeRbrwXN89EMfpPWnTMqSz+1Necf3vo0/8ixqVWF5IUmekFU1J8uUoioxdsPQH/Hi8xeYzY9wpGFeGbJKEPoxaWOYn8xQVYt0Q+wghKTCd2AQS7LDXeK8wVGS2WxBNIxoVEVjEjy3Q9slllVjacgnxwS+i21qpLBZiUYYY7DamqgvmB8tsZSN7/to/1QcZnfnkFC7VFITiZAam/mipZQWn73aQTciP5nzshe/mEpp5uKQrjeCbsp8uc/n7hxQ1CkrqxaiF1I4Cl8W+MGpYOozn3qS0NIs0wV3jvfAWPR8QRwN6RYNvV6A0dBzXE52r7Jq11iuDRQIUrTr4bY5G2t9dnb2cMqCxgh2Fxm7eUDsaeYduD2PEkVqO9zaPmB9JcIpJX2zZHMYEVsFuk6QPY/bizl7z19lPIjxpEPzBZb6F0UQMO0pw6yYzZBFCXlB5XTs7t9ie/86X/aG15IvZxwmE1zbwQiJpsXthbh+gOM5NF3D9Ts3KSjo9SOUPrXctnwPy/HxPBdbO5R1S9N26EawEkS0TUWbppiioixLbO3QFKcuva70ME2HrTSh7yMRpEmCcjUGiIQ61farBUp6+L7PcNhHa83aaIVhNKZFURoFKsD3QsqiwO4E0/mSRVWRpUu6riKtEuq2Yz5bgtFUVXHaNKwlH/id3+LNX/cNDNchX+ywmM341Gef4u0/8N0UmeZke8re3i67t57lDz7y+0wmE7LZnA/9p/9EMcl4yWu+imf+2qsZvfQBVtfHbO98jtpq8OKADR2yfes51tcGKLnOvS98GdLc4mBnm/Tm89T5iA996PcYBwLdFphKnNboVodUMAg9qtQjmWhuX3+aUmgcI+iv9MHuyNoUK/DYPZrRhAM0gp5lsewSDqZTjKUJB2tUlkfoaC7dcw/J4YIuk2ytXEBKm1Z4zOYJ2nHJ6pJcKaRrYXs2yWxK26SE2qL2QqKVAYvlCZ7uEMWSwLGIgxBtS2LfY1anmG5K1dSELiA76sDlYLLPx574UwaNwzg39Lo9wjBkdTRiYy1gvR8wTWtWhyMCpRmtX+S+ey5w74VLDFfH9F1N4IXYSBzfgxIQLY1SOL0AaRSHiyWzacKsUriiZpFApwb4WhOMttBdxWDzItbdDPfcasxgJWa0ts7Ii9gajBjaHkNPY8UuR9tHFJZhMQlIkoZl55Dmp8jAtXCFe1/yYg4nCYMNny+gKfLF0RMwQpJkUFUtUhYUdQVLm87yWaQVd55/Bst20aLi+OQIbRR5llI3IGtDpQ22afGVYHLzNrYfEzqG5Wx+ijvIE2Z5ged5HE0mjIZDJsuSvcUUKWymXcq6Y5MUBU7VEff7kCtwFLHwTj3kDGgpCJyAtjFEgyHKVIjWIm9OsQStATqwUTi+jWwlxjjYjoeNTZ4u0LbC9m2MMniWhz8Yk5cZvmNRLnNc32KaNtSdRDYdL3npi4lij3f+s5/i3//i3+a9v/br0LV85k9/j+cfc/n2b/92fuGXf4mV1THlvOSxP/40X/XKhynKivsefCVp2/Cuf/1TjCOL27dvk1c5VdVgREeZLjmz+gCPfuYxNja2uDwc8+mP/CZuOKZtO559+nN8zVvewn9+7y/yqSf+DGUchJTkuqUTUGUF88xDBzWxVRMMxgQaVNtgkoqkzogcn7qtuHB+izJJef7wgAeu3E9QZFjSp7N9aBNcKTg6OKC/uka/fz8lOSdHM9AKW9Y4IiLPS3wvpCgbjOsiXYusFegKhBK4TYelbSZpSRD1cMOAk507OKN10llKP4rwhMISgqypoApY812y6ZQw6nM0n1Nmho3+WaT2mM7n+FGfO7u7iKFhFG3Rdx3MuI+wBJ/+5ONEI5euCzk5zIg2VrBNg3B8WtVwkpZEgY0rNJ32cTxDaQy27XPunguE6wln1zf51Cf+CNeq2FvmxGLGomqwdENje1h2S3IyQTg2fuCwc7RES+itDKmSFNkIzNhnc9Dj8qVX8MiTzzAix7I8yJcMV9dJFinyr6I2LIRwgY8Dzt3r32uMeacQ4iLwq8AK8CngO4wxlRDCAf4d8HJgAnyLMebmF44CLcv5NhrJte2EM/fdg+5ymmVO3Pe4/syfsbJ+CTcc4UarFEVCMBwzm89RnsDTLXs3b+MPh0ijoFzSaHFXqMTG74WkaYJsO+q84LDdx5gWTUyaZRgjyZVF6LkcHU8BgWlqaDWHiz168ZCyqrFUe9ps9HzKvKTSAtl20IHlOnRlAUrRtClpAm4P7M6nTAqkpXBCn7aTCBQOFp0pqDpJp06twJZZycrQR7UJw/GI7Zs7bM+fw0iH48M9Lpx9Kd///f+cjbVL/Pb7fo2kKDnZ32drOOCpm7tcf+rTfO2b38irX/0yomjI937P2/ieH/8ZXn5xzNNHS6LBOr16ga8G3JlvM5kfcjs7Ynt7l621TXa2P437xu/g4bfdx0d++adphUPVHeKsDSjzBlqBCmxcJ6KtGtpOki5yurziH/7oDxPZPeq2wtgWerPHhSRkVuWI1lCXp9neAw9cYXoyoa0kUV/R1ECbgXbYvHSBcpmQFjPyMkPUDeF4RDNJaO2clSggazpCgLrFahqMo3GCGNO0KAWdC5Ht00iNbFvCwYiyA1sGJI3ApqMsKxobbNOwmGd0XcfO/pTVlZjGJCx8TVM3aNtn1I8Y9M+Riz6vf2CLpx8/YOfaVQbnz1EPGtzIJ01T3PNbrLua6TxjuTjh7PgS5LcYjtdJpzNsy2AqTUOKVBnPPH0VJV32b+ekRUdehqwPfMbjMdcWGcPhFmmdoiuLbOAgk5rl4oRzZza5eeMaddtihGSRzFjtjbl9c8LNW+/jwngL3VpMZ/tUxqIOTmjaz28h9pcKApwmNm80xiR33Yn/SAjx28A7gH9pjPlVIcTPAt8N/O9336fGmHuEEN8K/BTwLV8wBtDhOC3J8ZwoEsxPbtDr9bClS7ZsCbceojQtvrSQtiGyHJKTgvEwIt2fsp0dsjpcpVGaui0IPY95K4jjluVySVXXRAryckGvt0JBg2O7NGmLbFoGYYRRHfWyYdBfwVQFQsFkltJfi3BoKLOMhhZt91kmM9qqpudYJHlHYmri1sUSHdL20NoBIFs42HbFcHBqMGmkwQ9daCtqrSG0cayQJi+YzZYMx30sVTNYGdMpQTiI2EpzlrOMJ59+ksuX7yHuw4/9ox+nEA1lmhEMBrzuNS/nda97Hbn5clx7gA5O7SeLfMbuzavghnS24AWXLnBz9yrXr02o2hI6TS0czp67jBU4vPlvfCPzC2/goJRk9b9gNRyzd+dZVGuwFx1GGZq6wLddJJyaxtoxw9EqX/vGh7l57SmkJSjznCKHca+PrhpUdCqLLoDFYsFwGGNaRWe1yIOKPHAInIjF0YxsscSJYxwdUskjTu7cJtzcxHL6TKcT3OmcUoMf9XCiPnVd06QZTmBDCY5ySOYzwoFPPc/xlKLXOYh1h6YwTLsS20hC26a0Wuw8w4iafr9PqTQHyzl9FG4rODtwefqZO5SyIF6d8ScfP6ZSLmU84OK5K3zs536b/uu/kdWzEWqWU1YzSqUZDFz2slvoYUHNnGDsIwqfecTQGAAAIABJREFU0UrIjdtTiiyjrHJWQ0nVzFkfnsW1T7gzK2gPDa4/RDkNasmpvLoE29ccpzaTwyVO46J0w/begjNXztIlCcG6zdhE7BxNWD97llyv0C6XKHoErkT8VXoC5nQkd0+tuy8DvBF47935dwPfcPf46++ec/fzr7jrbPz5f4QQzPdTwjAkrSuiQR9tBMaxmR+fYNopWmZMpvvcuXaNw70TKtVxtHeHYDzkvrMXEJ7D5tYaZ86uUQjwKBGy5tKFc0T9GKc3JojHZOZUg7/Nl8yXM4qyoe0qHMuQWxWH0zukXU7VdEirY393l8cf/Qyz+RLTujiuhZAWUW8Abo+qzpFlTVrUVLUhXUxphc3JZI4bdOzd3OHoYB9Dg2kblrM5RdGQ1xmL7T3yKkW3BseyMVKQlZIyq5icTHEsh5/81z9JZSraZEoY5hzN4HVf/jLyaYa0bdpGIi0fqRWRs05vMOLOU9t0dQLa4aGoYic/wG4KHr99G+PGeL0WU+V89OOP8dDFhzBKE/SGfOff+R4+/uHfZOkq3vJNX4tSDjvP3cTUUFPQth227mE7Pklj0MrmcG+fdFqzc+dzmK7D1h69eHgK0CruiqdM5ggjEcowGMakZU3b1rRVgz20GLkjlsWSw8Nj/JWIZTYjMw22LYnjDarDPdxWECkLVmJWN86itE+eLGlOjpAlLKY5nRRMZ0es+DG+Mdiuj3I8lqIgLVqMa2EplzAOsd0WypxGl3hC0TUNIsm4sLpBMs0oypadZY3qhQxGfVxrlVtHh+RtxZof8eSTT/DN3/EdNPWc33//h8nyKZ2MCIkopxVyrvCSMeWsZb47YbJ7h/msYCWyGa3YnLu8QXypT2oneOse+SJjY7SBFQVUKqNOElTUMc0bRNvRKQvbt3B9hy5USC/gvntGWMbQ7/dxZY/aC2gDj/1pSjUvsdyYQd855U18gZX+l+oJCCEUpyn/PcDPANeAmTHm/0YgbANbd4+3gDsAxphGCDHntGQ4/n898+3A2wHWVte48MAVBoM+1eER0vX51HOP45cHCEsjp5C7FisrA6oqI61yqmTKhfURN29dQ/kWpjLsHuzhKJcL589wMpmjfIdlmpPlCZ7tYEmXjIx+Pz6FBZc3CIMedC1HO3OEkJSlZG04pMzm1KZl0F/F92JQLbdvXSfL1pkWCRpJS4erFVXdEUlNYyzyyrDcPSQKbPI8RQ17SN8hWaZ4sYPjhCTJgiCKqeua69fuIMsG1XMJbJeiKJBak+cJN248ymevbfNvfupfMU2mvPd9Nf3hKot0QdW2NFWG3+tTNBWL6RxXabymxnVdqgocofihH/0xvubhr+RJ38c0FqqqaDX8xI/8Y77qDa+kdWz+t5f+MJPJIcaqOd/+F85fD/nAb3yYfugzXRwzsEYUCjotQHSEsY/VVRR5jh875MmcxSKhxcLzFVlZo92Atm2xPQeUxhQFrvapOkm/P2R2NMG00NmKxEwYeT69+zbZPHuG288+x3x2jDdaI0tylOeRFAtMU2Abjxe/4lX8xgd/g9X+gNKuqLMUqR08L6CtO+b5kqBz6YSkkRZa14CCViHbmrJsqU1Lvzek50jmyRJPemi7pK5yzsQxVdFifIXX1kS6z/F8Sn/zDLPpgigOGQQDDvcneJHH/a98FX0PjhcponNR2qOpczpHki8rwv6A1WiEMOArl9YkfPDXPkC/P2TY3yBXE+aFYt1YlE2BSitK28LUktBpoItYNCVaSx548AK3bmUc7h3Rxecwy4x4Y8zh8pCiLRnHFYXxkF1Ih8Hx+wTd56cR/6WDgDGmBR4SQvSB9wP3/2Xu+wue+fPAzwO84MoLTNcBVUtj+Yim5UX3vRivFzJZzgmbhlKcugJpFVC1Cs+yqaTGth28Fsywh2MElWyRqqNtHXxXUt9tJilLs3uwix963N6+hev0qIsMJxhRVxVhzyUvKlZsC9PkGBlgyyWT3QNEIKEwDFb6LESN3Qp8z2FWQZ2nDCKX1NQoc4p5iHs+bZVyMDsmLTpuJnN8f0h+c0kcDZCmYvrsVSyl6A9WwRiMMXRAWhW4XYAxknh8hr/7bV/NpFowX+Q88dQNpicpN689iXZijKXRRUEnWs5trpI2HdkyYTBaoZEVaZLhtB3vfu97qGYn/A9//x9SxxFXLj/AyfEBwrG498wFjk9OuHp9l9XzmiiZ89v//ofwzmxx5uw606Pb+KvrrOHwzPYOxmqIQw/KjNl0we3dOW988zcyGI+gNuR1S1NUCFmhhEQpgd3r0WLIhSSUHnmSYTk2ltKkScJSNIwtm/TkmOvJEi1sNi9c4s7123iOTS17tI3BlCWZVfOn738fZ8+s88gnPsGlB16E2wspTE2b5yjbwfc1XVEj6opaSlrVYrkR8+UUL5CISuM0mlm9xMMjEhZpc6oYJRqBdi0cI0lMTBiUp30eFwZGUXs2ngig66gKhSVOCKyIImvRXc3ASXjyxjba9WhcDzFLWFtbQxQ1071dRlfu55mDmgde8RriyGNoCeaVZLxiY1SBbFpa0ZLNK3qxIJstmU9vsLK5RRP6XLtxhBdssRG6HLaKvLPY3plz6f5zXH32ANX1mJXXeeDMBZaLBdP5LhuDGKX/f9IYNMbMhBAfA74E6Ash9N1s4Aywc/eyHeAssC2E0EDMaYPw846ma7j1/HMUG+tI0eJZIYtlhjM5YW1jlaJr+ciHf4Mv+4qHcbzT/XxBw3I+R/maZFkwrBu80ZCkTDk5OiEehLTl6cJ0Vcf8ZEEcDImiEFf5CGOQsY/QCqSF6CShq2iNOEWaZUum+QLLSFhWKMdDuiHlyQRfW6R1RRjYLJdQC48ynTM72Wc8HlMkGbNkwTLNSYqCjbU1/NhlfnWPQglqCrK8wPdd5tk+dV3jLBVLy2C7Lk9ef5yqsGC5ZKlc9N4Jh8czHvvM7+Bri2ee3KVdOeKMDKijkE53TBrNcH0dJRTCDdBtAZaL5dtslCXZIOTf/sf/yNd/49fz/FOf4YWX7+Mnf+Kf8LP/9r0Yq+Y//Pr7edM3fylPH+3yole9Gs8ZcK7nkF12GJxZRWaf4/r+PtJUONqQzAr6ozFP/9Fn+aEfeAfp8gDX1ljS4EY+ZdEgBAjbpstypPaxuubUMSovcISicmvi1RinlcyqBqkVVKclmZ+OiOOYXhAymU0xrWHRaHzLoglduqLg/nNr9FWL6rk0RKf284FFk2QYYyjKFldZiNalTWcMBis0SY6xChoserYPtqZoS3pVwLJKwZakRmAFYFUZ0g4QwOX1M5hkiYxHdJkhyxMcX7DqrHJYJoQrY6Km5fad63h+RdTfoB8qHn3yJoPRGehrmpXzTNKM0ApwlUeynDJzFIPxgM3VB/jMZz8BdojjjnAiSV0vsftbRL0hbWuokhrTHXF8XLIxHtGezPBcn6ps2b26g0QyWg0wxys8f+uA8+fPo+bLUxHVtv3/HgSEEGOgvhsAPOBhTpt9HwPewukOwduAD9695UN3z//07ucfNX+BcokQsLq+jhCGRkLa1fSiiPTomDxPWaYlr3zNyzFlgdeLSYoFllSEgyH5NKHRirKuGEQxyyKjrQ2z2Qmhv0KrO7JW4AcWtSWYnhxhUCyP9xhtnaeoc4ZBQJrmhHFAskhJ05ymaYjDGKk6kskCR1tYQrC1OqJtW4yS7Ozs4Lo+bVdTtTlr4xWSPEFpjXZsTDpjPIwxpiM7XhJvrCOyGi1hJipC7XG4e4TqO6R1QT5r8bSPl7eIvILIZtRa5MWUtQfG5L8j+cG/97ep3JSt2mFntgN7krptGK1sMpncIoqiU3caP+Zwf5dWa8a9PmWVIg30V2IeesXL+dT1xxif9bjx9A4//I/fyZ3dI574X56lcBS//LO/wN/7Nz9BkWRQHPC2b/puHntE8YePPEtrJItFhW5g/3CPbNZgzB6ShqaBoqmRnUFrjUCf7srQnbpM2x6WJehFHqLUKNeizBrsaklWggmc090FZaG0DUKwNznmzEafRx99kvvvv5+6KanLhlJ1OPEWSZPhFobp/IArL3+Inas36A8dlvMZobZpMfhaY/sOddUirA5l+nQyB1FiyhqdLWi0i9IQOi5C9WirjFJopMxIZwm5JdFFA/MG2bNQSpFlGUdCIkRAMUlJ8gXD3gCZ+8iwIq8E973mVUSuwfJznnz0syT9FcaDdWQxQXsOvheQLWoeP34MuoDhIMQWHceHOWdXV0/7JP0IVMeVc1d44rmnuHj2LHVWEnsV0XiVqurQsuboaI+DnSVJVjMMXXae3yZYsdk+Mf+PwvWfN/4yYKEN4GNCiCeAR4GPGGM+DPwj4B1CiKuc1vy/ePf6XwRW7s6/A/ihv+gL2rYjHPi0ePgIiskB08M9hmtjyhbspgbtoHo9MmOQdozd6xEYQRiGxBtruP0+nhviSIve6pjx6iZNlbPiRzRA43jo2iX0fISAzc1LyGWGKAWLdHGK6mol0lEEgUd/Ncb1A/pBj/ULFwkDl9C1yGbH2AqEEKwN1zgzHCAdiMMBUjv0wz7agn7YZ3N8lvsuncEJYHXDxW5KxqMBsdfjTOAROR5nzlxgyzk1Cllf38R1LExP4/dXcW2XYLTFxuXL7D79PAM6hOvja5u8lvQHW5y/916u3HsvuchZ1Jq0KDnZOeTO9g1c26FuGqrZHj/yL34cKxjw1u/6B9y7OeDgxiGHx9CYiAvnzvK33vJ6tlY05fKYD73/VxmkHq+8/DKKQnPlhVeI/QGtSClaQc8WLLoK0Xn8/sc/SpFA0UgUFnanToOkMSyLHFtpknnGYDAgFzmFVKfAFVlimhQtJfbQRnuSMl0gbZ/QD5BIuu50oR4+f5MXXNjg+ac+zbn7HmBZV7TTgrJIKLMl0SgiGoZcffwpFvv7nF3fpMZBeR6XNzZJdUrbSKo2wzYtTb6g7k55BbkBZzxGSMPWeERlFHVbkeYlWIYWSX/cx8sl2hGsrA+wfItB3GdzvEE/PLVWF5ZLEA6x/D5bZ4Z4tYeyLSLlkk8aZrlHf3SRs9EGe3fmZOEGPddnvsxIkhl5YyiChvx2wtWbt4hUzvUbc+qq42TvhOV0zn/5449SlgU7kxlXn38ez/aZ7O9yvH/IfJJQVQ0ve/mLaf0ONwxQUYyrR5RNi/UFevN/YSZgjHkCeOmfM38deNWfM18A3/wXPfe/Hl3XsH1jh3igMU3MxpmzbM8S7uweMIwisCWjICY5njM+MyYpaqquQppTae/qZIbt2kzaExaTA7x2iNsLCQd92q4iUNCJivnigOHqBVYCn66tEdYKQtfUuSJNSsquxY5iinIJnUSYijwvURZUCJCKaH2LxWJBFNooXaO0Jugs5MDQ5DVtVaK9AZbWOK5AaY84GrGcZ8TxgCI/odMBneuSKYHnGOrcJx6exfYsgmjMfOLRJRPa8RbJ5BjTSd742od5zYtfghOEhJbDSZaymKZYStBQ0uv5WG2LtEH1YhAWRTrl/Pp5rt18jLd/y9v5Z+/6ZX7rt97H5pogUCGf+NSf0FMJD33pm3jwgS/j1rP/gBNj8c6f/Ake/po3c6wCiosl+WyX9fNbKAPC68jKJZYRKEuyt3eVrk5YXxszPZ4gnR6B7ZLmBZ7jUXc1dt+jrlp63hDXFOzfuUW8dpm2K7CkoWoCrCClFDFtVzEejUjygkVmaAuD7PeZdQ3+aI3jZz+LbUpmXcFKsEZZFNw6PMBpXfo9m1RLPvfcU9jaJfJ6JELgtQFpUeB4Hk1VoWwLIUqM9PG6kioV1EZxfDQnSUuEbIkHfYo8QRqoajDawvZ9kqokS1KC0KcxFa50GPoOVgVHyiDqks5yaCT4niZNlvjjEKvuKGIHpSXhmsSeH/PEU5/jwVd/KUmR4OYG0+a0ocZr19idFcSrPm1qCCzN1oUtPv3kVVqhsD3J6toW89kJhdVycXievcU2bufxmT/4JJthwPbuEa0S5NUhbeVTf4FU4IsCMaiUpmkLFksPe2yxqFJUugApqJuSxWLB3t4BFy9fYHd3GyEsirJha2udyeQQjEWbJfS8Hvfedx+70xl11ZLmOb04Ynq8xHiaPOuIO5hNJgjtYamaJm9wBPTGI2SaUVclA98DS1G3PkII6jKnlUDdQtuxMRyRpwXK8cllQ8/2OJnPcL2ARZkjioLOsghDn539PbzIR3U5nttHqTGua2NWYooyo6oEVq8la05ohMUiPzUUjVYi6kbQX/fYnx6CqhlvXUQpQedKRksHy08JtEtWKSI/RlkaKQ2WjhCyptAGhMt991zkM89PedPDr+Xt3/q3+Mkf+2ne+U9/iGisqI8GvPvn/iVN+y7i9R7+bM5+2/L8Myd84pN/QJEEPP/Us5w5d5m/8ZUvI9uvuXNzl6GnmUwX/PS73kVVZ+TpgqxKqbMFg+GIIPDIkpKsKRiP+gRSsz2dUCvB3nyBsW4yGK6eMgar9vR/kIYoHDA5OcHybXRX04tslHaREmxlsxCS8eom9smEdDonWomJ3B5Zayibjsb0wBgW80N836eeVHjRkJdducSN23c42dmno6XqOhwtMO6AoBWUbkNdlAjXwpEOeVbi2Q7JMsMKNU7YoymX1HmKdi06Y6gbQ1VWBIFHZzc4RuLGPk2dYTkeVVoyHqySdyXGdhjZHqkpaaMe/SDglV7MPJ3hdS1HbcmWf56COU4m8VYMy8Uxi0VD4HU8//hjfOkLX8Kjn3yCtnWgq4mjAT1RsDAdbhCR1DNyajotcYMIW0HXVDi+i2V9fgLRF4XQ6D0XL5uf/blf4CSZEUY9bK2oj4/QdsAsL1ldHVFnFa7vo9qKVtnYFuze2WZ9fZM0a9B2jev1T8kkSnHr9g3On7vIbDY7LQFsTV1WpyKklsf+yRFFknJmfY1SScrFAsd1mU8XRP2YLF9AJfGigH4YsEgXKDtAVjmN1FRVRdNUp5zyDg6XCwZhxGAYkxUpZd2ijSYrElxtURhDqCRF2eL51il5qRFI0dF0Na2AZpmhlDhVUq5rAulQljmIGixNlmUErsuySJAlOEoRDgd0GJp5SkpDFIaE0iYVDY7tU2Q1g1HIG77qa7CVz7VnPsnf/Zvfy0Nf+9W85z2/hjPYwp3t8gs//9N8/VvfStEqjo6O8dQmytrm6970Xbzpq1/KoBfygV/4P4i6jjd+/49wcLDDSdpy5XwPUdR0UnCys0+0sYY2At/RWI5LUWUopSjShDwvsZUmXhlzdLBPayDuRbSdJssS/H5E4GjSIie2bNLSpjHHYEIsW2FrhW5PxUisrqbtJJWokMbCsyRN0+D3+xwdHBPFIfuHO9jGZtTvsUgT8qzly7/qdTz1xDMkZUkcuORZSdtJii5HLRM6TzJZZKyFfcpkhnJDWulQ13McO8JWLVWZUZqWKgfXPaXoth3opqL1fWx9WmdPJ1MC7VJbkqasMMrgElKZOUlmaJuCuO+Tz2uENjhdj2BgWLn4MpL9O9x45jnqRuPHDVpKyq6hawXdAuygxbNtbh/NELqj54akVYKnXarqVO4+TVMsXxO5Pv/rL/0Sewf7f25N8EVBILJsi73JHlFesP3o4yz2J+hoTGEMPc+lLVrSYkYvCLl6exvTlSSThNWNdRZlSdwLcFwLaSmyosD3fdbHIxaLJV4QkNUVTV3SAVopiiQhtAKiKMTIlmT/kHw5w0azubXOYj4lDocEowFd1zCfTymznDzPwbNJkwWeaxNYFkrCbHZC4CmyfEGxXFLXJZYSLMo5QrZYrkPke6R5gnYlXWOwqg5H1xhKtNZoY2HrFrfn0dCg6pq0KrAsg0QiAocwiDiZpQziTapG4/XH5EXFMkupXZvVaIUoHiJ7fbTUeK6L53m86g1/nb/5Ld/NX/+6b6BoS/7Oj/4MnnB47atfTLWs+K7v/e9pHAsnlKeGl3Tk1R4yr5mmN3F6Hmtra1SHx2S5JnJdGtHiaYEqDUEQEPUHnLvnDGPPRXUVRsDVmzdQQlIlGUo7rK6MMUJyON0n0C4rfY8wULTtlH7PxpaGKsnQGKRroUWFoz0ClWM7MEvnlPmEKj1m/3iXypSUeYZvnbpXZ4s5B3eusdX3SGcJsrEwSI5mGXWr8FTDs08/R5ItGfRHXLtzg7pusbvsFN/vBCgRMrBDUinJvR7G8+lkhxMGIFumZUEpPSzbI4xDHD+gxsL4msZzTnUkpaJOC3zXotEdbd1h2SGebaNciVu3mGKJb1soNwTlUtQdVZ2yfWObzz7yCE9v3+HcA+dpm5RJWpJlJUHl4ylBGHd0Noiy5NKZiFe+8Ao0JbqoMfWcZbZE64aB7RPHEVk+x3R/hd2B/xajKjOe+tM/4Z/84Ds4PHwPH/2VXyFVDesXznLu3st4tsXq5hUOZ9s8cHmLsgtprSm1kdRFzn7WMhy6LA8XKKthsVjQCou8W2J1isDSzNKMuBeRFi2eq5FIwi4moWbt/AVmB4c0tuY4yTC2gx96HE5OqLOSVkiGAxdKQ350yGi4hdaaWZqSVzXn7r3E9GBJ6bfMq5qeH9DmJQO3R5nVTPb2sFYihOuwXNaEoWQZKkyaE3kDZvM5oRNQotFVi5IO7cBmIDVaCBatQZYNsudyqRdQliX3X7nMZHpMHIUU+QJL2kj3VMVn0BvRSYvjaUpR7PHBX38Pv/NnH0fXC65d/T5+94MfwokMv/J//jaup/ixdz7NHz7yEU5mDWlSoxwPuhFf8mXncdqQ1XjAdFYS9wUiWmGeL6HSNGWJjgPqxZy6aqEqYRCRLVt6teHs2gZ1XtAaDVVL1y6wbJ9er0dEy9Vr14kGfeLhkGSxZLqYoqqOfhQxLTK6OiPNJZqcxk9ZGcSUeQ3S4Hg9qmSB7w85OlwSDTwcKUFbWJZCUDGvW9YHPqatkW2J7mrS8tSFevf6NaImpCmmbGcdYWDRSQtZQmsUi4NjRuOIyBLMqoaucek7ip5rMy1aqA1SOzQYXNXRHZW44xEitiinBqc/pDjaw7MFfuBRA5VUZJNjWiugtxEjqxozXdBVBivyGbg+TBXOqmKeCg52n+XMxZh0dkz/hX3SJEefKOwTl8LJmZgSvVDs7DyPCgSDs2c4vHnIZtzDCNhe7LPZVMSDPvxVCET/LYbSNm/88tfzyWeeJjh3D2/7+69hupjSD32yxRJ8B6tJ0M4KRZ2TZ7epK4hDm6OTA6TtsltJHnnkUTZX1vElHBUFKysDxuM1PM8iildI0gW9MGY62aNtc3rj8zSpYTHbx4s8uiyhTlJGw5AsrbG0jY4gTyqaSnA8OeDCuSsIbUiKBbrno5cJs5MpnqewWkNbw3K+JOgFUNU4QxvbG2H3euTLhPniBsb06fV6aHdIWmbYns8izVCOBUIT+wHLLGWWZYz7I0x2wsneIeevXMKxXFojODw+IBzEuNqlkxa0DVJZRG6FbDKcTuF4GtvZ4n3vfjf/6n/8QX7gn7+L7/zut7LIUsZnH+ShBx9i48GL/OcPfQDdNKSLY6xgjOdIXvTKV/Dh3/kP/OYH3oMrA0y1i98bUyiL2txVzZE2m4OQ0g2pTI0vVjnav8WZtQ2qTuC3NbvHCaNBnwbFcjbH71nMjw4oY5+zL3mAZp7S5i2e3yN0PaZJhvRdHKVoao9MzpFdTBg6pNMpTd1heQG0BV4QkKRTJBmzyRSMxpUNz6uIpM5YtS2sPOPWndtcuvIAbeNQLA4J3ZjM5CAFSlqsBQGOMPSiFW4f3MHTFioKGJ07z51b24hG0lYpklOPC6fLyXVHtpxT5xmr62eoBoaUElOmuMMAqgxhgfL7pOkcx3GwO4HfG7GcT2gaQc/vUQYSz65ps5q5LE/Zr0VFl7SkhU3e2sxmHc1z4CJoOsGjdz7By+57HUFsOJwco6OAV7zkAZ64ehXtCRZyxoYbcfncBUwQcrj9PEp/fjPCL4qewP1X7jcf+92PcOP2EZPd5xBKYsqa2pJoS6Ha9hT1J+Wp92DT8OBLX8SffOwRivkSO4roDfu4rkvatLRVgR8PcDE0SU4pcv4v5t70WdfsLO/7rbWeeXqnvd89nH36nNOj1OqWhAAhIwskBQJisFPB2BgXMRAi4pAiHxLboeJKcJJK2S6cBCdOnHIq/mDHsU0oCGAXFiBBISsYJDS3ejjdZ9z77OGdn3lYa+XD1kfIp6Sqn//hudc9XNfvGrkKHfo8fvQWd197gySYs14+4g8/9yX+zJ/+GHcfXzAbT3j2hZd4+PAu3/rB72S3ymlVTbmuCEKHvrNko4C2c0C2SBUwDAPNtsAycPLUTU4fnRGEIdASuDG9J9meLZge7aEHS1XvGLRlMt/DdoY631y3lJ1mvVkSex7pKOGNR084PJgxlC1x4iLdGGUHkiRhcXWBMYZaa5QB13Gw1uJEAY8fPeBof0Y6mXK5W+OtDNFojAwsR4c3+Jt/5+f5xV/439nqlKcPbtCKHNtZJjf2ufvVz/Keb/g+fulXfoGf+c//S37643+JMJW8cHNO3xs8JUHB//SPfoHdkxXna81f/vjHeOOrX6PtO4qyha4DN2A8iRg6jR4ajFVMD4/pioJ8t2I+22OcpCw3SzorWbc5elchXIGDQ297pIGub4nTgNXFmmSW4WqDFg5RmlIXO6RyiTwf11XUdU079ASxw/ZyRxAE1MaQ+A5ND56EN954k9s39pnMT5ju7fPaW69i+x4hQ8oyJxvtX+sqxjPyMkfXJVma4nsh6+USzTXIRCpobY+jPeq2QkqJMYZOQYjA7zUbYekY8DRYR9LUOUk6Ic9zrNWM3ZjOcdltr651DJ5HvdixjQ2ZsWxzQZqM6YYeM+SIICFSAttBHyT49SVV0LA7rfHHKYmUDH5MvdzgRA52sPTbNeE0oFhs+Z9/4Rc5PXvyR7YDb4si8N73foP9tV/9BKG8lm9KKel1h+969H1PNJpiq4JoFPH657/IICVlUVAMLixfYxwEhNPNZXMhAAAgAElEQVQjmragLkrio2NE2dK416zButkiRADCwXUkFsnQWYQzYIVPW28ptzWHezOSMEE3G4LnXub8zde4OH+L1dWWO7MJ//TXP4Wsc9ZlzjtffIHR/CmOjo6ub/q+Q2gbgnTEclWQSUknNcYYRrMEq3xcN8HWOWawVLojCAJCJVgtK7IkozeaWPac5yuGzjA/3AdH0TWWvqmxyqPNt+Q25zDdo1UDXdkijUs8ziiaktE4ZXdxRZod0lQF1nOQfYsXBrRtzxde/xq/9o/+Ka8+OOfdL38jv/e53yab32C3afGqCyrr8I3f8l78ZMp68xYzL0DXivuPLhHZPj/+gx/nYE/xcLMhjo759m95D335KvluRzYagxuxWTwgjEZUy5JwkuAaw3qzY3wwRVcaXEuzq9AupJM9ym2P06zIlSJOR9h8w7baEqcJkYzB0YjO0FqLE7vkxZo43qdZ3CfwRrRdjZfGDNbgKx81wLpeszeZsV1skG6FiQ7xcfCNojUtVdvgVD3OPCXyPKq6p9hckEwP8WVC05cIfNw4pG972r5GmZZ6V2FlyPhggtWw3a2J4hTdaxzRkW8afKtpAsOoFxB6rJqONI3xtaHJa3pH0EtNaF20GGiNxNJjG00Vgr/tOZwnvPL6a5hKcXjnhN7R+G1DuTU444xdcYFSM8ZeQEmFNpdEUUC/chAqxTMOi3aNSBxS1+W/+Vs/x6Mnf3QReFuMA1obBjSl0WircRwfZSSu69L2HbopEEJwdrZgenyT0WxCnZdMI8GmukE3hOAF9E1NEAQoBLUcCAwMvWZbLDGtZrNeUqwW1+gux8G0PV7sMzk8oE4rurZGx5JGu6zuvY5pSm7ffIZpWoCS/MiP/iSeHSiqHFcahAwReuDgYE6vDI7pqJuGG/sxV7uctz7/KqvinHsPn/DMO97Lyy8/zYM3z3jve95FudkQTqaEJ4eI7Yb19pShMqj9hCgZMfSSpjO4g6VpBxrTo/qGemhAxCx6i9cY3BZU6hMKMD10ywoHl6YqEMrFNZIkm3C5WJJEgtN7V/z+Fx4wfdcJn/z0P+ebv/3P8drXPkPfLum1oTcb2srlgy89x1c/a/ndP/x9jl58mj//Xd/Cc6FkmwmEkuw2G44DQyBuYPyYILI0gyYSkAYjWgGT+ZhegWh7gtkI8gIbJxRdw0hqit6yOj8j8D3GsxhfSBwBOZo7N09w8bgsdtRNi216JNDXNa7nIrVFevvUWFQaUOxKRmmKH3voBk7291gtrxB+TDY9pKlaqqpEBiFvPnrAdDwhOryJGFqUm+HpLYoZHlD0FXGcIdSAYzqqas3+8W02l5f4k4iyXHB+vuNwekTsXpuSjO5ZbFdMR4e4QtDQoD0HawWOMJimY6cHtBK40iENPOr1muzghKkXUGx2OL5m6gp29YZmZ5nffIGJq1gVFdIGDF5KtDcw2JaJk9EoS2M1Di7j8JihEwinYplfMDs65HDjwEGKzDuk83ZHjitBu1vgehnKkeiuw3MCrBW4jk9dN/i+j+85OI7HYrFgnGS8frqk/9y/YPThP4NqK/ZGGWXbgJQ4ncRNPIo252B+wq6q2Tu6idEdbWfJ0hA9CIRjCD2PsiwZj8csHr+FOHqGR49fJ9eAcIiSAK0rsnCglh2x63KQTNkMGwI1QgYa2QjqqkMYQasNroXnXryDE7zIe/MSdzTFtJqXv+F9BLJlNks5mE85XZ9zeLTPxcNT9kYRiydnfOGNuzzzjpf44hc+RzIZ41jFOAlQfsiN4wNMlOFIQ1X3jPZGLFdrzrYG6woiOcLxQ4RyrzHdbcXF1Ro3TMjLCnSLVgui8A7vfvodfPbTv4jrRJi+x40zqGFvlnLy1B1+45OfwpgN9z7/u3yFnv0PfojICdjtFjRDjj97ntX2AqyDFALpCqTQVF1Lmu1RrZd0QqCUoCo1rTMwsw3bXYfcDzGLHdPZBCVdFvmGomyYTUd4UczQC8puTbtZEXsOhCGtEdTVjpk/wxWaeD7C6JauGoimYzSWoqjwVMDi4oxdvmFvMsXQY+W1uGm7XXN8MMdRMU65xfiGobQEUlF6CuUm1ItHDLstQeSx3QpcL+dq/QTZC6YHM7brLbNxRqU7Yj+kGzQIlyDO0E3BeJRRtprqakV0cITrCoZmYLAGR/o4SlKWNV48IV/nlO0ZrvJwXEkmAmQSQqPJ4ozi8hwhJQOCWSTYlS2+Cag9hes0SKVwesEyr9kLU+pJy4wjhnpN5yjW56c8nT2FMX98x/+2KAL5esPd+/c4iEeQai4enPLiix8kigNiP6J2JarXlBgcRzGaTNBdT5JN4APfx82DA7ZVzSAN1gy4IqBRNYPxcByJMfpabGItpTYIISnbjigKqMuGvu+xEvKipPUSHCzPv/N91E2H4zhgLUEYcnr6hFv7M+6/8RoqCKhOC4yreOONhxwcTph6AcYRuMqyN02vsxR3K9yDQ+quRCgHbQStcZmGEx6dLihXV6ybR7jhBBEPuKNDXnp3ymg0Ye+jHyWIfMI4ohMuWRjgYDh7uKIyBbvVhgd3XyeJJyjTsalKAmOI96fEQcLDJ2ve8e5n2ZUtxabk5sERyrY4ap/AnfNdf+oWX/pvHyOGnCRSNINFm5Cr8zV+4HHj5Rd59ck53/n+DxEXp/zKv/41fvYv/CU+98l/yVCW3Lo558Y0pjKWVbEh0IKt7vG966i3YDShyXe0u4507OPLkE77xEmPFRZJRbXZkB7u0aCYzaf024Kq14DEE5pkNGMoc9qywx+5TJwM3JC66mm7HWGSMogaOotjFbkQzOOQPlBMxhEaRSJ9Sq8mcEdkszmnTy6Z7U9ZnD9m7B1weXVKz0C/2JJELyIESM9FNyXJ/hhfPEVvctLxlKEuOJ7vUfYDaRwRKkWz3SGHnnESogbBpi3wnRBvHqIkKD+loyUTFi9JKLc5vvTYVAW+m+FHKal2qf2WWmTIoKRqKpxqiXMwwhYNgfRozIAdXLRjCZ0A03Z0xRZvkiHzjsaXxDqjTsDp95CRZH8tOLx5jBBv8xOhE3iEmys616c4rwmDEY9OX+fiwbX+PQxDqqGjXKyZHc6JZ/s4yuf04Snv/xPv5+//j3+bD3zwwzz30os0VrEzHYFxuH/3TY6OjzGAcj3WeUmQBtBrAkeiqx0SRVnUpHFGUdeEUYztB6qqQesea4brW3drmU5SrG2Z3ThBGssz8xnCKg6fu40XJLgC6r5jmo3Q/UAQhVxdnjIaTbj76pdZXy25d/dNbt1+mi8/+gLzo0MmkxFO4GAAYQRXZ4+IkoS63CAVNKuBIa9IRhmL9RLX9XHUQOInBPsJJ3tHTNKMoi0Aw3K7Zj47BmnYm87YPzjh4OgpAt/n0eMzlkVDNkkJhgZt54yIIBOkqcK3IZen5zx89Aa/86lf513vfDe/2f8yn/hXv4NLjYoPePj4a9y7eAtHxYRJeg1TqQv24ohhscDNpuRUzLKM7XrHycEBHCm0qZHm6959JSg3W9I0oegNm9MtaTii3u1AOXhCUTcdyTilaSvqIIDaYDtLZQVVvSUZJzgy4sn5BUHoUuY5d+7cwc8XLC+fYOMRQSrx657H1RppJfsHN9htdkz3M4ryiiJv6Yd7WOuyNxmhgxjrupi2Ijq4haMrjK/wTEPXa7Sp6XpLN7SMJ1P6Okc7UwJHMQQWKwY6CfP9WyzWK3zfJYwC6mqH7C2tsF9XRSbguERDQ9N0WNPjJBanMBiuaHRNOtoj6FxaYsq2ws0M7iAQ/rWCtQ9jsCFpMGZbbxlcD88IHKnotSGeZVRXa9TeiAdvPgT7/5GV+P+vTwmFPHqG9fKKSPU42kG4MV3vQpAi3JhICvynj0mCCGUbqstzppMR54s173nfN7JbbfjdT/wGviexumOx2zGfTVnqnKJrURZSP0SZOVJ4aGuIopi6rpllEWWZ44cxVVXgSXVtRR00roEw9Oi7DqxCDwOx79F2A0oKhk5ft4RdBb5PLCTd0FCXJVVXEsQJm13NdH6Hd7zrfbz03m/kK6+8xr/xPT/IbBRzdn7F3nyfrir4v/7JP+QbvvnbEK6mKnbEQUZTlxAltFagAocWg5AWPwjBNkhtWV2cQjJGBgq3M/T0dLuC2PF4vLggCQNE7yDkwL1Hl3z3x76PNq85vnnCs++b89pXXsEbT9nllj/xzR/i/qPHDI5GDJKuKwhSl76QPCzO+Xt/43+jrQvKcuATv/4Z7n/+V/nwx76fvaM7qLonZsNklFFvWkI/ompzlFUgDUPVEjgendV4cYojBAEafzKmLQWjyQEjP+Lem6+yd3BEm18Qj/eR/UCUKExf0UuXsBwYqoZVURF6PmqwzMYj8sUlpVGUWpP1DYuVT0bA2Etobcnjxw8J8NCVRroefuwRhi5KuQRxStGv6fqCvfmUvtvx1qMHnJy8RBB1mNqgvZLQC7DWUO62hGHIkC/Z7mpObj9NvVux2WzoohwhOzbbgsHGDGVHrxTjNKFqK+rW0ipDoDt6RyALh8KTWJmSRBrRhDi+oW5cBjEQBBFSO4Sxy6be4Ysxyjd4cYg2Dm6f4ytNoyxa9xwdHFPklwRZRlHlbNsaId/myHGEYBLECCl5860zTBSBHnjfN34L+5MMRyhaWUFdESUx0s+YHd9GBTG67WiGBi9JsAKCbEw6v82tw8NrD7aReOpawFIhWD654N6br3H15JxXXnmFVz/7Bb78lS9y8fgeX/5Xv8Xi4Smnb77O2cPXePzqK1xcPKJcX9HWOb3TchAFKHoS38Vqg+NIdkWOVA6ttmhXsjg7x40yAs9HDhYlDUHoUex2CNfnxZdeBDtQNi3jLKVuOgoDH3z/B9G7Jzy5WuA6Ia0ZcPyAvq+vx5LagHCxyqNrKqSCwSq80R5e6OHlHdOnnkZGLtl4H6SPjyW/WnH58IyriyvSyYS/9fP/Nf/Wn/0+btw85vX7Z/zQX/wxXH+OEA0/9e/9Oyh5wMVX74OfghkwMibwRxwdPMdgdmx3Hfmm5h/8w3/Mj//kf8iNk1tkvmL/xoj9G0dsFmsmmY+xNW3T8+DRPV79yivcO3uLr919nfV6yXZxRTAbXbtAkxnJyKfPC+q6Jp2MCRyB6025cXwL2w1EvkNeXEuQ4zjGGkU2TlEOeIFP3WuiZMIkTlHaEEiHzINWlCyHJZsiRzmWeD5FBobNYktve/Jdx3q9ps53WNcl31zQ9R7aSJ49PMaPe8pNycHhEUYqirwicANcKuq+xrQ5mTeweHgfJ3Z44eV3sdmtiKKISRqgTIsINX5jcJSP0B1DVxA5Bj10uEKiHc3YjwhlR17URKHCaS1t26IGiZUdvZLsygJPBpRtjW4k20ojRcc4S5mMZ+hdg3ICdos1TdHhiIZASqKhxXu7LwaNsSzWBdl4jvtsgJeMcH2HbV2i/IDMqYmz5+l0xW51gfJ8tBNgpcJYca3j7wrCeIwaBM2wY350m+rsjN3FiunxMScnJyzzLUMriDKf1eo6VdcZJ2gECIE/nuO7cLXe4Dohoemxm5zT04f46YSzV7/I9gMf4v79h4RhiFICK12ycUpxWjKaHzGIgSzKcGyNFAmlKAjjkLZtsa6kKgr8IKU1EAcBGEOEYTjfkLz0LuLVDP3qI55/+h1crs5oq+sIc6EF1VDRXjak6R4Ww6AdosS7tu5qSWfAq2p0cE2XdZOIvqlJ0xTbNDS1oN8WdIsrPvP7X+RAadyi44d+8M/y67/5WygR8Sc/8mHan/l73K8vCb/4WUIvQWmJFAP6skQ3Hetix2x6i7X6Ih/9kY9z9w8+zaa5jtyqq5Lp4R6NtUjlcnJ8zFNHBxS7Ai176kYjpcRD4giBI8GLYmLXodztaPuKTV3w+U//Lk899xynD96kLVc0+zeYzg8R0iVOY0QSYNr+OlXI83CFZTqZsbp8wjNPP8+DN++SjSakUYBUAZ1aUKy3dOOawLrMUokdT5H1FuvH1FUHQpAmE3rT4fQa6zv0ZY3jevTLBduyxA1TyrxBmI6mrYjDGbgd8ThGVz2Pd/doC009FOzPZiSO5XxzhaN62l5fewwch6HuEb7C8QQ3j5/hrbv3CCOXzPFwrKTQmihO8FzoSBDKweDSD5ZJ5H19z+Wx3V7vRvzAJQ59wkCCcJGNYrSX4W9z8DyGt/tiUA8dXuJRbnOykY9pNU+WS27eeIq6rMFG7IolXdWT7h3SNQWddnAcg0Az3z9EihDUgDEG2Y/Juy2ecghvP4XTC+q6Jo4T5geS81XBaC+E3lKZlqlycN2QKGjIdznT8QjjKaJsSlEYZvsZpuk4eeFb0K1l/+TkWlcvKtq8x2sa0mxKpX2K7Q7fLKkql0ZvcdqGzmhM1+MkCY7rk2Uem21B/MwLdEIRug4EPn1RgJtw86bL6ePXcZXPpljh+C5SNwy+YOQmVPTYZkcWzynqDtdVVLsV4/GUzjcESJpdi/IGjCsRjiIOYqSjUGmEP54i2p6f+Tv/BX/qL/4Y/+Dv/k10t8PXYwySo1s3qcqBk2hKK33cSDFc7Xj/t32Ehoq+6Uh6+Gvf/WN8/jf/Pm998v8mvLXPxhSMZYwQkqJqCJKAXV0zmJ6+6KibLVka0fUDgxV0iw2jYIzKNyyGiiROcYOQvdGMZ27eoF0VdL1BJe9EYOmHkq4zzCcxiRdyWe3wfI9BDqRBwtDULK8uCcd7JAdTyqsW2fRMJhMimeHemCONpBuN6buHJNoyVAU7nRH7PsoafD+iLAuiYaBVPomVVMOGlR+Q6Yi616ACDucz0APL5RpPjRg5go0QvPD0U3zpy28y9DXbs3tcKY9eSjJ53UHGgU/bDzgmYmdWeE3Ew8fnBFlCp8HxNLXtqPKGQIEnFE1twdYI1yJcF/oOL57Qtx1JKqFNUNohSALkUGPswMHBiO2DK9pJiBcGXMPr/ujvbVEEXM8ndhyc0EPj4Kcu+06EtII0HNHka0bTKeFhQtNW9NpBDgWRSNg1FSpShIHDclsgpUMaCS4va8Ikpms6lO/TDj2JcnjtYU6aBDTrBj9xkcancV0GFK4N8bMAxxhWdUHSekSOoa06BqFwI4sIXKIOqlhzoCfUNmd/ssdmvUalBjdyKbcNXmRIvAl50RA7PmEk6YVCSkO57XC9iLPHp5hAIlqDEBalFJv1Guv7rJ88YTzNONw7QOGSpoon55dEoYu9WNL4CqNaRG8ZhoH5fE5elYhaYGhxwoRmANdLGLRloMERIWkH2tEcCMsXP/0HPNm2/MGXv0TdKfL1isXVa7zn2af43BuXvHl1hW0a3NQlOTnhOz7yEe69/nmKcom5/QyfePh7/Nv/2d8gfc8LiPUVh+6Yy/Ml2TgG0aN7Q28LhCexysEPprSmw3VCHNuCTemahsXyMX0jGcc+VRgRjTJkrwlnM/RmBcNA01QEfoRVPZvVAtdLrxOJ1muS2QzbF1SD4PiFZ+nyhsSfsVJLpO/hm5qhKyjWW+68+yWoWuz4RfTQk8c+gSPxBsPdu3c5vvUMSTajMw2R6FgXDWmyh9yticM9dq99iuOXv5nto/uUOmQ83cdPOirh4FQNX/79P6QTFi902J/foCg1qTD883/xj3nxIz/AyPdwAhfHcRmZfQLbYQZBLyVduUJLQRxE2CwgC2OqusfJHI72b/Dk7AJXWVpGTIKIXd9RVppIGMJU0zcNeBG6q5C4qEmE02sMFine5uOANZqu6UnmM6rdFt91cIIbNNUa5XeMozFD33Hv7A2m0yn5ZoHveuSm5HA24urikky5ZI7CSslqecHR8RxrLV3TEkc+YjC4IiIbdzRVgRdYBC5D1yMEBKMQZQRVnrMdWmLpgxfRlEvausF1PQZPogwYNKIa8OYz4jhms8mJs5h1UYCVjMZTqvXy+kqRRKxXWx6++YSX3/U8V5cbjNS4wkFKiW0kgQppBHRNy8nxTVaXG/bvvMByuWTXWsq6oD/dkk0nSONQjUdIYzGtoqpLPM+hLlp63eOlE3aDYa6ArqPNc4SQiL6lsQFVFHCcjXGOj3EiweaLr1PlHaEfEKcu1moKMTBLJ5zMMhzb0ly2ECacHB7zxS/8HmG0x/ve8z6mD1L++k/+x/z5n/pxfvQvfA+9bjg4mtM2PZ6fECcOTTPgOyMGtSHMBFaOEaLG7kqy6Q0yR+BsE3orMU3DxcMHnFiJlA7b7QWu7+BIMFrQdB1939AHAbpc4wrB4clN7j88pWtymn5gLwlQcUwvO6y1pMkIXZas3ZA7Tz2F3dUUbQdW4w0Ds9GI3bYkbyqOb57Q1CWuY5GBxzid0/dXCGt46qnb2CAmnX0vKgk4PDhivVtSVYauHvCU5Oz8jGBvimcD4iykaSHNJnSi59t++Ifodw7bJ+dIxyNJEvwwotWGqm4JIknoZbiuizCC0OsoyxpjDKIaWNYdQmjaBkaJ4OLyzeuxKkvp2pDATxmo8AHPuOzqDuV4yLbBi3x4u3cCBolKFZvlBpBEscfVekUchtTbgSxpaazBFYZyV3Lj8BaVrjFmIG9bvNk+Mgyhq7F1TZYllBdX1LrF9ycsugt2yy2T0RgbuCSRh+cGTOdTHty9T5JMcY2mKBr2p/vs6pyyrim3a1pjGO9PqPMC23O9tfcdTJhcz5h9QxB4tA1MZvtcLJZUbYWxipGXoUKX4NDH1XD/8WMOD+/Qlx1BFkJo6fOGvu+oW0Oa+VwtNqRHMfnFliB1GOoW2RfMpglaWJQS+K3CKEscRfTDAL7DYDRO4EB5iUvKauholWaejtk1htjPoC65uXcEVuK3HpeLS2oUtWig6fjhH/wRusrwfDTnkb5Lug8y8Pjkr/wzvvtPfxzbVexWS0TsUzmSZ597mV/+7/8q9/2AZlFxtjnlcH9C33mEQQBBgOpzel1hXYOwKUN/zdGvbEw81OxkhtWSoVwzEHPr9tPU1RZpNhyfPEOvNfV2jRtY6qrDEuIKgfActHS4WC4I0il+InEvl9RhjNPbazuzhvXlY/re4itJkW9YbTZIBK6QdGGC3lUY3ZNlKb7v07UtBk2SjtB5xSjOUJ6iMgO6XBM4PkIPtK7ED6YYWqQD+XJHFGbERiB9QxYq4qlP0/WECLaVwk9cxP6Ivh04Xz5i7+AOz9884vRsiQgErqPQusUWPXIvJRy29MmEqeOx2jwh9iOK1YYKxfzmTbYXS7oCHNcidhsC36euS1ylEKJmKDR2lFBsLpDqbX4iFNagihYviem0oVisr19JrWl0x8jP0E3H9OApwsBjuckJfZ+i7GnkgJWaWhucKKBSA8MwXG+LwxnS6wmDCYGfgRgQQqCkoul7Th9foByP1WrF0f6cQVdcXjxE24Gm7/CDCb4daLZbvMDH8QOCIaJZXGBMQzY7JArmbJcrel1TPl4QOAGBIymtpjINbj0gjcTPYlIvpe1qjGewIqVebKl1S+D7pEGPsYoGQbjpMQYaIRglgs1jyd5hSrHaIMOIoavRuqVGE8YJVdsgXRfHDbFugitdZF/Qq4CqaHny+IyXXniavC3xA5f/7n/5P6idBbvmkMntFGdbUirF9/7EDzNWFW2o6Yqal559mVvTp/jM518lr6/40qNXsYHLfHzI//DX/jLPftMH+dlHX+Ol2+/nP/2pmBeODhHSZ1MvePj4ApQkRIEC1/eohyXCC/CIEL6gzbdYpyFII4Q3g0EifRdlBH5wg0KDHMB4EwLfkGYC3QpafX0tMcahrrcMQ0M8ntJOXXTe4Qc+vuvTMaACD+t0lPmWQGuUEKSRYn1+hu8colEErke53lL5Hl4oWV9t2S23uEIyYBnv7dHkJaP9KeV6e73l72t6zyUOYzzXQQUeLpIg9GjyGlDk245wHKHahtgLSLIJOxRlWaKYsDy7x28/ucet46dQg8tQ5dR2IEgTRNdcG79Ch9P7FyTJCGNaklGGHTS6NcTRiFgNNCiGVmP664uJF0nO7p2hGHCEwXdS/l9wAm+PE6EF1GRGV7QobSn6hvH+jLa/blMfPX7M0LQURcnlao1QDrYZ8Dz3WnJclTRVC1YhrWKSTVF+iAgcHD/jzTff4MmTJzStpWw7eqNQRpKvS5bbHUmSslhdcf/0PrumI0xG7O0dfp0rEOOECU8en6KMoakKkv0jomxC0zScnz3ktVe/gHEVfhAhXA+kJfYdQgmm79huz69fcMfFQZN5grzYoFTLOImJ4xgRTbDGoPuWsrmGXKZeQJIecHxnDydIidM9dptrLPbVcsWm7FFK4Tsufd/T6I5dnhMOJcZIDGCU5s7tE5Ae08keiYQkSPnF//WXiJXDl77ygLy3uFWPzs+xVmBdlzuzEYPsqETPjRtHOI5mfXpOt62wg+VDf+77+fhP/ChPTY/5nu/4DoQNKHcNv/Xbn8IAs8k+s2zC/OYhz7/wEkr7JGmK7SocldM3W15789N87Wu/xfL1r/LkwQPWFw/ZXT3BpDXN6iGb9bWfQQwVbaspi57L9QVtb9EI2qEGofCjkGGzxQUO9yOs0yMdha9c+sGghCVJRnR1S6U7Ouvhj47xpCWIUrrBMjmYM00n9NstoStx6UF5SM9DWY3tDFdXC4a+pe9zNtUO1WvWmxVNUxH5IbqpKdY5aZqizUAQuqwXS85OH1J2DY8uz+j7jmQUc3R4g3d9w3u4c+MYT2hM0+CEY7pBMhQ1fmtAaXYPniAVeL6gy0uavmO1XKIdS0vP0AuyaIynBoI0uKYxVx1JlpIdzVDCA9eCeJuPA47jUpU1k/0Zy6slN28/w8XVJaMoASy9EtiuJY5HrNdr3MHSJwlmMDh4ZP6AkTVmaLFtxU53pHFM2bZ4XsR07wDv6+KaOEzxrQRfEgQBqZui+wZtBc++8A70ZkdbtgzCkkhFZQWjOGF+8yarvEX5ks72vPXqG2RHM2bjA/aP73B+esX+aExvW6z1EFbQ5GuEl+EhaYsGpRRumNCbgSiVbM4WTEo69l4AACAASURBVI/HNGXBdJSw1fDUOKZVEt9RX7eRNjTLNbrvQLi4vkRbxXNP36HSltWuwFUOymqq5Yp0PmORl/gemMpHOCFt1yBUwbbsODjK2DYDP/LTP8Gjswf89m/8DrumYt1bTKmJjiaM9g747Cc/zUc/9gHCyXPMggnPP/tOLBLrOSSjiE9/5l/zyd/5Pdwq5cuvf4EPvf8HKBbnfPAj3w5NyXKxwYtG9KXkC3dfYW8+It8N9NIhdmLyouHll74fi6artmTWQYme/fEN1rtzqlaROgXbxqVebNhuztibHVGUSx4//CrPP/U8eTPQW9ibphgUSmi6ix16P6EptoxjH8cLaGuLpaEsalxPXePPHUV5UTC6PeJyuWBoCyLHAcdDlBrHD+ikxlqwyuHwZJ+r9QrdGYR0cKMxbTMw6I71qmGiB8bxmHWxZpPvcD2fbugZjce4e3uslxfIAaI0xGLwIof1Ysd0PEUJ6LTEdDkeHjIJMJ6k3VV0aYgxHW1VEoxGzCYJxTjFDg7YhkdXV2zf+Bof/fBHOL+8QLoOXd+irCFN9nGaDXld4ag/njH4tigCxhhuzPYwVlI4govTU5LxmN4YXCUJAxdcn26whKOMvm2Z+h4qCmmaht4KpKPImwFrJb6b0DY5rnTRfY2qS3wvwvVCOmPphcEaheNKyqZhU9ccj2fkRYEQkCQxvrFY1SB6h9Z0dKZBeRFtU9PbnFs3b7PqKnbrHQbLycEhgyspLxZYeoRQhFFKmE7IL0t8P2C3KzD9gBIOdd8TJRmriws8x+ey2dCJAaF83DRitdwy6ILxxEMmKarTGFnS9wOOVAjhY22N37bXhKXYJx1lOGiWVYnUisAL6LWl6zRX+Zajg2OWe3NWZcfh0RG/8HM/T12sEL3iox/8VkxvWa93lFXL89/7IS4LePLoFS6qhv/gr/wnfOL//CfIvuczn/p1TheXuEHIxN3ya//sF/mJH/gOhOPSNS5tZZkf32Rd7Ciqhr2jfRzbcng8Y73b4kqXWwcRVli01rSmRdUDNlBoSq7Wj0mciPHhO1jff4XUKmYvvgtEwEjd5GBxweHt21x86fNMp2NabfGVoBOCbhIQbbbkpuOLjy5Yni1ZVltuzG7yHd/1Ecoqp1YCd4DwcIzSlhfuHFGs12z7gYkfwDTBRdG0xTWNqizpOwdhLGGYIH1JX7U4qQ+DYiwMykBvDVGcIqyi7zuEaXFFyGa5ohsMSinavmfAUrUN6XRMGEVUQ4++XDKZzPBjS1FdMR8dcPfuFartGU0yqj7Hl4YHjxYoXPwgwfN9bpwccHiwz/npOZ1tGSqJ55SE8ZS2Kqm6FtdAXVd/7P/3tigCCNjWOet6wA9CykXOaKbwAh+Bxe0EGoHrQexnNEGDLxWbtmOUjsjlDmsFqRfwZLtBuiHWdOAptO+QzPfptcNge3Rr2DU7PD+iLCui1pJZGISmLxs8BIOrWRc7wjiiWj5gsncTJwixVUMsCmo34XKxJhpneFoSjSa4KsJuVjh2wHOz66zDegN1jedn4EOkYnR1Les9HI9p2oJGGnbbkv2jE6QtGKxkXVwgpUscZeRDjxKCypWIWrNerwjTQzrj4Aifra+YBBltXbCrasJI0nUwjGKullv25xnbZsfe/h6L1QXxLONrb7yGGmK+56d/nP/q5/46Jt7xV3/234WzniBwMbYnyUNuhSHl9iGyr3l87z5VL2lFhpNu+ZPv/Bht2dE+eo2f+bt/g8FNqIYL3O4KRwxsFwYjekIvoG0H6nqgVZLYn2KbBkPBIHyGYWAa71P6Bl9qLh5fMZncIlQj1p1gNDvAdx18HF574x4qG3N4NGe5admbzlidvsV0PKLRIZ0fki834AyM5jd45iRh/+RpZr5L6yWc7bZMgjGiWVJ0A57VLHuBOF+zKDfstjUPLh/AqqMWHd/2nf8mr796lw984AMU1Za6XTCfPk/b1HgIuqrEKBcbp5i2Jd+t8dSAFhGO4yKsgxAGnB5fucTRGMcV1FqTJQH337qHJ1z29w8Z3dynWm6RKiD2PR5dnBGOUu5/6QHPHTyDjRNELQmTgKFu0Ra01oxcn9a0GGeg6X2CVGFsSCs6YifED1xQDq7n/7G/39uiCAgh2Gx2GONhrGJyMMGRkrqqGYylqTui2MN1YgbdUW5zailIPI9B17iDYVvWuIHL8fExq9WOQMXXfHkclOugfIUgAtsTxd51Tp6QjA5C6rpGC8FoNgWjUZ6Dt9NQtoyPbtFWNdYGbBdbZvMDhr5hlE3oe8Mmv+DO3gsstgW9Hailh7tbcLVxcadjZN+TJCF932Lbmlde/QLvfPc3Y1wPzxtRrh4QZiGdLYndgL7vaUtB4Lso5VMXBTCQRSGdCskmR0RRRLlbsCkaDm/d4PLsEaEXkx4f0G7WjAIfL3CJ5ilNayDOuLpYMEgH33H4wHd9mC9/6pOcXj5BV4bRcITcCYwp2G1PCTzNZbHgSuf8y1/+JVQY86u/9ZvsdhvkkPFX/v3/iIcP7vH93/1hThcbhssrlBegWtCJC8qlqnZYBzqzQ7kTgr0Q260wTkLTV9T5lkm0T6csotwQRDNsVXJ0Y0xfK0wIzXJ5rYVwAwY7cPu9z2KrHj+Q5F3F+OSE2cHsOtgUzbbYcTR/HqkrlosV4Xyf7dkDxPSYsMp5simJxppt1zEJRrR1xTwLeHBZg4x5x/M3uHXnNhfrNbeOnqGq17zzne+lrBrWZYunUhZv3kVaFxEoXr3/GvujCbvtCtNntHKJKV5jeeHwzNMvcLFYksyu49RuPfMif/C5P+DmMyf4I8vm3DDUFc3gos0GuXZQAmR/wSwMEbMZ1Dtufs+3crFeMuQtdduReB69UIR2oC9drtQDhLoBXcNokrHrG4TWCOHjW49cthhfI9/uuQND3+P4HkmQYfsBLQeM0XieR+C4OE6DGXqWyzXz+RzH80jSmH6X07cDehjY259ysdjQDzUHB/us11tS51pmubw4R7gBbuCjXInv+1RtSxzHXFw8wUtiMBakIhmnlPmO8XxK6sY8zkuCIKTYbTk+mGJDhVkLVOxCb7iz9wyX548JgxThOCSTkKpucdAMuqXfVuSrLclkRN9qvumbPsTFdsV6vcFVipHnk28L9vbnlGXJ2cOH7O3tEwU+T07PEL5P6Hg8/n+Ye7OY27bsvus3V9+vtduvP82959xzTvm6yq5yynETN2XHREoUS2ARsIVEsBQhIUQEKKGxgAcCigRJaAQoUiKZRNgiNC9gAhjZIo6dhLJdzb3Xtznt1+2+WXv17eThO6KRqIoj/FDzaa25ptZe2tKYc8wxx/j/Xs0IphNM06QxVaZHJ2ziT0h2B3b7nOB4yObFG1BVkjxj2BZg6exuYoyJx9DwqB0Fsc/5+7/+q/i+w//wN3+ZOmuQms5ut6OkRkcltFymFyNuL2P27wlGXo/nmKTZAdvyefzwASfHU66ubnDGR+Sagu35lHlKWjZ0VU5TxThKiOwtfEOlznLaBlb7GcNBiB+eMFuuCBwTREtelfRJjmo6ZPslbatj+0O0TtC1LU2RI/sWrVdohYYhJcXimsByUPqGOCuZRAN2ZUZfpITTMauba945v49QDXLZcGQ7tG1NGETkm4RD05Ctc4JhiF0rmIqG7auklU6aztF1k93qCkXTMDUX07aRA5fq+hZH6jwaPMUa+bz3rsNyn1MrLUH3h1jvF5wcjXin01kvtsi2YuBP2cdb1OfXNO03EV3I99/7HF+dacz1rzM6a7CLI/ZdQH/yiKEUxPg0uw2Lm0uCaIAhO7yhy+tPXjKwbFRSRDnBG3dUuk1eVoS6QaerxGnMZ1cLpCcI/YBvpx/2+54E3uLJvwrcSCn/hBDiIXccwhF32PJ/RkpZCyFM4L8EvsQdiPRPSSlff/t3qzSNwNIrWlpM3UQqJrZlEG/WjKdTbm6vSeOM8eSIODlg2iYVFrvVjsFkymq35dHjR7x8/oJkvULTNZJ9jLA9estE9g2e7d/hsqWCYpj0msIoGnKoGlxTQzUdqrjibHrOejOnNm3ODZU3r6/xg4iuKpGaRLENqizDj0LmqwPecMz8domiG0wHJrav0UuTfdai6h1FmWC3EqkL1kUKTU8YhvR9Q1zVhMfHdHmHqggeXpySxlu2m4ReWOiORVpVDB6eI7MSIXvE6kASuEyHJyyuP+bBO8/QtTusuoaC4+pIaTL77AWWG7G5fMXe8LjZ3rKYb3j65Av85m/+LyhKg9Z2/Af/7l+iUUrs/u5+XxSoikNcxXh5yb4VXF3vqBrJD//AF4h3c3aXz1HG9xl2e5JakCYJmqJSxTuGgxGNH1KlOZ3I2SUpimzISslwFDBwHVbzJZ5hUJUdlW0y1GrywYiqL7DGEavLDav8E5yJj6IKItWlKCq8TqFVjDuDwuK2a0EpMWrJfLGjtg1sRWGxT5mcnPDVD77J2dkZfjBEpSdPMgIaXNfBDVT0vqeTDfNkjtAimvRAnx/wHjwk70ymwwGb2YI+NKn2B8xaJVNsdNsilTviLKWXGmXlUK2XpKrK0YMjDruYtk4IwxOW64YXv/urPHn6OYKRz+ryywTHA65mMaMHKnbo3pW0NzG60nP16gW3Zcvw9An+Ax8nhVfzFwyEQpXvGDoWv/Yrf4vzdx/x3tE57TqiVWf0Zw+5eX6JN76HBngnEVZXkVZ3BW7fqv2jHBH+S8Dv/T/u/yLwl6WUj4Ad8PNv+38e2L3t/8tvx337JluodihdT5WX9FXD6uULykOMoenczG5xTJtoFFE3OYHjYJk6nVIRhj6iLlEQLOY3gEKr2diWS9U2pMmOo8kQ33ARUqEqaqq+paoqHE3jkJa0CqzimN1+T0fDcjNHMXR22yXz+YJOURBKT2+7ZEmKKkA3HTTNuUscSStOT4/RNQXbdWk6g8jxMeuEJC84PzrF0BVGgzGqVDmeTCg2KwwUHk2GGFLBshyasqLuelrdw/ZGNEqDr+oEno8oGhzfISsL3FFA3TVongXelKyquVmvEXkDQFW3lKKnD3xAwzRs/DDg6aPv4Qtfesqbr/5d/uf/9Vf49HLPl770R9jVa/pWoVQ9ct1hf7jliydj/uYv/XVaQ+Vy/hLdgFGj8fP/9M8ShfcYvfc+um6wOvR47gjR3rBDQbMd9llJT4ftafjOgDAcYDoRJxcBdVeT1A3e5BzDMqmakjrOKYRKnm6phEHfKHh6w73zC0zdYXkzJ072LBe3rNuYzewaQ5ggavoqxjM8OlpeXL/g6pOPoBHobYmhtjw4P0fkLUUaU1ctfhSyL1rerK95/eqWm+UV+0OBZwa0ho4wbGz3iK4QBKIi2a6xbJ3AVu80/DTBg0hBkXfodVv2xHmNUBrChyNGFx5FktGrgtYO2LdbrMhFGZwjmoTiUGFYHXI7o1FqovEItWwxs4SRpXD18mOur2YEx8doakJ69Qou3uOdR4+59/4XUIyQOjvwx376T/OVH/lJzr/8RTrN5PJKENVjRtF9TAMOuwWkCfl2xe7FjL5vvqX5/b48ASHEOfDHgb/AHYRUAF8BfvbtkF8E/h3gPwd++u01wH8D/KdCCPHtyMQ9AssLWW23mJbGLt6TyAav2JPmGZZhIlSFvumo85Q8LajaCl143C4+4fT8AXmR0TQNom9QhMpu3dLWHd4gpE0OLJYLpqfnOLbH6uoljQTaI4Sh4GkKpWVTljWOLjjsUxSh0bUVYTCk6gr2+xhFsxiFPnXVkx529JqGFwRUTc1stsCwTF6/ecVoeMz+EHNyckK/WILo0A2bQ5Gh6TazOCEcn9IKwSquwBQUakbXdPRCEAQBSZbiBT7L2YLp9Ji2E3TVW83ErKCmJysLmrRkX9V3LMbDDpFp5GnC8FgQBRG7/QGhqeyWC3y1Rc1UnGfv8S8O/zmubpeM7J7D/BZ1rKIECofZhs89ep+HR1N+5Jt/n63l8vUPXrBYXlLbFutijjwU5H2PZujUdU15uESN3iOoDiy2OyaTCWYtyHqdpC8ZW4BuUzeSHokUJlmZ0/cqXjgkm22RVcPEH4JQwVBQ7z1k9+YltaYxiqacTE8w9xt60yIa+iz3M0aOB3WNoVgkrsmzp9+N6qhUVUe+TlivMopsj+7r5Psax+/QOoGQHUeDM5pBy/z6hq7P8QONNKs40TUqpcbodJJ9jeM4JFlOtU3JL9+ghxHzqsHzbT558YL37j2kj1P0QUeS9lS5hjnU76oHNweGWoRiV+gWKEQEtkPvOPRUqGnL7uoV945P+e2/81s8/NKX+MKzJ9ijAX3R8vHNjmA8Rlx9jdHFU1b7BN+N0BCYhkEtXG5+43e4/+QBf/jzP8rX3mTsGw27lwSTh6iyoulrTt9/xF1d6f93+/16An8F+HP83wnII2AvpWzf3l8DZ2+vz4ArgLfP47fj/19NCPFnhBBfFUJ8NTkc6LMtm82aLM7ZZzHD8Yj5Rx/RXF2x3G9ZP3/By8sX7FZrtssVZV3xzW/+XcbjKfkhochLmqJA6STxoaSrVRx7wD4p2eYN4fSErEo57BbomkVXt1RVSVbGSFVgmja6opKWLUoDQhPoho1iKRiqhu8N7hKTyoa8bugQlHVK6NkUhy2qrtyNsTzoaxrRMn9xRdF0lK2K7Fuq+m6/HDkei3RLVqTYjkmVlYgCBCqqZtGUDXGcoKGguBb7JmOT7knzml4o5H1LvNnRxRnHRxGOY2MaGufvnvM9n/8uouERvmNRkiD6HXV+lwEorZB+amPueozBKd/9/hfxdfCtgMN+zeXNlqLM+HC14Cv/xE/y+mqJkWz44MMPWWyX7LYa69tryqrF0hQoa0zPRCoD6mTO8vYVg+GE7XrJar8mqRqGqoIZBJRViqsIHEPn4+fPcWV/R2cqevzRCcvVhlr1uN4foOwQukY0Pcfzp4ymF/QIWkXDoEczJV50glRMrCCiqlp8BGXXIEuJLTs8TSUYBWStQts5DM+OcXSXQyLR+57DbMd2scE5miBQMc0JZ/6Qg+6StRAMpjhaTjK/BDI26yXq4Azb9/A1SVmlfP93fwGzuzOvSPOxMRhNHLzqTgbMNyxEnZMXFXXaUqUlm82WxfbA+mpOXyVsX7/kZrvg/Hv+MMJREY5OYwtM1+NBaGDvU0b3vot4tcI0O7KmutOOMC2iwOHke79E0qp8/eUCo73h/ljBVkNUzSTNaoQzRVgqqvjW3IF/qCcghPgTwFJK+dtCiB/7fUwYv68mpfyrwF8FePr4mVweKkYnR3z8jQ94/4vfS6T6HH3PD7HTOsaKTr3e8AP3z1nPN4yPwPAcQkOHXqCYBkbTcXX9gqPTd6nKHb3oqJWAMslwTAcUHVOx2VQ5uqah2Hdy0rubDXVTUwqTvG3QdME0GrLYLtE0gzY26esEWgXfi9jernAcMEyD5FAyVxZYlkPdtiSHLfF2S++4xNmesTdkOozI85x5XBO6gkazsT2bqT6mbxqSIqOsK3SzphUddVuiKQLXtZFNi63qHJKMvm6wog671cnygr7psYdTGjLKLsc3XfTOYbXYoIqOrqmINzme1Nl3GSdDB1kVlNIkGhmsN0uawEadPmYWr3CCEFfpKOd7Hp494fIbL/jiXue2ilFkTNtqfP9P/SBReESnqqzrgsA2WV2vCYY+rSLA9ThsN3fwVuET+gLRG6yXc/JNRiN7yjwnMG1ukpg0LTgZjZldfsDo9Jzt5g2KYpAXFeluRS0E4yDi+s0HHD14QlVVUPVoXUfWtOzqmkEQ0qoGoeVT1YLdbsVwMsaMdLbbnHfefUqaJpRFT10WBNMhfVPS6BIzOyBrAVlC7pgYioCmRqgK8+0SzRgiXRdLs+nL5zx4eM5tfI1hedT7mL2Z8rnvfcanH3xA2pSgqyTxAaXqqPuG8/ER690tT0ZHPL95hWmP6OstSnenpD3bHXAe3mN9fcnRPYP1rsOooT8UiBbUpmE0cUiQoAgEFvfdDXE7oGoSXn18y2R8QodG3dYYzoi4KujKDboU7LZrRven9GmKVP7/eQI/BPxJIcRr7gKBXwH+IyAS4v+qTzwHbt5e3wAXAG+fh9wFCL/1R6iCwB9AU/J93/UY33MpuwI5cimubjHrFmyNq6srqraj6nrevJxRCJ1cUbAcl1E04fv+0A9zOg4YeSPefecLDMYXPHr0HqfnD8iKjn0W46g2RZohq4RuvyLZ7omzFCE71PKAUZesF3OkopJt9sT7G+qkIJ4vWM7mBCOT9XaDWleIw4bXH96QdjmBFLz65Jv0ecIh2WOqCtrIZb1cEgYuJ1OTOG8xu5zb+TVNlt9F0YsS3w0oDjnb7RYA0VRocPddikYYDjg7vWC7T0iqA/tDguVaJPmOeB3TZSX7XcKb18+ppKTqGrpWELgOleXjmAb7rGS326FR4EUjFEPHMVxm82uUViFZ7Tj2hxzajJ/+yhd4PZ8x/ZkfI3m+JU972rbnx58d8eL6muefvsBp4NNvfB1v4OP7E+KkpKhapHrHaAymIX2jsNqtaCqFyYNj9K4ldE10tcVWHKJRSFFkXNx7gD8NUQ0ftZe8mF+j6SbHwzFtV2KEU6SoOTo7ZR5n7JI7gxNNhzkICEwHRVh4ms7ANKiL+i52o0NRHkjKDaqQHA5bPvvoaxTrDVkaI4o9tulQ0qHrOk0nMHuBrgcIqZBVLUMrITAMhBfwex99RLXbkZYtmaqRpxmfPX9F3LTESsf1co6aVvSmwVHkkWUZbSOYJwWOOyEYDFG9kEbcxa28wEckGdPzU27nM0a1ZJ2taa/maKJGqCZvVq9JX32MpoR0vcPNTNKJjP3+QFaVWLpBUZXIXmW7LUgrweJ2RaGo3D9+Qr58RdPriG9j6v9I8JG3nsC/+vZ04G8B/62U8peFEP8F8A0p5X8mhPgXgO+WUv7zQoh/CvjHpZT/5Ld777Onz+Rf/Df/bTTNwA0DdmVBmaWMRlMGYUiS7uiExm625OzePQ7FHl0f0NUxrusjlIbp5Jy8rKjrGlHVrJIDVQ1G3zI6G9DGNZuqYBAOaWTJ0DLp245KNbGkJK5yiqSkKRN0zUQzTbzRiHx9idR8VpsNgXOndVgC290SuzfYlHuEbnB2NMW1h3zt679DU2REA49wfHK3unQtZVbStSWj4YS878jrBtu2UZqCQ1ZiRRGqTKlLA0VT0foO21IQhk962FP3cCgOnB6f0WUl6yRFVQWiBdlKwsChySrSfoPRewyPAz588YqzaMqb3Yr7J8fMZgsm42OatmS+2dG2PVq8wAk94qRn7EZs0pRKdhy6gsnwiF//6q/zye98jbYP+bmf+Qq6lIxPj+kLCCcjRoPhXYAw3qHJBl2zcX0fJ/BR8oLFfoNje2iGga3ptLJnuVxydH5KUxYYhoXbCrZlhqZpLK5e8uy9ZyiaQdyW0LW4qkFmGsiqxKwPXL2cc/7kMVla0SMZDYb0Sk+SJCRJwjsXx6y3BwxLp+o1TEshXsxxPIe+1NnXFUpxS3T2Ds1uRxtEUOS4lotsCtBd0n2MrfUER0Nm6wN9WWIKFydQqFsoy5LO1Bi5LnFc4gQOXddBneOOhqyWM6oejLLGQLJrKmSjcD7yWB1S2l5iuQbpIcO1TNwgRIiOYTgkORyo84RCKKi9gmqo6AQYA590s6JuOtzAIAh8FsuUoutxdPkWcNLRNQW7vEeTPUlRcn465c/82T/Lizdv/sCpxH+euyDhc+72/H/tbf9fA0Zv+/9l4F/7h71I9pLJ/QcEgzGtojAaj7n34F3yeIUUcHU5I9numZ6c4HgWfZyxvr3G1XXiOGYzX/LisxcU5YHN8obtfkMvVZL9jFHg3HEFPYPpcIATOXjCQHV9DMenqVqWyxV9kXHv/ILTs4doloNhmVw9f47v+niOw7OH96izDbeLLZbpcjQ9Q4t8Ij/iMFsxm2/I2jttvYuzc4aDMYcs5Xb2mtmbF8TzN2zaguX+LSKrqVluN7Sqjuxryv2e+dWSqjjgmgVFfaBTdbqmwvEtTKEQOh6WEKzXl3TFDlEmFFRkfYJ0eq7zOVgunavy9Q8/wDA0FLdA3+xZ3L5G0xqUNuXN/A2+LIi0GuP4HqtdTNq1HKoKx9KI/IDAGnIUTdluZlRqx4//0R9kNDlicvQQ2RtcvPsO0XjE7fyG3WZJoFuYenQniNELPv69j1iWOfvVjsiNkHXDR1/7e3Sy5+jkhLbVMbQ7jFtiqCiWoDUMzPExKxNqpcHUVIbRgF0eI1Yb1OWcQ2dx8v4TetEzPR7hKKDYCqoqcRyHs+MjrhYzhqcTJBpVvadLayZH98m3W+qu4uxswv1H38XVxy+xomPUDB5dPKFUG/72r/wmpmmiOQZGcMSrVzN8w8V2Hc7u+dS9QUfBMo7x/ZCmUDG8BqNqEKgkdU98u0WpOgZCw3GHDAdHuFbI0cUJO1XBPTpjOh7QKRqPHz5AaRpmsx1pnPPyzSWr9ZaiuauENV2HRnbs0ltmn/webdsSDX3cwGO52dD1FSdRhOxVyrRln6ao1ojItzEHAZqpsdoVqPq3zhj8jsCQPXnyVP6NX/olunVK7eoocUmptvTozK/ecHZySl8XaI53p8jieDxP9oh0/VY5JycwRqhNTN2pRJMB6/hOHEKrG/ZIxprPLt5hWxoC6NZL7OFdaac39GiKkoE7YZesGR+fQCcoWkG+umJomzSGjuONWCZz+hpMw2G7TLAtlbhMMPqGyNT4Pz74hAfP3scVGm1dkbQVg2CAUHo80yHrMpReoKg6nmkzX624vL3h9N4A3/WQmBjJBlUPSeINuaqjlQeusoqLoYNoFeZVimNHyKwBS0XmBUXTE0URXd1yEAeCWmVX50wNm9bx6Pc35NKjKHZQNCRCEg6iu+KmLGWZ1CidJE3X/Ppvf50/9c/+HH/9P/lLbAudqA34uT/9Mxh6wnR8n/n1GyJ3gOLaXDx4j6pI4wIIugAAIABJREFU0KnpTYM4jjE1EztwqLclmmtQ1Smt6fH+u0/59Ju/jec51J1GNBmRxHtE19EIi/OBybrM2W0PRKpHSYbnBlidwrosuTgec3n1Ce54jN6HIDOErqG0PWXf36kx3y4x/YjA9ZFGi2K49PGM9fKG8cX7yDZhllQYtUagrXCic/Ztjx9YKEXLvimotwWW5aCNIj76nd/iwdF9vItTstsNimlTFDsUzWZoK7SuxWZbUy1fMXn4Ll1a0ad73MGQ1fJA7UgiQ2eb528XnQyzqKiFiaBEs0wCU5DbATJPkI2OY9jsVrco7pCiSemROKpBbze0uUKXVkynHtHpKZezJcuXr7n/8B5t21PmgulJhIqk1kyq7R6ptPz5X/gFXlz+wXsCf3BNSqplTDAwyA4xRtBj6TaBBY/efchytqI3XAQajmWRZQWnlsHjdz/H8XDC2fgMy9bxT+7hRBG79Q7XDnhw/IC0bhlHZ2i2gW3bNIbDrpQEj56RVcod+MGbEgwvWK9XCFtDbAoS2XNYzbACg/mhZJWULOYrkkVBX/XUeU7gqriGxtnkiOn5O/TOMT/+Yz/FUDacRC76qc9wPOQbv/Pb+OEQKXu6TqAIDV2zaMqatuj4/HuPCZQIW7iEmoU2fkjegakrOLpN4414ND5naE0wtBoVA6tvUERHs08xNJM2Lyl2V7TVEj1O2cQ5baOyylKe3b/Hy1dzku0CiQqTgIeP7pPVGV2RE0yn3B/72KbFOw9P+WM/+oN88qv/O9tdTLta8LM//ycJfZtgdIKpqwTDCYPjAYiGbHdJcViT9RK9lRz5Hsk+QxQ9/iCi73uapGXgGLRlzODoDNMOOMxm2I6DZRiEvotBTS1U8nXCKIwwxz7nR2cMg5B9V+L5JklR8OQLX8aSDoZaoxo6aZLQ9Cq2uPuv/NEYReZUsiVPG7LdBmH6xLnCbZ6QFgq2Yd9Vg1rnFOad/FpZKuzThN0ywwqHNIrCYbFkdHSGNR3TFxWao9FXBX5g4AQ2VW3RFRVufcvDd99F9B26o/D+j/04s/hAUW24sFwOeYHrGdAVXJw9QI4sxlMfx7LRdQPNHSOTjCq5O2lY7hZMT04p24xxdIKtaZiWznFwwsVkxOmDcwbnU958ssHSPZ597n1M2XJuSU4jE8cdkeNSZDFGoFLHOajf+nTgO2ISkBKqHmZpR1NJkl1OWffIXifwB4yOB0ymEaarsTnsKUULikmZFZimQTAc8fyjj8g3WyzLYnJ+juWYLK5f43oBjtoDgsdPn/JgMiF0TTRZMn38EN91aXYxpycT+r7HKHX2huD1r/1tbNmhavYdDRmB5dtMjse4gxDdsXBGA7TAo+pa2q5Cyoyi2VNbLm+KnKfuKa+++TF/7t/41/n8d71PKySB7WLpkmRzQ0aFNXFpjRZ37OP7PkHg0R7eoNsa3oMneMOIoeGwlCXzbE2cCsaDKbI1iA8FZuixqTNqeix3SFspGJGPpuuMBgN0b8zr6x2qPkKPJlCBWyhYQsNvFQxFpRMGSQ6GrrHedxiGhXca8qPf80f4x378CVcf/C6VlNw8f8Fnn31ClscYlkfTCvZZjGU5ZLuMXirkDQynFlmZs97e0LUVztgljzMuP3vN8s0lVVPx3g99keXlDX3VYZk+VVWRHEqE5dC1kjJNEKZB3XcYQsE1DXRFZbfYEY0GGKaNKlWausfxLTTNICkK/NGIwfgMoRqYYUDXN6S9ZHLvPuetRaUL9vv4rv6/bxCVpK8bmrokKztOT8/Y7df0ssYOPFRpUBQ1pSJohEANXarKZZ0ntHZOEu9xJg9J+oau6FAUjduPv4YTugh7wLpsuDi/j6ZEHCka2+UMp7L5+Gsf01ghWV6TNzAYjLDNDssWHJ+M2MQHAtdjv1zQyIab2zm7zZ75Ys+hKoivairllouJRdPmzJKGGwa8vF5z/eJD2npLvFii9i6dH9C27be0v++I7cDnnn1O/vJ//d+R73eIRpKnGaN7xxR5S6NCtU44Pxkz38R4lkYpoS8KFMNEt0waIVGbGqVosQYBRVXS1g2abSCzns5WCTXI0ppGghV6CNlDnd+5sPucQNW53iw5Ob7PJl6hyhJ3+ACFhKro0LucolewXId8G3Nze8XZvYd4XoCoKxA9eVbhDQJ2yw2+Z9OrHdk+RXHHKKKhbXtOhyHzeIumgNQ61M4kjhOkquAaOtc3N4RhiGloZHHJ9OwYs+tp9IYyB5qcPnCRiznSHaBogk4VmE1N1sEsThj1GsLuOKw3WOGQ0eQEkZdc38xJiz2NVmDlkKkaD0+PSDc7rsqYIzUia3aIxmWVrFlvZnzx6fdzMCrkIkd11bsKOH/A0IqIixW2raIqBtuXn/Fbv7viB3/6BzjWBK2pchSO2cR7+k5jfDZEqQIO7YZwOMC3DbKqpS7KO4Ziq7LOUzTdvct42+8ZhBGqrhFFIapiML9d4AxDLF1hvbjFdnwsW6WRBlWyw7MtaqOluJHYg4iiTAHwTEHaNpiaSRqXOFpNqil0tcJkEJA2OSOhMc8LVHEHBVHciM3tC8LzM9SsZlPUDHyPokjQ/TFK29KVNb6Wsc4MFFPFUlSEbdJmNXboAzXpNkXVVSwDcGyyLMNuNFb5gkk0pK5KumSPenxB3+S4tnWnPZFWFLpDZ0i6IsGwLfpe0uwTpD0hEAWL/Z7eMtHKgnA4ZX+1prF1xpOQvGugqlA9n2KT8O/9lX+fTz/97DuYStx2HLZ7jsZDVtsYHIus7Yhsn+vrSy7OxyzzFtvRiA8Jum0ThQH7trorCKpbsG2MoxDRNBzKHNMyiXcbjk4vkG3Fm8tbguGArhP0VUNTJpi2h5AKpm5hairnD+7hS5XWdtGlh03DbDHHCQYI20cmBfkhQxE6UTDB1QzasgAkeVOhKD37ZI89DBlEY+I85dEgIm46qkOPsAUvr14xHExpupbk0HEeuYhARZgabdvy8N33OCQxlmuCUGnSPfpwgFf36IFFUap3K9fghPXlZ8hS4jgBN6KiFoLP+wGd7fP6xUfcf+cRvdA45AlNXhIeBbTrjnePHpNlGfo2pqo7jGDKvWBM2R5o9wPCSGdqdQSeyWCs8+WjM/77m9/g/uAevmpzu1wzPA5wrQEGPh0tR1/8Xn7mywHr1Rz36IzQmVKJJe1e4WQUobkR14cZrqrz7OEjrt58giwkaZoythzWbY6U0BYHdGGgKQp5fpdYVeYlos9xLYHW1HRtx9nxEdtNQttLDvsDfmTe0aBUB+1EQyVHlZK4TFDMAK3IMXQF3zPIqxbP0BG6SpPGuKZN2fdYSkq+begsg76NEU5InbfUcYbqByRZie542EBalozGIaudRDZrGsVH0wQibaj7lvmnV9w7PaGjwbIN4jRnbLnIGhRLx5Ujmsag1iVNa2IeauIsZtOu8BwfW1TEWYzVDzBVyOI9gR3QmgZ5lzCIfJSyRKfAGw057GOy8kCTtbQiY3hyhik7dnXMIPSpi/Jb2t93xCSAIijLks9evWQ6OUHvQUrJYnbF6YNTbpcbAs/F0CxMxybLc4oiQVENADpdo697+vUSzfEYDYbUScaDe4+RrSQ3JBcXFxzyDM0ARIfmeBRtTWBYbPIDjh+iSpWiSjADm3yXstmlNJ2KJSws1WA6tOiqjKJV0AydTjOwTYXFas3FvXM++fBrnJ6e05cN2/kcYWj0lsX1bIurqPRtwqcffsb3/fAU0dUUccKsq2jKgqnnYzketaw5PzklzfYYvkuW1m9z3h3Wsx3BIEJVPZqmQEyPUSwLTTVw45hOVVlVHa5eE4xHVLKjzVtOzsa8/L2XGMLDdkzqsmC9XLGKd5wpR2huiZLsKVsDS7bYQuf7vvwFPvhwzs12zU1a8c6j9+nMDld1+fKzkOfzFSeTIUm2wfMCrEaj1xtOwwGKrXJz8wJzYBAEDr0j2C5jmmaPrh/zjQ8+QVLTCJCdJJENvuVgqQabw57BcEyeF5RlSWtp7DdrHMuiqip6MkTbcTSekB42NJ3g4uyCJN1iWi6r1RV9qTA6PaVuagIvpE5aTDuk7Qq69k481dZMOk2nag50vaBHw3TH5N0OqZncCxy2+5pSa7FDH91zIatI25Zdm6IrOqvFEuGGtHVF05m4kwG6blDsljx45yFS1RkGKnVTIlWP7XaNYflIreVwOGAYBoIcw/MQasUgGKGZGmmcUvSS44v73MwXtOqd5H3cQVn3qF1OmXWMfJe+rNgkKdluwWA4JK1ykiJBeTWjqjKkZSNGFup3ekxACCA9ULUddVuDpZEuV/jDiJvrOZZh4nkevaLQ9z2hYeOGQ8o4QXY9TVWyTbZ0qk682zGfz1nvVxySPY0sqQ4lWZHjWTai6YhCF8vQ2a3WXM+WDLyI1W7P+mZBMJ6yvbrFMkxMQ+VoekbgOvyd/+l/JM9zOt9jNPLxwoDINOgEPH7vHZY3c86np+zXK549e0pe5qi6Sq+6BLqOq5v0qsMP/eiP0NcNfjRgMvE5vneKb/jIaEDbQV3XdxjpXpInKVcvXmJ1LW+ut8iu5c2bVxRFhqvYtA00dYdsSsaRh2tY+EMXtbMZnN/HH4e4Ax1X1fAmEVHoEOcVy92O3jA5Ojrl/vkUy/MZX7yDVnXcPz8DRWexzzFMiS8tQj/AMnWWL1OORkOEZnFuq7SdSrNLkFXBOs4oCkmHQpXEeAOftuopM7AUn9NJyMAb4XomTVuQpBsGKoSuTdnesReTOmcymfDB736dw9Vn+FFAVTUMA49RNMb0A46mFzx45xjDBCNwmd6/YDe/RPcjNMNk4kUI2+D2zUsWswVt2+IFHrtDTFN3qJaB0XeUbUm+XbA+pAQnEyxDI7QiRu6QgR+RtCqtUpMsFwhN5ZCsyQ5LDBUi18e0NFTLQnQVw9N3GQQOdVZS5jGyg7Q4cNiuKYoCTarYRoeh6eSHA2meEVgOgyBC00OqrkfTAz5nqhSVRTDwaDoVpawIa4muhOiKR58UWH2HTGv2qw1V3bPcZtR5iuYEpC0oCEZuhDtw0VSwNYM+jenab60n8B0RE3j65Jn8pb/xS+iBy/JmhmkYBGGEZujkh5TDfoPpuCAU+rpEt2yyssRRdJIiZzQaYdoWXd5QNTVVX/Pg/jmbzYYyq7BVBwxJ09Roqk3flbR9R5EVuL7HfrtjNJyAIqjquxVo6Ac0bXXnAioKuaUSNgq/8Wv/Gz/4x/8oWdIT+CZVU2MoCk0HgyCkrDKavOSwX+NEEZpuIpuazz5+xcn9CxA9umuzeXNNeDahKyp8b0gW75Gawnji8+azGVHk0yFRFIV4McM7PyOybfIyo+9UaFpq2WAogrrJ2S0TVMfEcV0cy2M/v2K3XTEYDOl6hUSRRFhIRYKpkCYlVRETaDa52rFYLDi2IypHwxA6bVsipYqGQpdliOMAIzeYTg1mi5yu6MDIiWydy33JYDxi9vySBw8eoAcavjMiTjcYQkUzHBRTpzvklLLGcgPW65eMhxesdjGuaTLyXfI8R7UsLj97ydN7F9RhgKaaSFpu3tzi+A7jaECdp1TpHdbNjgZobUPX9/S9ZDgZs7j5DC+Y4Hkem92BwdAhy1t0VUNTTRTZ0rU58XyH0DWkqqBZBsv5iqpJOTs+Iaslrq2j6yayV/CtFkVotMJGSME/+OY/4MwLsU9PEHmL5jk0Wcvt5Sc8fvQOMTrHo5Crl6/RHYPQCZitNoSDEPYxBAG6FBzqAt0xMIqWF8//HvbRFzHLPf5wyiFNkHmC4tncMc4tLE2jyxKyzSVqcMyAntjW2F4tGI3HnN8/52uffobe1cgsp5cKqqvzF/7D/5g311ffuUeEQggURaG8vcI1dDzbIkkSvvn1b6AKgR0MyfICU9Ww/QFZWjJ1Q+qqR5g2XVWx225QDYVGgqBj9vINRVogDJNO1KAo3L65oukr+qYlGo7w/BB6iWeYNPQs1ivS/ZqXLz6l7Bos0yUYj5nt1riqQlUW/MRP/ASb2YLzoyEooGsqk6Nj2q6ibDsWqy2VonDx4CF1r7Pa7KmA+597hNBhcjzFcxzuP36XapvS5w2VzHj98kNMzWI+2zK+OKZWOlzfJ8sTZODidrBZ76mLDlEXd5FtQKomXhARhgNGowHx7BbaGqmreMcn2OMI1fVxNI2mzSjqA/1qhyYq3nvvKWoYoSQ1Z8dn+EdjfMNF03tszycIAjRZ4t87ZoBDo3Uc0oZwZNJHOZE35WqfQprjVgUP3nuEMDyUBg7rDYf1msN6TUNPlRYc2hrT9bA1i6Fl02w2vDceYxgGn7x8iWW4NK3k/uPHLPKSoiypuooyyTmajinKlF5W6K7H6N4Jw8GAcRSgB3dl44ZtkuwXBOEJXdUxv1miKxWz2y3ULUrfUB22rGeX9ELDPj9GH4REx0e4tsWTp8949M4TgsGQ0cAl8IeIXsV2DOrCYCcFt7e33GxmvHv/jHUSc/36DY1sWCwvyaqEk3cesigq7E5y+dlrpACjqpC6zulRhFomJFVB4DnIrqIrG+r1km16YProy3SXH2PXgl28x3At1DCirnoM1aArdxRlQlq1DE8f00mVWoWuFaj2HUXr9naO0za4TsSu7DCCCFUx0L7NduA7whN49vSZ/MVf/K+w0VFsnfiwx9JN8rrENC1kryL6Gt12kF1/pzhkWeziLfSS7XbLo7N71LIjq0oMw6DMc/wwJC/vjhFD12O+3GE7gDAQQiVLC8oiwbQtHMulrmsUYeAHJsvrS3zPosKg6yRd3RCELqapYwoVKSDJSrKqJHQ96rpiu9/jBRE9krZucCydqumJkwNaDcPjAWmaUCR7PMtDNUzqrqVVBE3XYOkGm80GW7VxPJ2yamiLCtVzULqG7q1HNwnDO10EIe9+03GoywrHs2jyGLWT5HlOLFWGrs0hLVFMgdJIPMPACgJ2h5iiKDB0C90Q9E2P57hcX1+T5Tsu3nlCGRckzRaNAM3oyNYdilUznQTkB4E/DSmyArWvGV88YHZ1jWhzLDvEUnu2aYUfhcSbLV1b4rkBimqgmBrL61vG0wnRkYfI4dC2CBrqvMNzHdIsJ/AdWk1H7Ro0RaXtOzoBddlgiJ6s7qDLGHhj9l3F6vU1xX7Oj/3kT5HkLVWR4YYRad9Rr9dM7j+kLSrqIsMfD1hcLWgONzx+8nk+eP6c0dEZit5SJyU1KrquEO8STo8H3FzuiI5CyqbGUXSK/Z7h/WNkq5LEW0zFYZFtMN8mLpkqHE9PKLoevYxp9BBEw2w2YzodkqcN9BJBjip0FCsgCG0O+ww/CIj1nvBmRzzSUWuNqk0ZqBq7uMFyJPvlNc7wMU1+AE2l6Bu0/i1XwzARqsVut8U1VBzH4F/5hX+Ll29efed6An0vUYXGtm4pyhxds6iaBt00EUKQZwmW49FUNZahkRUpu2SHbdu4vsf5+TlXyxk3s1sURcM0bVzHp6hKDF1DF5DkCbquojQd6XZHaN8FS6bjAYZmIkWPkB1ZHnNIE+zBkCA6R+1THp6MeefJY8q2Z5dklNJkttsTFymiqmlkj9QUptH/ydybhVyXpXlev7XXnoczD+/4vd8UQ0ZkRlZnlp1Wd2djIYoFiuVFgYIXIljQtnjhRSuiDYJ4442I4JVIa1e3Sit0Q9k4FIWCZltVnWNEZkR80/t973jmPc97Ly/eQFvpqr6oKogFh7POA2fDvngenrWe/zDEpCWJYq6urjjEEYNAorqWXXxPqylMw2EwO6JUNWdnE+I45unZObLp0ZqGJ+dnDBdTeqW4ffMKzbMpkpTifsfANjGkzt1mS5pntHVNT4/hQFZk1GlJ10riUuHOxwwcn6boGA18qjBD18Ed+VRdD13NbOTR9h1V2dF3EB52aKbNaHpKEW559mTJ8fKEo8WMmzdvmQxnONMpQkqUb3Hz+nN0oZG3LeurazSpcMdzml7QCp04yzClDrbD8ukzvMkSoSu8wGW6HHN0PKJZVURJgjfwQRg4Y4+qL3HnI/Iipo3WjAIX23bJK9B0C8OycLwJ8/ER/miOMl0cx+Pi8TP+iV/7F3n1do0Z2BiDgN0+pI0jdOmR7A8IpfH27RWr3Z52ZFN5S35ydcN0uiRevYPWRhMPxzClFI/Pz9ncXnP29AhVtizcCabUcIIhSZIQphmOP0XaPeeLGXmeM55OcX2PzXZFl8UM5j4iWlHnJSezGboZYPoutueCtLGcKZmu+C/+y79OGIaEhwNlmrBPdmhFwzYMiQ4p20OK7trEUYYze4wXOCAbhuMJnj/AGczw/RmuM0A3DRxLMhiOaaXzx2YR/qkvIUBVEeOBgyaMhwu4pqHOa1zTYjr2sV0Lw4TVbouGoC1rbi/fIbqeuq5ZnBwzmUyoqoK7uxvKKsfVDXQB28MeTZfYtk1UNAznC2oNiqJAaj2z4RjLMGm6juXxgjzPMXWLu8MapU9Y5wVlHOGbBr5pkUZrbN0gkDq4FuubFU2jI80hpj9hPpny0Ucf0bQtcaoxO5pz+vgJVlhiSUHfNrTC4BcvbxiNB/zo05/iTwc4lku6i6GoyaOM2fE5hhJMp1Omx0sOWcHJyQnLswWe79M3HccjH5FKnixn6KZgvblClwV5XWEJ0Bwddz5kvDhBly7b9Y7w9o6mVwTegEkwoelLKtnR1B2mZ+P4JikaLy6v6IWP0DWGNnRGyebNawJ/yMC2yRnQ0GCohr7rcGYPSSBkC7rB2eMLqqpiYtukYURf1ly9u6VuFcF4xquf/IBmGOD5UyzdxJM6JjZG3qCnGZU7ptFc7sOWQ5IwGeqYCgzRkUQhTRdTFymrm1t0rcczGi7vPmc6cNGrDtH2LE5PWJ4vwNNRVESHmMXyCMu08Rqd81Ofo8XyAWg0fkRIQZOmTIIhuukQRSmD2ZSyqDkkKTfFjm0R0Wgabd/TbN9y/+ZLaApsTePo2QVDz8J0bJZnF4jxmNWuJlI2uzBicDwnvnnDxx8/Rbd1KqVh+h3Otuef+/Vfw5uN6SwDI9KwhwvKpuZIWIwGFtP5Mb0UCKUxPpoROAIxmiE1k+ztG67efc51fk8RR2yurlBdSZSHpHc7ot32D82/r8WIUAFZ1SO2Bw5pgTuwkKIjTCIcU6AZLlpZIaVHsbli9MSlkgbBYML65pZaPogpDoOA8hBhGAaWa5N3DfvNFsezUWVHWec4WcloKlmHIYOhT9lo7PcbHFdDNS15XvLk4ilZlmBpAkVLuI1ZqY6h59HoGkKDpsjxvQfm3uJ0SdNW/P7f/zF/8S98nzxqMKViZE4QomPkDgiLHjWS7Dc7HNNk4nhs7tdkUYFuDrE0kyTfINwRutFj9gGq75CtQijFyckRflkibIG63mI7Lv3IRnUSbdChSQPRSrzREWbgYAubsE5xhMf+1RVN31G1Hb7vozs6x+dnXH3xKbPZAqlZqKxFHw1wNA03cLk4mvLF63fQH7i5OvD+d79HlJV8PHmfmzc3aIFFoLeI3uH48QLRSW5uXuDYA/KqI8xDPnr6AfflDeFhz7e+9QkvvvyMs7NTDE1Rti2nH32fpqtoOkW2SRn7I0zZc41g6roMmgdJN0325HnNzJuRRAmm7WO7kr6tmE4CxtMHtZuilcxnU7Kq5v6wJhiM2G+3KDqU1OnqntnxhK4q6DWdRlSowkK2DUWZInuwDYcPvvttrl6+RTN8lKloSoWlSZ4+f0YZxxyUoNcanEbDXT6hVQpNahS1ILAs8rohy2toIt7+4kdMnnyEEcwwZM96GzJ9+pzXL2/plcDXII9qarthOZqzur5HCxwMt2ObxhTrnMl7jzEri1oJtpeXKHvIIK54ffUW2xKEZs7Rxx/zVEDeSwwhuHj2mF2Uku/3mDObyXzxh+bf16IToOvpu4rU0XDGLsJwaI0BpjsmLhratuYXP/ohdRFSyJ6ybMhu7/Bcg6u7t9i2xe39HZfXN+hCoy5L6qKkj2OGhsvYsNiHIYbU4XzKTy9fsN1uKdIdgaczmXrs9wcmsylpGvHi1UvyvETTxAOysO/wbQfbdqjTEM+wHlr0NKepct69eYeUkl/+zne5ubpin4XskwPCaBk6Bvf3d9RdSZHEBEGAP58gXJu4Tlk+vuD40QmbcMt0OmXgOCTXbxnYLsUhwfQ9lIK674j6lrv/6yfctw03cU1yqDAEVMUDJXcydBm7I5pOcQgjVKcwRjabrEBzfCQGt7fXWJbF/v4ec+xjSYdf/dV/HNvuoSqI9jtkD7e3Mbr0aHL5QMwpQasVRSawRlNMZXIymzE2Dlxdr8iVwgmm1ECvGZwfj0jiNciOb378Mdtoz9HRGdKSWKZDX7QYCoo4pwpjpp5JWoRoto5mGEglKKuGXrUYqsXVBdQ1lmOxWq3Zb7YIaXB3d0eexjR5iWEY6K3GwHYZOhNc28O2bTzD4HQ2w7U9ot2K7f2KpihAKaIoorYlj84f4w9dqijj08/eYJsBeg+e9WATJ42aMLzFcRR2I5kNZ+RS0FYNbZlTK0lYZ6wOIdE2wnUsHMPkvV/+PseLKSd2i2kZiF5RJwmr6xX7q3sKJdAGAdZoRG1qD5B0wyAKCzxjwPHJlM3+gFIavt9zcnHK+XlAl++ZjwKGw2MG4wldGRNFCdz8jOt3b7l8+xpTtJi2jVSCvvvDR4RfiyIgTQNpjfCFhW75jCyTpgqZzgYEQ486jVk+viBOKx4vLgiGQ47OT+j7nvfe/xhLszgbnVLkLcLU2L69JmsKSiSHpuI+jnAGDq1oSLYpsq3J85irmxu2NzdUZcyj4ykvX/wc2zIYDjzaqsYUOptDxGwyRZQ1SvU4msV2c8/Fkyds0xzDcTh7ekIVZdRmz/h4zNAwyO+v0EXINoyJv9L5Cw8x4W5Pnuds724YTY7xTI842qN1gpu7Ww77W1ZRTVGVBIspLYJeM7jbrknudyRmy0KTLI7mOK5Jq2moume32nBIUnoDlpMFz56cukD4AAAgAElEQVQ9xXIMVJbx/MkRnuPSeiZnj5+R9w2jxQJd6azSkN3rK2zXRjNd7NkElELTFZs4RukCU5mkxR7dsZAjl4vnFwg3oOglpVggTEG+XaOKmLrQMCyNOC1pOkVvuNwnO5psx831JYvl8QPisS1JOkUwnDA/W3Kz2lMWCavdnkfPHtMLyXQ4YBq46EgCe0iSZNQFBMMBZuAh+pzRaIoUOplsqMIM03fQVY1h2FQKanqQOmnWYBoOSQPD4yMsz8WXJrlo0YqGJivodB3bkGimgTUeUlc5cV5TNhqq7RgNjrlZx2imwJM9DpK6SxkMXdq+wJQ6nmEiMJnPXA5lRJXW5EnK2mhZBAP6tgfNxBg5SNOAvia+v8eoQVQPF9BmXTP2BriBj6YHSDOgqkNe/Pgzus6gvnuDNF0OcU5W5HRxxOZQkpWKm3aG4floRYPsdZAxhu2gG38yasN/akv1PY4pMEWDLhVpV+M7AZevL6mKBmFY2Jb3QFTpSnabDev1GiUEfdtRpAdU0BMEOlVRMn//MdQ9rjTwdQvZQLQO0TodaWgMx3MmwZRvffRtTDugrgRdD6bUiO9XGG3HyHdJ0j0j3yXaH8CWbO9XpFFNWbXE+z0nU4+hZVLuEoKxj4xLVm/vcOdLJucfkHQj0t0az3MxkJiOjT8b0BU17z15D9voibIUUymenxyjG0NmixPmiwlCwO5+S1+XaH2DZzsM/YDpow9hvODw7ktc38GVHb5nYIx8yjDClgZhGJLEIWXdYWCwX4dYqmUkLbqmZTRw0TQN3xsgNJvPL+9JOoHtSNpDTpTX+L7LyLGRQmJPRviWR10VuFnN/ecv0FRNrzUk6YF+HZE1FVUDjgVlFuJ8dSE703XiXUzX25w+/5i71Zo0yZgMxxiqwrY6mqTHGA6pC8UkmPD25Rt6KR7w8sKmtW0q26DUNFQWU4chRtfy+c9eYOjdw2Vr3lNa8NP/6e/Stw5dF1KXJa5jQa+wTUmtN4wdk3i7pigT1kXE88WMvmsYz6Z4Oriyw5Ma0WFLLwSLQMeUPZUmiMI1uqqwqoi06BHUTCfHoEykoaFpYPs+46XPftNi9DY2Oa5jYIc9uqgxbZ2mLPCcgOFyiqVLBkOXvMuQosUeuhj+gGDwAEnXZMNiOsAwLE7e/5hClBjTD4mijMFoyNwTFIbJdOFzffOWzfoW07DxTs/YZTET7z2MwER1f7gt8deiCEip0SnImp5eCTxN0Vc1Z0dHOIaOMwywLIPN5g7D1JBS4/jiEWEY0nYK0x8QGB5NWfP6xWt2d2vcwYBegu7ZWL6HoUm6LGVoSzRd4o0GHA4Penh5UXG32TNenjM6OWWfF2DoHLKGpoPJyZxAt1i9+AXTsc/50QnSMBCNxu3NPWnbUBY1jYThcszPf/RD0mhPXaR4oxldVWL4Jrpp4FoeSnRc7zakWYHWwCE+UIsKZVRouuC95x+ia5JHj44wzQdAUpQ2OI6NVqX4ts745Am7XUhRafj+nK7swLbJshS6jKpsqeuaTus4ffoUJ/CxbI26baiShrAssG2bo8EQ2zMZei4z2+LivWfYUlGXHaJOMGSLppkUfYtrumjzMaUmkJ3C8xx0XTI+PWE+HnEIU9zpGM+ZQNaBaXIoCwLHwrVM3r35OaYu8IcuyhJIy6QqIdcVvpSMFrMHmzWpQVvSVwmqz5GOhR7F+AOXXjfxRmNGszmnj5aUzcPZvh2YjK0hg299i7t4zTYqHkhaTYtUPUVbwy6hTlMMxyfKSjzpso1Dek0SHg4c4oxcaWiaxmEb4bouh6KhqCs820G1DYbuoS8fUdV7LGeIUgohBKI36MuagW+glCIYmBiWoOw0iizFDjzqRmIYNppeYPQdllZjD6eMxnN6TWOzi7i5uXlwxLJszKGPIV20HoRuPBRuw6E3FK7zUDz6wQDXAhGWfOOTj/j+9/8xbL2jjjM03STMr8mi9CtY7j98fS2KQK8gDnfolkFTxXRS0BgKL/BpVYfbO9RVwsnRnLwo6YR4uIU2dHRDYxuHdGT4gwGPL844OXtEnmeYrkOexdhC59HFKTLwOR3PCBydMsnomp6L+RzNVIxnUxzDwLN0qHX2m7dMZlNk21KVLev9geff+z55U1N1GoaUdJrg8ZNHjAYBVd8SRluapiGYDDg5PscwNRzPIWoasn2KbRnc3V0Tp8WDtHndEUZ7jF6SRSVFXHHYhby9esfN7Yqm7R8s2uIY1zGpu453N9cc9g/GqdNhQKNKojxlNPBYjCf4gct0cYHQOyaDIW2n2KxvqZsS0QmmgzFB4FNsNtzc3JC0EaKXHO5viMqOrM7RHR/D0ggmS7K6RBYJmy9fIYqS9et3xPd3mKaJpjREW1GWEWFRcXx6BG2LYxt0Nti2w8QOGExmVHXHOJgxCSb0HRiaQdN09D34tk4rNaRuMT8/wpCKs+WUpuVBJqxXbLuGKiyQes9+t+HLl1+gapCOoMk6KDUM28DMK1zXpykj2rZ+QH/OjojjmN6xcU5PMHiYFJUt1NKCrme7XSM6gT+a4dg+o+WMtm3oigLVC06PR1i2z+TRCZZUuPYU2zIe6OeGxWRoM53OaWpBkcT85EefMppM0VF00qJsC9yBi6Fajk7eIzDNBzXsOKGp6ofpletwcv4YbRyQJTnh1Q1xuiPOY1ytp2hLFsMAvWkRuoVCJ921D0VnMcWXLWUT0imJZkJDT91KHBR/FB7o61EEug7X9Qm3EUVSU9SKJq+J45giTnlz9w7bckmyElsKVF1yWN8TOC55XeGXDXWqCDybuurY3r5GFy6mJnBsl+39PUmSgG5yud/yg9/7faqyRdMfZthpUdILwWG7I04KBouAVneYDFwM26IqcizLYhYEBI7FaOahOdDkJVWnyIoSvdcZD2Z8/uOf0zaC8BBjaAZtnrNYzNENQZxGVGUPHYhOZ2Z6zBcjTp895vaQ09YFpqWjqDlfLkn3W+qyJHAt9qtbek1y/uQj0HS6Fob+mHCdcv/umrpqKcuSIq/omhzT1DE0Sa93nA5mD/Dk2RhpAWbH05MLAt3DcobohuJo+YwsDaFvyZKIrmhwTImrGWi2hj4YwsSndk1OP/6Iqq6JDntOHl0g/TFDTSPOasoiQ3UNvj0kivZkZUSWpAxnY6qu5JDGGIZBFaWsr16huTpFkqK1NXqTs3p9TVY03Kz3fPHZzxG9ItpsKNII09EZLE8YL4+YTqc4szNoBYYo0WTFYX/L5PEFA1tnNH1KX5bUUcy7d5dQZbRS53DzFtsyUUpRZltc3cQLRjx+7xsPsaohSmLoe1qhGM+nWE3Nu8sdZbZDKx9MPDbxhrws6JqaXlXEWUOUZeyiHUIIjk+P2IU76jpnPBiyud+RRClFVhLuI3ZJwiHL8B2NtitRbcv29ZcEXYlVNPiWy2C6xFQ9UuhgDWm7kpubGxbzE8oo5/7tS2YzjUqzqNuK3S4jS3QcB1zXZeJ5kD+QiLQ/AifwtUAMfvD+B+q/+et/E73VyGWF0Qpe394xW8wIXAeUhSUKLq/eMT+5oOs6fD8gS1I0TUPva3ZhQxPdMnn6hMByyLuG1e0Bx/Ox25Ra2pweTQn3GZpUJE2FLgSBaaJrgqIo8IIBddahrBY/GCLqnNdXG44fHVPXLapusR2derNne/OS6ce/hO0NMaXi7n7PYOixu71nfrREKp2OHtqGMM2wdYO6LhGaTjAZIU2D1WrFxHKIygZpS3QpGXgBeRERbkuskUGbFeRdz3AwRSt33Ly5xBm4jJdHNI2O6diINqJICtzhFFpJ11aoNqcoNRy9RB8vKfOKzWbDyWJOlBUEw4AWyHcxk4nJ9V3IwBEYvkOZFPS0FHlMvol4+tH3KLOQyfEIzfZQTct+F7OYBrx+d4NlC0zl825/zaOjM+pOw1SCtEjQhIFmPaDqZNfh2AOC2Qhdk2xefs7k2QfUWY4zHpDnOZ40iYuMvm85WzymqlNev3zN8uwYup60rHEsG80y2L/5lOnZMzRDo0pLek1n5rqs0hxNlWAZjIIJaV09oDyrkl7Y6LKhaxWG41EXMY7V0nQ2lqGzL3qWgU/U5FiVIkwOnD8+Ynu4Z+guSOICdzKiKHIGhk8tGiajAdvNnrZp2G2vCQYLeqHTCoWoa5Su0RYV1iiAXqH1iizL2K7WzOdLVN/gDYfkYYzt2rRmS5v0D3oIgcfc8yHassdm6bhUdctmv8edGGTCZSokVbiicVzmywVpckCqB62NsWOwSUv+8r/5l/nixZdfX8SgEA/EnVV4S7wNuVnfYg49VLzH1g3iOqZt4ezJ+yRZjNnXmLJlt9sh25xO6QjVYy/PoNPZ7g7Yesfd6y/Q6wLpulxeX5JHGcV+R9m2HF5fMRt50OmsdyWWHRDtDpRkdJ3B3d2KuG9ZTodUVUUcx3RaTysl/dBCPvqQugWVV2RpzWI2w7M93EFAVqRsN2syat68vUR1Da2to7su7nxCEsWosmToBoTJBkMo6Aq6uqHMc1RTENgaqtFxbI9BWdI2Faqz+eCjP8Ng9gjTDAgcm66sEXKIMT5ivTmwzVKEYVFWoLk6g9kCQ8DQNxnNZihVcPv6BX2dYSuBMHqMYMrAtljd7jANl/OzZxi6j5Bjnrz3SximRqb11FWK3StevXpBHlesrm+ZjWb41oTRaMQyOEKTJr6mYXsWZdtSdh1jaXJ8tGB8/gjds5gMAooyY/L+h5T7PcePTnA1E19q1F3LYDRGCoPN9pbwcGB6fvTQ9eUFvqOTZjGBY+NPz6m6njar8d2Atk84KIVpuljSITACkrs7ivUKqTr8QYCpK5q6I8ozqB7QqUlS8Nt/+7cxehPR17y7f4feddTkLE+PiZMKT5uzu9+j+xaiatDKjOhwYH21enDE6ios2+b47Am+69AZLaalGA4HaAikaCGO0JucPN7jehYXj84ZDjw0DeoyQR87VFqHLwOMvsETGkME2/sDr/cJZZ5zt92TtRn2KMBofWadQFDinZxjaAZaA33zoCIUb/a820dsbjfUVfWH59/XohN4/lz9R3/1P0R3XcbjIZapIZHkhx2FFPijKdEhJskTLh6dUdWKvCwxipB9qTF3dbA0DmFKvrvFco94//0LtnlBnpU8enxBF+6ppEZlGLR3W0bHR1R5SVdlTCYu610OSmO5dFlvMqo64XixxFUGb+7uePr8GSrLuT0khPt7zk6fcSgS5tMZq7sbFrM5g+mY+9WGqWOidIdaayizmsCy6MqEz378Q55/9D5Ja9DXiuF0QK8pwl2C7lrIThEdQp48fk5ThByyiPFoSbTZIT2FoXsITcMwLOIsxtQku33IbDBAdyR6p7PbR5iWAaaBqFr0sUO0jdAtA8oGjRbbtml6RZKV6JrCtD00XSKUompKuu7hslZrW/QeSlFgd5JGtxlMJ4T7A5VSjEyNOE04Oj0ii2I6U6KpntvXV8xGA1o0gsEEZ+CTxQmq6WiqCivwuIu3BIbL2PbY5wXTgU0nJck2AqkjejACB0GPJiWObtM2DW1TPOgvaiatanDcgLpOud/nXMwGNLoiDRMGwyGbcI8P5Ag8a4DKShJqThZLwvCA7w0R1Ii+o+lKOmmg04F06KqaVjS0tWLoB9jDgPqQkecFutORRzWL8xPKKMWfTanz6EG4w7Tpekh2B2aej9Ihq0oCvWKfC/zBA3ahafsHPopvc3e7QfNckn3IdLaApqYxNNIk4Ww6oag6OsSDnL4uoa1oO53o7o7p01PqrEKXEiEERZbSGxq60Bg6DknTUxchf+Wv/vu8fP3669sJ6JbN8+dPCYwxRlIQvVuRJhWvDg2H+wPVKuLFz35B4Ptc/+IndOsbZN+T1hqLIOCzL9/QKgvXH/HdP/vnmUymRIc9ZltxPhmzXu1IOw3PsvFEDxbcvr2ir1Ocscvd4cDAN3B1k9u8wBuOsCZTdnFHRsV4OmO3vec62WLrDcPJHDmymR7NsGwDS6vJq4j7t3dIy+Tt1Yo8i8jKA9HtJWVdsDwa8Wf+6X+KpNeJuwxLN2gsQfT2NY/GJnqcQ13i6R1ddCBH0cQVq3DzgO+PC7q8Yv3zz6jikL5RNEXDQDeospRuX/DuFz+m3r3EnfpU6YNrstNZLGyDidAQRYjnDkEYqI6HRNV09us1ok3Ib2+wNRPNNvFMGw2JMRujmy4FOk2UUSQRztBH1wwEJobmUcaQFSlGrtEXNmePPsCcn2M6PkWVE6626K2g6CVN14HSOB6e4mgWpueTHDaUrQWtxuT4DGvo05oGm/s3VEnH+u4tdV+yOeyppUlTZDS01KqiiFZ0ScWFO6RoS0QmOT46I9zlmL3F+u4dsu5oqRiOx1ycjBiNPaRqaes9eVlDENA1QF1j6BaGYeD4HpPRlGXgE2chTZrSNwmIinS9xXRcyqggana8/cXnJEUHpo2utZhljtR6yjJE080H/UJc3PGUuuoJw/Dh+OYJBr5PEoc4kzmn82NSPUaYLu8+/TmTgUNZ21R1QZ3FlH1B01YUdNgWjBc2ZqHAcaiaHNE0WJpD07aMUNwfKoy2p2sl6o/wIvxadAIfvv+h+u//xm+xiwravMBzXExH0Zs+6foGYzRHR2O/2rCYTsmikKSH9X7F0WhK2TSsdlsmoxHx6h3f+uR7qDblNirQ6Tmf2rxeF7iWQBgDmjxksRyjyZ53NyHz0Qm213C429IlCe7pKZ6pIcWQYOJwud6ilxWlKmmqAsuwaUWLXRfEysZqdRZnC8oyxq4LjNmS9T7l+OSMKElpu4of/M3/mstdwW/8638JTzXQwYaCpTvj7bvX2L5Htt7zjQ+ecXf3ls8/v+S7f+GfRPYaSRVSCxO9y5gFDvd5wtIcUdkP5KSma6nDCKXZWLpBMPCoi5y6Bd2VUKV4/oCy6tEMEyV6iu0ex7Ww/CFaC69e/YSjD/4sotpxuF7jLU+xhMYhj/A8j89++BOePP8Qy3qQ+Ja+i9G11ErQmIpoc4tKHsapWVmgpI5uGHRJzmTgsKVA37fI8YiyrJlMZlThgUpTTHyb9SahzBMc32c8HbM7hA8w7UqysAWllFytVpydn0Bb0/aCvlJcvvwJ3/7WR7x8e897n7zP5z98TScaDMNifuJTxh2z5QlJFXG42TOa2tS9xNJ0xrqOGI84hDvuX73h5OiIosgYLE/Zbu7wZnM8NDTbJj6EjIce7mhAtrohrU1EX3AoM2SlI2YjZp7N+tULxo/OKPIOs22Qlk2nWtZhiB+4D8CrbItSgvH4lLhN8NApe4Xcf4m/+ARVr6nVgNXuhiCY05Mx8AM6DJqiIc5jfFci6ppucoxaR6gAivCA440eVLWzjLx+GNOKruXf/Q/+Pb548Q/XGPxadAJt33Fzv8JT4B0vSERHmCqSOGW0OEEWDTo9k5MZcV1gDSwmE5cPPvgA0zTpu4RPvvWMKt9x9uQp73Z3pPQ05QFhWFSxwBo4D+y1CSTbew7bgsM6pCobVqsVVaOQUuA9Pqa1JOvbO66iGw67K5q71+imZBoEHD97jmG6GLpN2UiC6RhvbpAmEa1S7JTHblcSlzl/92/9DZr1O+qm49u/8S/xr/7bf4Wy3NPInt7uObbmuLYkCAKEUJw9fcrtIWQ8POPkG8/5/Pf/N/Y3v8CUNaLZI3uN3/s/fsTdizdUSUZ8e8tmm+BrLvpkQk+HYdvcXl2S5SV3mzuarCXZNbSNQd9plPv0//FwSAtFXsHddo8/OSHdX5Md9oyW58iuRTcl48GQoqn5znd/Cb3JcR0L/2hIpzq6psX3PTaffoqLy/BsTJzmuE5AIEEWLbY0KDWD/NWWehBgq5Zse8fh6hVKPRiG5HXDRx++R5GnuLaBJRTDwKepewwj4/n3vslg5lPGW95dvgXg3cvXNCLh+P1vchN1aMDm8p7ChtPzC9yJT1sYWIHPevcGwzDopaJTBp7jYUiDfQdpldH1PcHRjKOnTxgtjrm6fMt8NsMQEG43RFHMMBhTNYoozJBmQEdDWdZ4/ojRaMSwytHKAu/pBckhxDAMhB1QNw8Et+fPnnC0mINqQI0Zz48osjWD6uFd+i7HXnyb7e6GMHXQLIPT8zOE1HDdKZguSntgN44GAdIaEReSOkwo3R5ZVMxnj2l5kNobDX2ariaME6aTAeJPwJX4T3XphsHT82d0vkXg+Az84cMoC7hZ3XJ/uMW3a37vv/st0CSrqy1VXONaJrPjAfb8nCLt+fi9D6jzlvnQoeg6juYXaJ5Fb9k4nUFTSK5vIvrWRjclZdsCCb2x5/qwQrNNylXJoJOMHz1lcXxCH9hMzp5hWRa7bcbtqxtev7tiV5S4vgdlTt0YhEnM6vYaWedYssDoJe9/57sMZjPasmbcWbz80U/QNYP7L+/ok4pdnXAIN6RlgTsaMXM02ral3a8YDydMz88wj8+4OyQY6AjX5ejJU97/6GN2VcbYsTm2W+p0x7BsCLcbqjDm5OQ5dZNz9PiUfZ4wmg/57PoN6/UazXMoi54qK+i6itXqDZqmY3YlpnDQnCmqOuC4FkJvMSwHS+nEVQXOgN1my/bmHt1ocUXNPgo5evIhrqfjKxNbN3C0Ct2yaWwwREWbRXzynW8SvrokVxonjx/RCouub6EsuHn7jtv1OyZDB0dXJLsG09Lom5T96p7/83d/zNt3txyfPmZm6+y2MSdPHzEcTpFVBUbPaDAEU2NmGoT7DbrQaJsU3/fQrYA6bdGUwpBDskOI6hKGnoYtBE1WMRkveXN1Q1Qm+FZLj47KK4LxHPqCut5TpAnh1WvyskZYDtKdMPJGSEexyxvaqobbNXXa0xY1fZtQqxYzcAnTjHgTY+kWs5FJnTf49oQCyex4jJ4XlHGMbit0V6OqDrRNiSUqurZGJHv+3v/4d2hVxngSUO4rBiMX0/f55nLBOiypJWBAGkaE6x3Towlny1P22x3dH5c7IIS4FEL8TAjxYyHEH3wVmwgh/hchxIuvvsdfxYUQ4j8VQrwUQvxUCPGdf2QREBqNIdFaHak6LFMyG06xNBNLmpw++oBd7fHnfv1f4aNnz3ny8XsY44BdXJMlHUPLxwmGdKaPf3yCI6fsXrxC1zWMOKbzWnZVxJc3l4xnS1xboQRIb4jnnnJ28m2WoyWdBqXvEPUt+3fXaGXBrDbIij35YYM0Str1LSO/4ELV6A5Uu1vubr9kPD3h6Xsf0BlgjY7xjZ5u95Y0iRBU3GUJy9MJxW6PaUmubt4ym7m4noVPipNlvN3tML0hL7Me1SqcskZva8b+GEdzGMiO+dimqhW9gJtoz17ZrLOabZpy+uiCXte4Xt2wGE/R84pTKaiyiPdHAY5rYOs6huViWCaO5zL0h3SipMBA16FrCupO45AWJHFBuAmxZIkoQvQ+R4oObzymLCCyDJq2wvdddq9u+OLtJdLQKKqW/e0KVbcYswUje8jrL7/gww+fcDpaEG0SBlMdbzjA9Bze/8aHuKaFYfsUStBWl7SdZDqYMzs+IW8OeELDMiXOxWOOzsaUZYXKCxxDwzWgN2xGgyFKdSilsHSH4XTB9m7FyWREmu9YnpzQOxmD8QhvOOJ2tabISoazEZIKz7VwHA8zmJI2LZqnU4meuusp057p4gRrvCRO9jiyQ2sisjhkdXWF7Vv0nsfg4imDmcV0GqDrOm+/+AK9EdRxTd31RHVBVaYk6R5noGGYPZPpGN226YoNrhhRdBW68oi2FYZmYAjIy4rz97/Npz/7nGS9YzD3sF2PevWGy22IZUo++93/FbOVDI6WJK4PlUachJiuQa/+ZAhEv6qU+iWl1C9/9fvfAX5HKfUe8Dv8v56Dvwa899XnN4H//B/14K7vadsW6ZtESUqvQBgGSZlz9vgCzRRUXY9qCj5/846qFQzdEWPDYDaeYHUtaArT/spx2NZYvP9tWtOkNR2aSmM2nPLxx58wHng4F88ZzaboecK3P/6Iyqg4c4bYus9ESPY3t1yuN7y5vedH71ZsVjG//T/8t4zHQ+qzI6bzj+lGc6rSZ/7oY3xnQpmuybOSrGhom4ysqPAXj9lHKbamMbUq+vqetgFvYDJ/+oTL/Za6FBydfkTWaGhS4TUNA7NEKyL0wYLV61d0Xc3f+Vu/xZcvXrFLSxzH5mg+YzG7YOpobG5eMRyPSPbhgy6hUnx2+ZKqSHm9X5M3kn2uqOuWeL8hSWKSJEL2DapoUTR4zoD1/Q6JIpiOqdOc/XZH0zR47oyiMrjPc1pDJ0tTNNGQ7EM8z+GQ3OE/XXL05IQoydjfvXmwxE5C3vziS6K6QOomTV7yxYsvmU1H1GFD37SkaUqZbNhfv6NtKnQl0b1jDveXlF2N1DTm8zGFYZLVJe3tDWFaobUNuyRB0zTIK3rZ0yYRs9mM87MjTL2mqFP88ZD7/Z6BO0JkB0TSE4V7qqri6OgEJcBCkhz2qKZENRnzgQ19w9iQ2GgsxlM81wZVYjs6je6gaxZKCTqps3z0iOT2ljxK6OsCzXTZrrY0LSxPz1hHe4q2QIqOkXxQcRoOpgjh4Q+GNHWLP5kgxye44yFTx8ce2ly8f4ayBEmZYoyWLJ884nt/8VfQ7QBUQlm36P4SN/Cp6paPvvc9RN4iuhZf9ZR1gW0KRtMTTNP8EykC///1zwN/7av9XwN+/R+I/1fqYf09HizMj/+oBwlNo0chkNR1ja5Jttstlm7QNgoNnZHnIsZD6FqyOENpHcqzSMqC6XJCX3Ucohglet598RNOz5bEYYJlanC34+ZnnzGQivj+Dq1r6Xuw548o8gzSnru0pBegBRbPP/k2jz58n2ePn/P48WPm82N+4y/9W3SMef2//w6O51IqQWDrpFnFeDEmrg3W24Q3l9f8Z//xf8Lk6AhvPGV5coqj6bSOiz/7mMnZiDTPuXnxBd19xJef/pzbu0uu129Zre7YZbdkVOhmxcDPGJ/NsUTBn/sX/ooavKIAACAASURBVBlmnsPQn9PVEVlS0msd0hrxje/8CpYuOD9bELgeti2olOLy1TVHy0c4lkkVJ5zORlzd3TIemLz5wQ+oihotTekrg8vVNeOhQxptqaqKuojwA5eoOLDJMoKRTWBImrykEz2ryxcc9jm6KRG9RROlaElInhcoOUBvTUxvgrcY4Y/GjKYjzKnPo3OPShaYxoGii8n7gigDb3ICrkNdl2RlhR3M2axvkZZJHimMskOrJdJwiKOE4XROj8Z6uyJD4tFwc7XjsL3n9ZtrDlc3aHVHkce4hsWnP/wBrRRMF2Mcx2F7/YbDm8/I7l6iSXA8D9tx0Eyb3vAYIcl1A+nr9PqD4U0S7/G8gKPxhKKMmBxfYDctbd5y/uQp3njI6uoGgclwPkUIwcAPmE0XHE3nBP6YWrewfY8iSkjrElM3UOgUUYIhdfbhFZv9CkPqvPjiJX1rUO637NZ76iSBsiOOdiRZj6EUmm8QH/bMTxZYroUxdynylLpr0S2TxTjg5sWXqP6PTyBSwP8shPj7Qojf/Cq2VErdfbW/B5Zf7U+Bq3/gv9dfxf6/iS/Ebwoh/kAI8QeH/Z4myZn4A8bjKft9yHA0YzobE+8PeJaJaev8+Hd/h+lkyGQ5pa1aZCdQUqdsO8aLMUrCaDDlm5/8CtvtA5b99U9fYxw94skn36ZTknVSMp4vHjzgNOikxngU4I/G1PSUjcvPf/tvM6oykiQhryu8+RTfDYiLhD//z/4GQgl830cMTRzfQ1QWR5MBi8WcX/rOd/mX/7V/g/nwGKMzcZyAttdw/REiieh3HdKfcnLynA8/eo/OlGS14vTkAsfwqXKBngosc0QqXDohkb3BB86Uw+aGJvwSvbO4u/mMu8/+b+bePOa29a7v+6z1rHnc897v/J5z7j3DHY0vtjFDDKYQpIYEVaFFigqiaVRVZQgkVdtUldxIiEhJKwElRk2jqFWLQtSYYAItULADtjHG2Hc495x7xvecd97zXnuveewfr1Pxh03UoFb3+WctPXrW2tKWnmf9pu/n93k2yxlamVHIGmeXJ5ydPqNcrfHzhNbIJaemKtfoLYUwDrlx4wZVAbe+89vIPBW6Pm1fQ9d1snBDnkpEmwW5ojKdjlGbCtFUmKZOk8l4lkuzjjF0H7cnk8wXZLVM/9oN0C1uXNvmA990hzwJIAyplgFhMufobMY6iDmaROS1TpbLWP6A1ckpFyfHRJQwm1MsJgiRY8oNsqRw70/uMl2dYjhAOafjCXqOyfPTR6ymK9Z5w2Z2zrtvfoX2ThfFaBjoEnlVcnp6ysXFmMn4jBuvfoB1lHJ8fEwlbZhejlFH1yj0LienlwTBhvVyzeXlhHG6ITMayskcoowyr9lMLmgwSDYpWV1hmw5ZHJCSXakEDY2yyDh4YR/KnDyLrg5IRbBenCEqWC8vyMIFR8WczcN7SA3MFnPquiZvFGpqLHuL9taIMI4QhoHpt2h3e2wd9BmMuqiixnZkJEpqucbIckyhozSCdZyRpSm256PbHmVdsbhYUug2WfHnbEMmSdJO0zRnkiQNgN8Bfhz4dNM0rT+1Ztk0TVuSpH8J/L2maT73tfnfBf6Lpmm+/I3ef+fOy82v/tNPUQmB/LUo5mIZYOiCoqnw3RabICQuczxDo5EgvBxTRwGt/RFK47AOV/jdHjUNmtyQCBXF1FGyijxImWYTistj+ju3wTSQJRXHcTgfzxBUhJsUW1rj3/gg5fyUMAF5YNKNGqZFyiYIOdwZsVqt8FsdovUU4XooCNK0ZHJ2xsHeHllRENUpugSmY7KJE3zLRA6WjMOa4dDh+WzD9e4OcbNgfb5CuD5JklBrMloVo6s6/bZPUsJykVJJKXq5xp43nLkVXSGxFn0W6w3RbEzPVJA8D0OA1unTJGuqMCetUozeAE13yC/eYzR8kXuPH9PuuEiKgUqJbLSo8jFN00HWNuSZTb9tkJQVSZlj2j5uo5GJgnC9oNEU1kHMju9x8uiSy3SOLglevLaHKTWsaolwNWNrfxclg0kWYpkOymxCMTggWK+Q0BCXRyydDh2rooxDYtXBqmW0jkN8fI7qWTQFyG5DETXofhdVVBhKSRwITAG5IqiyFZtChSxCFBrhUGe3qCnmK87XOVt7+5TVigKZ9Sai09vGs3qcPPk8Q29AVJQ4u1uYkkKwCMAySYsUpVHRTIGkGHhqTTSZUjk+jikTLmKC1YLeaAcJDd13qOKAulLQhUJWxzQoaLqDqpVUuXqFhxcKQsgUqzmZ28KUaqhK5uNz1knNwM2xzD1WyRzV7KJrKq4SsMpbNFWIZniAoBQN0cU5kmoQhROu3XyFpK5p6wrz8SWq73G5WCE2a4KqoGsP+Km/81M8evrk3z5F2DTN2deuE+BXgQ8D439t5n/tOvna8jNg7089vvu1uT/rF2iahqopqOuSKIrY3u7hOSa6qlIUBb5rIuocw9RRhEwmVNq3XiOMBcLTsYcD4roEYTCNG6JZQDQLCMOQQpVx7BbejQ8R5eBaDlVV8ezZM7qtK5lyb6fH6NodqvUUuzvAUhsGeDS6DsuE/YNdiqrAdlrUdYrT30WvcuLlGMeW6OmC4PwYxzIQzRWvfrOKURuFzSrh2kuvYmgN61VIx/GYZwGTixyz22dre4Bl63S8NrYzxLaHLOKKLIixbYP5xRmSPmTa80gzidLZJa9yDnaHvPbKy2C12d3eQ9Ydeph09g8Q3QGHL7yK2YAuyaBvcRpG6K7LTt9jOrsgCkukTQr2Fm7Lw9D6eK5FKFVUZY6j24gsJilT4k1MsNoQj2eMdIuj996ht+tx42CHVschLhKCIkTR4Y03PkSc1TS+g2Go+I6P2NoCqcBUNHSpIG338R1Boxhs7R0ybHdRZYl+y6fWTVxvRLjOQHHJGgktXFGlNZcnEYouMQ4CZF2lrA3KZE3V1ERViLWJKRuDetBFaSmYLRPZdVFUiTuv3kGhYj15gtAsVkWFujVkfHLM2dkJT4/usxqfEc6X1HlAs1mTLi+pyMmaiiiY8+jee4ynz2h3O1S1weMn94mfvY1iOcRxgiCiSXPajkbw7CGz8QTVbpiePANS8iyjdh2ULEKRaqJgTqvXpd11qPQup+GS9vYB3sjF0h0CyaWoGlyvhaGrFHmEnBeE8wsa0WD7bfI8J5yMmUwm1JXGbJmiag1Nq8dW/xqqplD8ebIDkiTZkiS5//oe+F7gLvBp4Ee+tuxHgF/72v2ngR/+WpbgW4DgT7kNX3cIWZCWBZZ+RQAum5pyMWHk6Zy++SXqSiYMA3Rd5e0/+SqqLFBlQadl0+156LKGIWmksyV1EtBrmXiGjJB1hBBomoYuKShRTtnkLIIlqq7Qa3cIgiWjrSG+4zJbLMipiDZrckPnRt9k1G+x98oBdZowX4aEaUDbcVht1mSNSnvrBkkqI1SZSkhkdYkigSQ0NFtDtU3cbpvHJ5fIRg+rNaJKUsqiwmnbGJbJ+fE5nu3gqhrnx8ekzRX00/TbKJJgsHvI0+en9Nt9Rv0Rmyyh37mi3c7WV6KTPC0wNJVIztg8n5GHa4L1kpOnp1RNjdtv0VEb/G6fWWox2LrOYNRnPTvCNzTScIbR6zBfjDn6k3ewnRZN0VA2MkEcYmg6cpSQxjnuqENv/xZed4hlmmyP9tH0HpraJS9UHj8d43guwTLEsfvMz8+5ODpmdXlJ2xLkqwtubHn0bRulrknWCXm8xnevyoZfvf0CiIi9V/cZqC6uJriMJR6fnCFUmY5lsgpmqHnI7vYBQpLZGu1xMNrFH+6gGCZpDqPtPZbrDcsgwqplpqdjmjik1WrR6m5TRTmrIMJtD+nubDPc38FLrrpD5UVN2AjipCacZURFg67rSJJCEBY06wsWkweUdYa+d43Z+JJoOebJo8+xjhNWeY5yMMIxFaoootvzGI8v8H2XNArJsoRNtAYETSOwLA+Fhl6nz+pyiiwalLpkc/QQQy25XASs12uCdcRkOqW/c4cmKxi2twmDFU7PZzodIwwZs8roVDZammPVEwy9Qde+MVno3+gOSJJ0nauvP1yBSX+5aZqfkSSpC/wzYB94Dvz7TdMsJEmSgP8B+D4gBn70z3IF4Kor8c/97D/A7/bQLIs0TXEMg0rIZFWNVF+p/EzdQiglWZYjhECpLUYDnS/+8T1afQfL9FHqGtXRCcOQLC8Z9rpkSYzrumyShCJvaJs6YVGRU3K4u0NSNqzGF1fwBySSqsawTJBliqZCl2RavsvleMxiFXH94JA4SynSDF2S6A961JpKtFlTlTmKqrNcLzE1HV1zUC2VeDZnOQ8wfJ11VF6BRqoUs92nKVIGvSGrOKGJM2pHQygKT997yGA0Ip6eYfR6VxLiMKPd6hCt52DrpEsQ8oogTGn3t65iGJ6JpThE8RpVqORFQrvVpaZis4iwfAtb11gsJth+hzys0Z2abBFy8uwRB7dfJY4KhKogCYEqN5i+TTJdgiEhPIf4dI0mUgrD4vJ4QqejsVzNcJ0eQd7QtQ1KGTyvRTibE5YF7Y4LaYYkG6CptHyLuEhQopxJMieZhNi6RrUaIzkakreNUUucn8zo9jRaZkMeZUyyNV57xCaW0E0X6pwkmNM7PCSvGxoh0et0ef7W2zh7+xgrOA0u8X2PqErZLHMGHYE2y9C2PSTVxHEs4jJHyQRBtmK9XDB68RazZw/xbB/LcxlfLlFUnSrJsM2GVTRHUjv4ukF18ZCk3cJyBySzNZpuEocL3IMdmkxgaNWVkrSKWaYR0iTFu3kbaRVieQqrNZgdyBcJVVFgdNqsx8+Q7F1sq4WuBSyWMb7vI+SS8/Mlg16Ll/7C69z/7FeQtQpFabFeBeTlEtfrsykqlFzCYMnf+Dt/lyeP/y27EjdN8xR4/evMz4Hv/jrzDfCf/Zve+6dHUVakdUPPNInDEFk1CdMSQ5MxhSDMI3zXQpIl6lLG8zySOGLUUknDlN7uDqYuozU6aDVFlTMYdqk2GYquX6XG0oSqrrBsizCJMW2XPbfLFz7zGXYPrxMVBaZuUDQViiSDLCM1DVVWkCoqQZhhWS664lKUKaoAf6vP6ek5yWyC67pkWcFsuqTjWzR5TRrHJHJCkCdc37uBSAJQXDwnRW37V0QaVZCFEo8fP2X7pZs0uuC9dx/THQ3Y2T0gzSK0do+yUtGRUWybIM/QbQ9NaKTKYzx/F6erQhqSlRVVXBJVF5iGS95ImIbDYjrHa/sUecLZsxnDrV0kRadoYBXM0GIwHJ/t6y8Shwnd/QHl/Iyg1CnSkvHyFFfvUAYVdV4jSQWNpiEkCd2uMEyXrmSTRAt6nseoN+L88ozp8SO2rt/Bn04RTc66rLB8nUKSuXz2FNuzOF5s0Asd2TPojkZ86s13+fZv+zDNOiBVHQ5fH1GVbTZJRO1E7N24SZIkOEZJUYLrdJlvNqRxSJwX2JQ8WUzodLqoUgFaQNdOqcqGtmEzuOOiVyX30hRzseHma9sET59TeDZVkKIPOwzSnA+8cMjvHj+nVDQevPMuXn9Is5qRlRnJOqFOHZx9FVyD3ujD5HHKLIsooyl1aDE43GW+jFFVFUzBIpqj6Q7RIqKz1SNfXmC5BmEQE6sJbWmHlIrUVTDzmO7OLZbTEww1xJT3qO2SYLlANXREk1BWKk/ffozmeKRpDEVEFAdUdYnXVZA2OZIcUlYWUvmNswPiE5/4xP+b/fr/yfjkP/yHn/grf+Xfgyrn/Ol7dAdD0rQiLWOKqsHWFWRJ0DSQhSmNCoYiSKuQNKmxSTm79w6xXOK7PoosuDx+RF7LzNcrDnZ2iKMYioZev01e1pRlynSxoLc9wnYcbMdBKAq+60EDlmNTUtNv9bBslzTNWG8CFEPD1DXqsmI2uVITzmdTBA1VVTIYdhGKid/xQG5Y17C5HFMLBcf0SMsESQg8xyavG4okRlI0HMslSiKquKTXbuF2fCqppmO7oAlOvvxVuns3qLMJfbtLkqXU9QbV7CNUkzJNWYdrJMtCU1UKSRDlNarVsE4SNlWCKKHMY7a2t1CQKLKMrASkBsfWUFSDhoZws6LMGip0yjBAs2zKCioRoyFj6wrRZIY3GDF+esL+4QsEwYaGGGE6KGlCrhpUjYpQJERRUeoSq6xGswyCzRKlUaCCUgim9x6y9cIWnqTi+Db7O31cp4OiKGiWSpkLZKnm8uwJje5SlwKlkpmv16w2IXkskUYbLs4uadU5TXLGvu3zbLnExqG9t830fIXd7rAMN5RJSr4RyFkAlUS+mjJ9+22aXgeqhuX5MyRHsLgMUJqMusnptfsUm5ze7i6mY9Pd2qbX8wnTDaoEqq6TNQrrJCTPTIbbEvkyYlWWpEnK5eUYqVR48N4jfFnCdT067T7xJsbp+OTzNUmcIzkai3efEFYldZMhGouqEZiOyvnZGcVmRVWW2H4HwzY5OrnE3/IpwhWziwBNM1FUA63IOb7/DpowWc9m/KsvfY4f/6mf/m+/3v57X5QNV1WNqWqMDI2+22KVp0gs6fkeRhORNDlJ+ZgmzJF9qKuEKA6IMplKs7n/+Bjz8DpNWTF+9oi8zuj096ioefMLX+Dps2d4votiqmxWa6bTMU0Nhu1QxhlJllIkMaoquP/Hf0w6XbKJQuSkJkjXrBZj2m2X7e1dRFWSRyl5DY7TIQgXqBJYrs31nT2qcIPrmqRZTpoWDD2b2y+/hFJGrNOUaBMjSYKshjRO8FpdDEmQZhuGrS0OhwaiZV21LhMyT86eUaYZux/8CFVVMBvnHM1nyJpMt7NFliRk0xOOnx/R6vgYQqdKM1RJZtBrocgqPcOio3vYjo/htZgsVsSbkKwu0YWE7VksZ3MuT58TFRW60wKpRBYCSTORLesqHtHaoZYU4rhi+/p1kiSltzUkXs6ppArT6eE6PnEtk0Ub+h0bSehX/fLWG8I8p0xD2rZNFIa0h30MxeLWKx9EEQaGYRBFDbpwUE0L029TNjKtto6hu9y6+RJ9yyMcP0e2TNqtFnuDHpajMxrt8PqH3iDQXArvNs9SDUWYBHLJ4nJDWTXIqNy+fhNV91A9hyAo8DyHSBY8rnXKWKYoM8qoQbV6TJYTGt2iZQ0Qmwh32CGxZER7lwydjSphOz7j2YzTB3eRkhwla/jWD71AJg2oDA/fNOn2W+y0ffq7fT76zR/G3hqSNTWLbIOiKdRU6LaD4bbIa52tF3eYTsc8uPsYyxNkRU6T1ui2g7t1gFAVTEWQxAUtSSF8dsLxvWfsvfQC6cCkylYU1HRu3qLQBaUKtfzniAn8/zEO97abf/ALP0uxrtk7HCLNC2azI5ybH2R+/0vcf+cPaX1vhZZ36Yl9JsspadkwMO7Qab3MtlODMyDaxDx4/C7f/fHvQy5D3n7vmBt7be4/eMZLH3yN5WTOqGUT1hKz1Zq2a6NJGhu5QAtWyJ5Fv1b4lX/+KT7+w3+NKogoyoyslPA8hzgp0JUKTTOpRQ1ZTZxtkDSTJghxuz2myxWyDLKmkMYJbV2lkhQ0y0KSJFqWwfHljLwsaDsepirI6hwtiVjW0O4OUGSZ0wdP6G53OJuc42sjTCNmmcbItcI4CNnf3iFZBiiaRDCfITs+WVGzNeyhmhKm4XJ2doEmN1iNz/npXXqHN5Fl6YrLuAlxVR3khrJsSNOIgeWwjFPctgtFQRxF1HVNe7BFug5ZTpZUrkxHguUmpr93QFHlPL//kG/68Lcwvpgg1KvgqJAEWZZSFRmGapGJEke30bUKKgG2STCdYlkWZqOTZEskof8/CHXLaShynSxOmcxPafX6aK5LvokwZJCVq/oKQxEslgm+7yIrFWGt4qsKx5fPaDstbNvk+MG77F/bQyoFte9Rb9aomkGdpoRpRrvdJityZASXRw/ZO3iJlSoTnZ2xvd9iMwvQzC6WEpPUGuEqoZBL1LaKUupXaeD1mikZB6pOlEr0DgdM5ytSSWc4GJCnOZPL53h72yxnG168dg0pXrJYB6hNQhDLCEOAVFNT0Rntsrj3LrHp0ddrdLdPVlXUZYPr2tRlgZAE5WzBcVSwO7j67x48fJvta2/gaAZpuSJbqxTRhJ/95C/y7oMHXzcm8L5wB37hF37uEx840Hn9YMBv/71P8plnj3j01Ufo/d9nFd/njZdv0xVz3nvyFt7AQi9OuHf6ZW5cv0lYfh67GpI2Ko2oGG4Lnr7zFkfRA0Z9l6OHp2xv7zCezVEUQRDGhFHIzqjP/HLKe2czppcrTLfFdLUkc3S2D68THF9QuzbxbMn2/g7z5YIsr+l0bNSqIacmiXJkCRRhkOU5l+cndHz3ysqwLHRdR1F1JFUwnc6QqopNsKGhZjDskyYxmyTDsLQrDv9FRqOukRSTpCoRus5mtqG37fL86SWD3hbIOpIik6Ylm01Iq9fj2d1H9K7tYagqiqwQJwXBMiDPC0BCtQXCsrE0g02whqakkAUtwyYRFVLVUFclmm7hOC55ml1BTuUKqVEomwZFCKy2B3VDXjaYbY8kTqmrmv7WNptoQ5mlnJ88we0NqcoUIWQ82yevK5SqRnd04iBiMQvIpAq5FiALgqxEqQrKRsK2PNIspiwULNOkkWvsVht5HRKWCns7PYJlzMOHj5AUGSE17Gztkq4nyMQooqJvu8iKhapKhGGMbWkUWY3d6hKlOTqCG3v7VFJDKcF0skS2dLK8YrDVI/cU9CCiqSU2YYDcqOiage62qGQFvVpiCou27fHg6VNajk/7cIvofMrOnddoug6VbBI2FQfbe8zHpyA3TI4v0Yce6+NLVE1HyIKkyGkUnbbXognOEGlOz76GLGU4Ix9PmDy/f0S35xOkCYqQiNME12+zCAK8UY+t7W0uphM6jseB00F1PRqpptcZoFsGkga/+pu/yU99A3fgfXEI/PzP/8InfvRHfpysthh807fx+s0XufHGB4nmPV6//ZdJNyPMwUdRqzv4TyU09WUWj2oOpS3Kd59y9M5d/uJf+nY+9wefYzI+YT66S/rwd5DLc+r+JeMHXyQ5/hL/7g//NI9OHzO79xRz4PGP/8UXef7oki+9+cfksYnhKmwlMUVTU3ttxg8f8dUvfoEk2pAXsN22iD7/WTa7++TBmFLxkCQFWYFlMEc1bHyvxenjB9idDvU6RtYUskpCiIw4TRlsD0iSAlVTefj0Cde2hiwWAVkU0+/7yLLFydMnmK5HEScojkmeVYzPj/GcFjgSpi4QtYQmN5iWjXAU2q0OvqMgmRbrbE3ba+NqJmkUIVHR7/aZLyZ4nRFpnNEyTeI0R5VlkniFa3gUEsRhSFbnmLqFbjmQ5ciKBhJkaYBtq7i6TpHXeG0bUcu4toksN2iKjtf2CVcBLaNFa6tHFRdojkKZ1+iGgWY4OI6Db5hXzWWn56i6T900IMkMB22COMbSDeo8QjQlICgkhaq4wpXpSBxc26HOS1qaRKIJwignrlS2OgOsVofpYoEioMxLun4LSRioQmBaBqvZnPk6Yp2DoxlUTYQmq2iKjKsNuVxPqM8v2TQlli6zvbvNoknoSjJP3noT0zMZbLU42yR0vB4tz6Zqctpbe2QULOZrZFKkCpKsRiLDFG28/S3qouFgf4+srhCyxK07B4xPJmxv7RJnFaXpk5cpq01Jv9/n7lfvMnrpJR7fv8/wYBcTG8tzkGQZSZbJoph7f/QFBtcOKGudzgs3WQdzynhMkUTk8YqySPns57/Ij//ET3zdQ+B94Q7cunmr+Zkf+9t0rl9D812i5Qq/rZPEKllVosQxnY7ODAmRV6wWAcKuSWKDoaUyTuHjH7jG0y9/ltNCYn6SYuy0afltsjggigt2+x3MwxHJ+JTp6YJHJyseP3nONNgwvPd/8ofNa1x76Tr/+Y+6WJnOUtrj4PqrPDqdohsmebTE6A6ILo7QZwVfmZ3z3R/7Xs4nJ+hVzsH+i8Qy5GWFqllMJs/oDfbwiohIGEh6ipJBu+fz6GjFcNTi/GyKKEsaTcOQa7I6RdE96rxAUw0sTWG2WtNkS0Lh0PU9qukRhqXTaAMqKUfoFgKJbLlCdV1ELcgnM5pRm2S+pD3sIwuI4hS5kkERVEqDpVlEUYTjeJTZirJREHlDI2SyIkfXrmoxyuZK3FVVFa5l0ygCTVMJxjMKuaCqGkxFoygqer0e0/Mjojilv7NHFK7Y7g9JkoRNAZrjUC7GWK0WrV6f4Pk5X/zd3+KjP/ADVxZKWdFu+2CZJHkGRUNdlORpSaM0gES/7VI3CpNgiaBiHhfs+jpZrVAVBUJc6U+SaINm2Qy621zOnqGVBYnQEFJFJmto4RSlUNCHI+pSR3YF2fER6tYQEclEcoGe5WSOgbmKKVo+bppwCZiWgiNvoHB5fPceL955iXlWYEsmklxQG4JiMUM2NC4mY3Z2BxBHRJMVLc/mzge/nbcfPoa6Ijp+jHHnOl2nQ7yJEULCkzXyzZTQ8dDzzVVzHM3EVE3CeI6kWchKg63rrJcpqBKWbkEWEcYhrmoQZBOu3/wmnl+c0xUGP/LTf5MHD78+aPR9YQn893//v/vE4eEIVzMIpSlWXDN//DajHRWEQq+t0RgdRJ2CBC++/jqLkxMas8V6POb64cuspZrlPGdbLmm9fpvC8OgKQctSGN+9x85rH2Q+3tAxu+xvjfhnv/373L94hLyGB9sDdvUBf/H7X+b1V/8y07mB1b7NxaM/pLtzQLacoWUlb371LrZl8M2HPZ5Ha15/UUO5PEGSM94+OSMoYsqmQhMS+SZkdf8rPBzPORvPmb79LrXlUjc6x+fvcnl5j0G/QxLF2L5Ny1PJMkGeV1R5RlVXaLbKJpgxWee8duMGzx4coQgTxd0mqCNW0zWmLJivVjR1QavbYTyf0eu45ALSokTTdcosRVQy1sCDqiKLcgwlo85DijigESZN1FAXCbIoiZdTamA5nuH2OmR5giwEdbHCNixWl3MaVaeoBbV4HwAAIABJREFUSizVJFdkiihFEgWN5WG2u6DaVFGK126TUXN5dsbQttB6XRaTGVKWUVRguS7UNY1mXLUvkhTidQRlTde3SNYrDNtBMQUyGoWUY6g2i+dP0VwfTVOIlxFVdcVkKJua2XSMJUs01DQlRNkSKUio9DZaZeL5Np7rk2g1Jw9PUISBPn1OrkmwAamlY6FidEfYWUGsy4hiQVSaqM0MSZeh9ImTjNG1LaI4xHNbtG2LtFyjC4NIUjBMj07HpVopLGlodftUukO2XlPIEkJV0F44RNk0dHObui4omxLHNDheJviGilqZpJpGg0JR5hi2QjApyLOCNKlw1Bq146CnOWFS0hn0qA0bWdGZTJYYuoQwDH7913+DH/sGlsD7IjugaIIPfvhbUdo+ncLjkpLhR76TeeGA6THdyExOjpg+OMXVXE4ePEFIHmW0YOfaAU9O3uTo7S8hmSrPSh1bd+k1Mv3tHqLSeeWv/iWSdIXwFEoV/v7P/0/MF0scs8tKNOTPEp5OH3J6rPNXf/AnWTtduh2Dg2/5PmpFxlJH2IMbfMeHPsq1Wy8y293lOz7y3Tyfevgf+C5qvceoe41OOuXFnk/XNGiyipXQGDgq2XTG0WLJZDHlc//XP2cZf4l5+r/zL9/820TuH/H02SeZFp/ldPpZmnCCrRpIm3OCi5BNHDAYdAnSKV7fQ3dt0uU9eqaH1zGRlYbdjkd//wDiNYUqc7peE54+RzYbzh68RxElZJmgyWrKNMFuq2j4lIUHikRZliR1RK1CITRUt4Oq6LiDLnEcI2QZQ2rYZAqbJMfsuuRSje9ZbKIMaNBMmYvLGV7LxiTDijfoukGQJBRxznBnm1TSkKMEIWsEeUIi1yjDLqgCIdVosoSt68iqQJUyJuMV6DphlZOuM4p8RbKpWEcBkusjaQ15EaF1Tez2EG9+ToOEY1qIzhDb61NIDUJqofd9bu151PIGyzBYRRs02eUDb3wQ3Szo33yFAgPZcaiLkqiJmR3dJyoyyqzANLs4Vs3J8YRyVpOFMbUimE0ianTKsuTReEwjG6RRyFbXR84zNlFGoOb0eh0UWcV2W4QAln7FNwxiJMvnKF2gqAVCcghLmVa7RxAviQ0NTVKp8xTfdfCMEU04pb/Vx9Bk8rpi/PSUOJMwPY3peML8wT3KTUNHV8nOjsni8s9kDL4vWpMLWXDr9ivIpokiybinj7mYznj+5CEf/uaPMNjaZrrScfcUkqjA0DRqs+Jw+5DTR0dcv3aNh++9x2HHZR2F5HnOMlhjqQof+s7b3J2XrI+mjIYdWprBpILmeh9zU5Ipc8q6y9/9T/9D9nYO+IE3/jrJe1/C2/o4qybl5PN/wOsf/z50Q3D0cE5P3SdfX1AvF1y7/lHWyYaXPvrvcP7kGWr/ZaJgQ7tls31DY0u+Qzl7xM7BSwQ26GuJ8s4t5HlIMvkWXnrpOp6ukBqPUJ/E6Eczum9IfOijff6bv/UraFLBv/riZ/mP/9oPsfBGuF6bk6P36B/sEo/P2N0fcnx8zo39AU8fv00+b9B3h2iez7uLt7gVu2zdeJXZ+Dl7WxpFXpKEGVLTkJZLTLXiYmPS9iQMw8C0ZNKyIlnP0Dp9NouA9s4IhYY4yRj6PrVac/bgPsOtLeLjJUqvx+OvfJmdfpsbh3e4OJqg2Rqmp0EiUUabK3pwVZI2MR3HYnp2wQuv3UDKBUkSEScpu/t9NlHI+ekJo/19qhQkRSYvdXSjRBENkqwghE6UJtiipglremaHsm4wq5zJYA83TZB1E8e2UHOT3/jtT/OZz/wuoz2fk+MLfu7nP0kt52x1W8xnMUEUMBjtcrqcs7e3x/liiY9FUuT0Rls8ffqYnZ091kECecn+tZfo9X0uTmbs2D6xnfLw4WP2BltIVUwwXjAYbHN6dsGo22cTFvRbDiLPSPOUuqxQVZ0yyTGaAlV4LBZnWOEZp80hph4TRRn3/+n/yO3/4CdJl0t2ByPquuQPfuv3+Nj3fBdaf5s0K8jyElEr9Le2yTYBpeJjtnqUmoNkyiyzBnvnFaQmQRLvc9DojcPD5lf/t3/M7FImzpegwOF2j3unZ1zfu0OSrrFkneV8jK7r5LKC7Zg4ts96s+T8eEyjVxwOe+TCYjqbo2kqeS3zQtdi+egBxu4+UdXwX/70L6HdaRO3DcKTJZpI0eKCT//P/4T777yJaZscPzvm5vXrJKfnrEmwh33qxiQfz4gMiW63C2UBlUYhF/R3e6hRw+d+57f4yPd8L8PdIctFyLPjI3zbR5gqUlOj5hKTyQS/45FtYkzPJ8pjDMNCaSRmkwmj0QApnfLOs1MOX7hDOBlT1TW5UpI9fU7r+jZCl2l39pieTlGKkHeevsu+GfNH03exwiW3hjs4OwP8F76Tj330h/i1/+WTnN/9Ijc+9oPM50sSWTBs90ny5CojoPhMJ6dUkkLBAinW2NvdwnQbNpsKtz/i5OlDOpYgylQ6Q5twXVKuNxSUyI6LEheYVpdc1GjUNMjc/8ofYdkat7/124iWAUVRUBcVuq6x2Fzit3fIygQpqSi0FDN30T0TWVORMkCVMF2D1fEFuS3wLRVrNmdu2rRpsZFXIK4YAMXJCbFr4CgSatUgGQ4XkwChSLi6BoaKpKj4ukWwiVE1mVqR0UuJIg1Q0RDtAZkaMf7iW1itXVKxxOxtsX48RRk4NKSoisXZk6dcu3WDsmy4d/ddhp0Bna02agXCNNFNDVVRSMuCzXJFXUl4jklZSyRhxMl8xq1re3TaPQa+wR+/d4++v4UiV8SioUxCRCEjNBXDsJBkhWWwpo4jFKlgcjLBGo0YP3yX/VffQLFtbLUhCjPKJqOOMzzNJjMbfOGTShX/yY/9DZ4cHb1/YwK/+Au/+ImPfeQ72N7eIVMFO8NtirJgtL2FopmsgyVJBbWmImkmqFdYq6ookYTELA7ZG2xTSBqGptByOwSrJXqdUJttQsOjbiS+/IU3CeoVOEOKdI2hSKTBinpZ8z1/4TWCJGdra4snj5+iGxaBAYZhYakOZ5MLJEXBGw7YBCFCVulsuaxnY9ZHxwRBwNbN15Ckkre+8hUunj4kmp2gyAazyyVmUTAvYnqDFprQMHstsmBNsF7gqQW2lOJu7zKZXnJ4cBvV8ZCp0b0WSVLjWC2crRt4nW2qxrwSGOkCSRb4+oDPfeEp3/XdP4Tl36T34scI5xpb7W3eu/s2paSw+9JHaPW7qIbP/ftPeX7/Effevstv/IvfpE6OePP3f5NEUnjn7XsMbqw5j+9x9PgMQ1EQikxRVDx5cgy6jqKDVOnIqoJpCLIk5vLiiKSK0CqJdDLHViQoM7YODpmOpxiGSlLXWM6VglMqZIospi5hf7/N+jJHdRWSLEfOE2b5CjsvKPOKqEnomD6r6ZLE0ChTSLUGWWqoZJUij5kFGY6h02oNuJxM0Fs++XqN6ysosn4FrMkKlkFATUx4cc726JCMjOVkysnZGb5jc/F0xtbLLzCbPcM0h6gq/N5nfp29vRsIGRRJkAtBEoak84CXbh7i+QYZCmkW09ZdUASz2RxJknFNE0kWpFmOLCDJUzzPp9NykeqKi7MpmzhEigp+81O/zO1br5JvQjrdEWW0IVysmF6c02372K5NLhz2bmyjag7bezukcYomScTBBklTkRoIZytwDUSaoTs207Pn/N4f/AE/8Td/8v2bHbh9+3bzj37pn/Dk+WNeObjGPC9oShlNlJSFYH93h7PJJVm6wjF9CknGtk1kVBazC5J1iNl20DULx3ORkTg9PmJ394AoyQiDSwbDV/m5n/tH0KiEvYJNWLKaTCjKECN1+YW//xOs1hGGXDObLlguV9x59RVOHjxidPM6olGJ4zWWIpMnMePLKbc/9ApJkgEyRZRgmj6nJ8/Ii5TtnT1sz2Y1myN0BUdovPvuA+689BIgUTYVkgBNMUiiNU3T0EgK4+kYSzSUmolt2xSbBEkRGIrMcGtEEMXomkVV5kxXGzxFoFoGOirPzh7Q7fZJag2zrqiKmI2qIzUVk/E513dvsowCDFmhKSMMw6CuYRHEtPe6qHmNIWucX0Z0NY04mWJZBhfxhiqrabKASm6o65LgRGHnjQl2NuD+3a/wf3zq1+iNrvHx7/x+7r73Ht//H/0gdRShOxaK3CfL1pyPV0h1jeFopGnO5OwCr9Pj+sEhlcgoT08Z3nmZ8WRBnIHnaYRRgkVFY1rYqsoyWFFlDd1+i7gsSSuJMpvQtruUcU5vNOT87ATLbhPEa144uMPl6QPa/QEXF2NU28TvdAmXAVmt0KwvwTZZnDzBaQ8xPZ28NrE0Fd1QkVLYBHPWBfT6HaoqpwhXeN1tTk/P0DTtStSTlpRmRhnX6LrNOo2hbmg5JufTMTu7hywvZ+imQZqXnF8ecevaNZ49P2N4uIdVG8zX5wwHh6jkQM1kGaJbJkWa4VsmQhNsohXp5QS5s83Ad1hUJbYsIes6jZA5eXaKpql4ro2oU7p+j5OLS/7Wf/1f8fT517cE3hcxgaZqKMMKVeisKFitluxs7XH26AG7L77EH33pD7nz+iuoKFRSSbvloigy9//kLvs3DpEVFUUxMFWb9XnAJg3whl2m0ym232IWSHz+079Ko1vkGlRBxrbqYDuC+eUxqhwzu1xyePMFHt6/y81bL3B5MUETFtdv32KxDlAUhSTJyIqcD7z+Kna7TZlUlOucShLUssR0PWfvYJeH77xFLUEYREhSgybpBMGavf0DUAXHZxPaloyrm5R1hYKM03aohcSw6zOdLyjzzVVBiV5QCwnTahNlBXEYYfoSdsvn6PETIgpMw6OWY4qsZjZdsb23RxotMHstWqjkUok8F9za93nrXoBsKARBg5JXKN0WI1MjXW0QdosyyWj3TObjOZXQGPldhO0SJjPSyqXXHRJHG0YHGctLn9KzeeGbhvyAsc0L3/oRtFzhxQ+9jJarhIaHFZcc3u4yEW0uH1+ieCqWo1MlDZZTcX55yoO3vswmSTnc20J//hZ7L34AyemxGocIPaEQHu+9+Rat4ZBOp4XeFEzmKR2nQjUcHp0noKyJVjmPZufstfe4OJ9g+DrHsxOW6w2V5tIIhXtv3ePmndtoskxZKlSVR7ejkaX7bG13mR8vaW8bLC4WiK0uaZFwmazZH42o64ooisg3OWE1YbMpaLmQhmvQdPRcYbaZ4JRQRCG94Q6r1YJ+v8/k4ogdzWJBg6LDwegARbsqRZdRwMrZDQ00Q+P89JSdg+u0hU6cjem7W+RazuxyRVylDAY2paIQkRO+cx/r297gC7/+u7zxHd9Ou91C13Xi1RpN09FMA9v2kRXxDfff+8ISuHnzdvMr/+sv8/zkHFNImEKwlmWsJkUua9aVwNV1hO2wv3/IyckJiqLgWDqqKpjPrqLotqcSJyE2LkfvHXPttVc5ePEaaSFx78kxv/1Ln0IdtNHSkjgIqRR4Pr6kqXJ+5mf+OqrtEAQLJEUQ/d/MvWmQbOlZ3/k7+577Uln7rVu37tZ7a5cQDJgxIJYR4bHHJjwfLAbbwyZgxgIxEyHk8ZgYbGwhjBEBBnvClgeBcYBGKw2oJUS3ulvq27f79l2r6taee+bJs6/zoTpiCEeIYfik/HIyz/ueNzMi4zzxnOd9/v9fENHr1QinATkCUZhiN2pMxgOKUqbu2KRBiGjp6EWJFyxQnSon/T4Nq0GWR6x11xnMzq2yVVlkMJqgGwrzmUteZBi6TRj6iJKAP5oiipCWUKnVKBPvXFtQb6HoGv7UR7YKsrxkfDRC1TUEo0DONKq1JncP7lMXMvTuJk7FRC0k9o53qTRbLB4cYax2GJwc06418BZzglTAMU2KNMFuGchlhVTwsSstFFHAT2NUAXTVoBQSWlHBKIVAllApcGdzTMshyxPSQiJajHHsBuM0B39EzZRJ/UMmyg5CVGBW4fD3P8Hl7/2bxFHKIuzTW7tCSxIoLZM0yxAUkHyX3oVHmPpDBq/eYP2Rx/nMM19g/9kb2Estbty8jeXMcWqbbHRtJnKT9UqIrHVYvrrD67uv0JCbZKMxvcefJE1TcjEmmchYtsrpwZTMCJEKkeWOhaBVEcWUZCFj1y3G7pBkPMdZWSVcLCiCEFGVcbOMXnsFW5eZnE6xZZGTYIEQuLSWl/GLmLZuI4oyE/eYLFVQGjWUOGc+dam1bIq0QDMq2KbA/b0jlpeX8dMcqYQiEanaGalhkEigpzn5yMNyesyzE7RSIVBAFTSMQiSScmq1Bu7xKa4EelpSaTq8/Gcvsvn04xSTMbKu0WwtMZlN+akPfoDbX6dP4BsiCFzZ2Sk/8s9+HWwQggLLstARzjFek5CsbVL1AwRVIEVH0/RzocpsRlwKVJo2llHl5KDPtbe9BakMKHwX2azgzhaUhUqoZRiBzkc/8ttU4wwdhYezMUYZ8Jr7Kv/bP/4ZBE1h7849tnd28OYeRcuAgY/iR6R6QSmoBG9gtgVkMmJqqkOIQLfX4fDBA8ajOU++6THm8wneIkcxwJ9MEIWcZmcVxTIoUp80i3CnHpoi0ai38OOM0WiEKeuMpyN6a+s41Qbjw0MyqUBTDaQiJYwSoniOpNe4/eJX6V69iFxIZH5EIon0TIFMdrCrDvsHB2hZgLm6xJLV4OxsRK3T4ODsjGZeoHU7hIGHXMB/+tV/x8ajV3jk3d9GzdQ46J9QSeaIcsH8KIHL66iUiLHAeDrCrFQpybGVFFm0SeWEht5AQCZazBEUBX29RxCMcB/OkbQUU7C5+/AOp8cub77UwNm4hFwq3D05oCIYqKKE3RTOW7K9HEFwkIMH6GadIJTQqjZGLeP4foxXjOjVLHSjzdHNL3Jp62moWkzmY3xfoF5Rmd94FnP7GvvPvczqm9/F8y+9yKi/T6ZqdKwGtZqCeSllvD/n+pu+iYawwd7eAVYywd5ZJZ+meJMRtbU1hgfHrF64jJ+GnM36OJaOZtgE4xlxIXF5a4fhyUNq3Qbu3KM/GbAkp1i1LQ7DgCVLJ5UgdRPanToHJ1N69RqT6YhK2yJKFZJFBFmOsapjShrTwz5BrcemJZF7MX4eEMcpZSqDKlNp1DEFl8OTMZbdwKmaxHHKzPVZ7jQoyoQozFAFjX/4j36UO1/HT+AbIghc2t4pP/5/fpzFaMA4SrAMk3ajy/HghIZTx59PqHZaGIaBH3gookywSKl1O0ShR5KlPP30m5hMpkSBT1GKZFlxjmEqcvKyIEky+kd9qstNPvkfnoGjBYYFfpIyjGf8/R/9W3S7TU5HZ0SLOSIW9a7FfOJiVx3y5Jymk1JgiCmRoJO4UxrLGyRpSDz38D2X1tIy0/EAUVAQyoRZWrLR6ZIXCfMwJg9CLD1CcFZQRBPbLBj0H2KqJorcICFi0h+yemGDyWyMU2sRxQGGpBAvpsyyDCEUkWQPxawhqyZ5XBCMTygKkfraBsOjuxSphNlpER33Wbm0hjedMzx+yIU3P0XUH+OGKVanQTKbEngCWeahmRad5R6e5yEoOcEiwLIcRkeneGlKx6rTXF/GHYzRbZ2j0yOalRaCIpOGAVq1hpKVpLqIounEC5+oKGjXTD7/8d9n51vejJgkSIKIE+WczH2qLQdbdJBaIkoJWQK1bo+Tg4eUiYi4VEGIIz75b/4j3//DP8jZ0Skd20Z1VLyoxB1NkAhpGQaj0YhS1BCIqDfbLNKIcDDCbtbJcoN2p07/7B5itcLZ4Sl1c5lF5LO8soTrzpCChKXtJfJEIBcLNElgNg4QdJ3h4ginKTCZjaE8JCgKNlubxNEZg+Exzeo3E+ovIWUW0Z7PTK5S1S4SLu4RqxbT05CN3kU2VpbwC4WqpJIHEwK9gZykLBKXaLYg9SKMmk11tU3ST9Fti7TwsR2V0dRFERR0W0cO5iwKGbuhIqUqyDrLax1u3LyJg4i+0kXNZXxvRs9U+O9/4n/6uhiyb4zdgV/+1x+6un2Nqu1QazdAAC8MaWglfp7hez6mYyJSEIzHaJqMJxeM7t3l/f/jh3nfj7yP2XxOGMWkeUEcRqiqQk5Gq1kjKxKQoNtqEPsZc0lEVSPSNCWIfcLc48LOyrlJqSDgeXMa1SpRFHB62kfIC6I0xY9dlhoOo+GERrVFGM6I3Ag/DFnEAYpuU2/X0TSDeRpRZAXtusbk6JCtR65xdDBg58oWXmYhCQLxfMRB/xDbWUVLTUaxi6RJVCoVxuMx9hvZTrhwqZsWcZBSqhrkCbqoUeYikqGxcGdU6yaRLGHZBnqSkpk6Wimj1xsMhzMsp0KQluiCTjqdkzVtVFEh8DP6XoBtKURhwNHZhDTPsCQLTbPw3IBKo0JY5CSkiAhoFRtNlhEkgYrhEGURjWqDLPIp1YIy9gmCCF1VmAzOkFGor7cxg5Qog7pjn7sYN+qU4TlGS/Y8posCR7M4OjwmyWXqtsDZyTF6IrJ8+SLTu3fZsGIuX9ogOBny7Gd+j8ceezNJDFBSqTdJCpHm2gZRKeEtImTNJK2YyGmEn+bUaissogRL0dEEDbkUSNIMWUiQGxbROCaLfAJ3RpqDVMDUHTEdz2npPTTRQfZkuuoFioGOXNnGEC+gxjqV9HH0pIM99XnsW/8OS1YFKxLZvnKNnfUdrj5yhdybUqkqnJycsD+YsH/zFpoqokUhGBI7WxuIUkSfZ1m7skwa9YnKGYLYZjLukyYJdsUhWkypriwRjiHLE+o1DXfmoukWqlgQ9oeozTqpIJIkKZ/9w2f40R/70W9cAdFH/uW/+ND7/s57qVebTMYzFEfhYrXFCy+8zFvf8lZEw8AbnlGpNylVjViE//WnP8iNLzzHxbe8k8nRDR59/GkKNadISyzDoKAgTQv6/RlCXhKHGQgChi0yPBsT6hrTyOfUOyF1FzS6FhfWL9JUdcIko1JrcO/VL9FprSBVHeqVJkmQYZsOkSwRpymjsyGVtWWSscfp9AS5UDl+cIBetVDKklxXqTgNjGabwdkCw1GYui7Vqs34dES7XUcxLTzPJShyVElC1y3UHLKypNpqkWfQbdY5GE1RDIlmrX3OZYg90ASC4SkXe21StYmu64TTPmZtBd22cN0J8SJga6uDFgeEecnpyQmlIWHqFcyqzf07t7h8dZuq3Trv2hNKKoZFlgdYFQvFNgjcECUtKFSNbq3GWX+AO5kSFQJ5mdI1NPaOziApmUZzDNlAk3QKDXy/QMxLwmkfR2vh1E3SMME3DZYqbaauh2jYqEaNMotAkjHNlMEsRrd1WvUmc29IvV5n//SEqiUxTmXGRoudK9cZjE/pNmrcOznAMDUevnofXyuQ4oLIT1lZbTIehVj1Cvn0FKtSI/bGLDIFwdGYTh7y6FM7FKXK8N4+9c11hqcTVrauUmYZYiFhmm0q1QZlDjkyERZmnJAgYCDQNFcRDRtRLEkKEX31MkcnQ/BmuJJGTkE+HLE/ivGKBQ8P51iOQENysCs1KnUHp2rhDj3kqsn2U0/RErYxzC5LZg+zu4aha6hqDduxmA4OmYX3OSnuMQ6mzLJPkesqeze/xk/+g5/i7d/+rSTpAsdpcPzKq7h+yBef+1N+/P3v/8YNAh/71V/50Jvf9XYGoUur0ebs8Bi9W+XipW32jg5ZTF2cqk292wJBwQ8Snv3j53jTU0+Q2ys8/5nP8MS7vpkHrz5EUiUO94+ZeRFpkiKrClGSIMkCWZ4T+RnuzGX//j6v7z2gUl8m8qdYksC1R6+S6hLj6YStrXXKXKDwptQaXbIkwrY1qo0asZ+SlyWOZiCpMogKdaOkWm9h2BXyLKFeb3A2nKKIMmmScdo/QSpLiiTFn01RbZMojjnZf8jq6gr9QZ/eUov+ySmqqRIsfIS8ZDY5Zjaf0un28P0Q350xms64uLpBOHOpVtvs7e7iexNUsQTBQXMUAjck8gLq1SqiWuG1B4dUW3VazS6ZIGDIGqPxlPXOKhk5FDGeF9PstImCkNpyj8FwQuL7CIJILMJqvUGw8BBFWOouISki7XabYeCh5Sl995BWo4tj1vBJ0MMQxzJo1C127xzRfWwDqchRZI1avc5oPCT1pkgaLKYuigQiIplqYVJQiDKFqFDOXSqNFoWkkNbXODw84sJSjTTNeLh7hG3nWGYbUdHZun4ZMQypVByWV9qMAo/l5WUqdpXxxCVME5SkoNpoEfg5reUlVKHGnVdfIxRt0jjEdFS+9PnPEkUlmaFwOj2laoo8PD5iNp9Tc2zWL18jinWU7IjFwxHqSouzyRTZMsj9kKWOjVppcnA2oFZvoWNy0D+lZjSwBQenUSPTdLrryxhpTqYIaJaCpqUM91MS3+fuV1/i6OEDbHuDYLEgco9RBNAtg9XeFbrWGuGrZzxx/W/Qcjbo9bb4vvd+L1tXr2BUDIooxc9Ujs8e8rUbN3j/T/zEN652IMsh8w2c1CBfuGiVCs/96Qu8/LWv0XIsZu4xB7v3+Pv/3Q+Q5BmtTpNbt15lrXmFzqUqcpExOtvjwiOXMHQLy7HRTI00zRmPx8RZSRynhEFCkuaIisgzz/wJ3eUV1ChBqrQpE5GvPfcS/mxMq17ja6/cRJQtassXSJIU09KJXJf5QZ+pOyfNYxIhwxv3SfIIuaygSaCIIRXDRBCg1+qgqCBLKdevX0GR5HNarVknDgMOXn+FRqtLHKfohsbCjc5JvLaJUjWYBwsUvUJ3eZM8zZElgXrdoSDj9p1XSfMI2dTZvPooV65exdB0ZE3i9u3bjMYDKu0m6BHHp3dZW1Up4oTFdE4RZ8znc3Z2djg8OiD2M9Kw4MLFiyiGee6EOx4SeQs6tkG9UsUyzve+I1ni7v1dJEnC0FX2Dh5SxCVJWrK6fpEwynBdF3fYJ61ZSGXB4OyErWs7KKVAUqYkQsbe3gN0w0ZSbWYTn53tRxkOxxSCSOQHmFYFbzpHKwTyQiYOIyxFpWrEbDRMnvv8FxgMTrj++A5pKWLWFmguAAAgAElEQVRWHUgyjl6/h9Vt4rkLPverv0jRP+PBs3+IP+3Tu7BFtergxxmiDIoQsFZVSP0pyyvrXL92kQsXLjAYJbz3b7yX9ZUVLm9s8eS1a+iKzZve9G4uXrpGEStM+kNev/MCXzk5N76d3b3N5P4+w7t7PPf8V3j15m1c12Oz00CVJSahR5LOSUsBljXIC+a375OMx1g1G0wLx+pi1a8j12Ru379H69JjdDs7WKZLxVAx6usUhUmWShzunjB8fULziSs8f/NVDvb3eXDzPnmhcOulG0gLEcFPWDJj/utv/RYUVfm69983RCbw0Y/80ofe+x3fjdm2uH13j9XVOtcvXMSxVP7tb/w2X3nuz3jl5btsrm3zvd/33zCYKbzwpT/lF3/5n6CIOh/9nU/y/B/8O97yjveiiBF/+mc30TVIsxLXnePYKoMTj+PjQ9yZglmTcYMITSmZTyNMXeY7v//bsHSdhuNwfOcBuWWwVG1werhPiYiIxMXVOhNBwdRgMZ3hWDJhrHO6v4sbjGnYTcZhzGg4Q1ZKZFVGQSL2Y+qmjFyzWPjnSkhdLlm/tEU0Cxm5Pq26Q5glhKdDSkli7sXYjkqcFcwWPmJZsAgiBMtEWuRIDYMygDCIkQyLfDJHattkp1OW6jLDKKfpVIgmDyiKClmpI9k6hqpSdyRU1UasiuS+RMXUCIkI52cUsymNzhLDAKSwYLCYIuoaeZrhBSkdR8Rod3n5+Rs4tkPDqqKYOosgwDAswoVLPpvTn/sUbkqaZVQbDTKhhDRBMpsMzw7ZsJc4W5ygyjKmUWE8OmX1wjaL6RxdAKtSQTZkJFXkeDSh2m1i6Qod1UCqrGFYJs16mzL2STQNOUjQFIGiZqEECZLt0HryadzAxdQs3LhEN2XimY87C1hZXmZ0OiXNZNBUiD0ocvq3dzEevkKx/QR+5nP3ta9gylWyRCQlxHQsUqHES0o2NmtUZR2n26N7aRuz1sCoqVy6dAWrVDjc26fVXUYsS9wEMs+j0alx/NzzLF/dwvV9XDch7S/wTIHJzRvEQsHB0R7r7U16KylFUaBYK2hySRRH3H3xj3j7d3wP3XrBtB8SqSpXdi6hiQqlY6PbbSauS/+1m8RmDf/gPubyGp/8vz/Fj/34N3DH4M6lS+U//fn/gwtLPR4+3OM3fut36ba6VKoOtXqDqIzRYsjkHN+NWdtc4ZO/+/t803f9V2xdfROFqfI/v+8f8rHf/HUWUcB86CMbElpZULzhLedGEUWRkIkq7uSUxTBhNBty/2CfPB7wi//05wjdgCRPaFVsRoM+kaQhJT52rUXqzalXHKorF9i9f4dmu8PRwzNayybjo1MEo4Iui+iijGbrzIdj2t0V0BWi8RTD0olFAVvSmUxnDPon1HvLaHKO7jRR8ojhPKSeJgyTHMWuUK+aFEWBKCsUSYI3meBUbeII3GjC9vIKuSySyhJRf0RHKjix6zi5TKHJGJrG537vEzzyzm/B7Y8wKhq5G+FsrpAlIemt26y+6+0MZx7hnRdRNp4gdj1yWaRXsxiFEV2ngl2vcnD/PvsPj3n7257geDBHEETSLGAwmdKrNWl3O6i6ySIOCcZzFFNDLGVev/0a6ystFL0CRcb8ZICXRzRXVxBEhZZpE2Up3mwKgoQqicyzACM5NwsxVJ3BaERneQmlkAimAY22TRKXaJpALOYkCx8vDOj1ehRxztHkgKXKEk6lxtFwRK9Rpz8Z4agmB2cDllY6FHmIIhtIBQS+T16UBEVCq1blwemIq5tNJLHG6ckh3XqTG6++iNXs0mn3yIqERqtF/+g+lCqybiCVIfPTOVutKgNFJR+NMasWYaHQatSYzAOmszHtbpd6yyEcZaRlwMHhPs1eFy0sKeUI1W5gRhnhbEax2kESFbxJTCyHNNQKRQGlEJDlEVW9y8ydk7snzIKC0+mM9soSTVnEo0BIclLL4bd+/n/hlcMhC3/xjbw78K8+pKcqn/n8lxgMp1R7LeLcg1RAM8Afj5FNndWlDt3lNjdv3OL13dd5+OBVnnri7QxOPPqLMb/5ax+mW99gqdPicDjixos3oczw5yEZCYtZzFn/DjdfvsnZ+ITh6ARJlfgXP/szrPWU82hfQqVdg6Sk1mqhyCJ7Ryc88tjjoKi4wwN0y2E2GLHzyDZFIXF2eIZGTM3UQbcwK1XkLEM1dbKZz83929hGlYXnUak5KBUboQRFM6gZNY77Q/LQP+/9rlbY3Fwj8F2i+QzNsQhdD3dwRlmxcRSdQpcxNZNZFpMUAs9/+nNsPv4oRs2BeUCuCbzwx5/HbNo88siTJIsxzbU1XnnhZa5e7uCfjVFkA7Hb4ORwhFNVqHQuYlZkwjBB1hRef+0mF9e3SLOIXJaYzT0UVWVRlORJQZRnSFnJeDJhaWOd0eSILIqYLgJalSruzCUjx7ZlpFKks7xEmicYDZtWawVVA88LURSFqTuiTMGuWAiqTNVq4ScRjmZQ5BFdu45TqzKcTZCVjLa9zMl8SNVRkGIB0VCYTlwkRSEMS+pVm/t3d8miGarqEM7OqDgOu2cntG0TSdJQFZWz/oAijclSD9N2CBcB1VodSyzIPIH+fIqjFmRJQqXVRDcqKP6Erm4yOD1FETR67Q5kGY6qEck6gaQgBxlCrU6JjlHRmAyGiKLIte0LhFmEsIgIohGyWaFZMcjmCyLdol6rQSYxJaXVa7A4miGoJZmQY4spZydDIrlgtVIjTqNz+7TxlKXtK1itBmmcs9WtsvBTti5cwmg3MbyU9/zAd/PMM89+3UzgG6ImAALv+7Gf5K2PvZVbd0+4/8JN5DhHLFKSAkTTQRQ0+keHPDwaI6g6uqSxiCUif06eL1hf24KiTVZMGY/nSFnC9vY2kyjn3mTA7dfv8+nP/V98+bNfZD7PmM4HHNzf41d+8ReQ1ZTdhy6lqtCo1pid7PFg91WKrKTIJLY31zk7OmAejjDMNk2niiGXuAOXMvF45MlHqa1tsXLxMn4Ucvhgj1fuP2A0mxOrMb/9Cx9hcLaHScjt579EOBzRrFcJ44BJNsWpVsgVkyLNCSZzbt26jef6GFaVhRfSH09RqirLzTqTqUuRhKgylF6EISlsPX6d+7df59b9I4RqFbkUqDS7VNUmJ4M+Wa4gI/DOt72FyTyj0d08b4Oehkgy9PeHFEWOkInYVYfBySlXrlxjHntkMYxPhmiKil1rYZVgKSWWKIIYce3qZdK0oFvZYDIMKMIMPw0xUhe5lOhtXECxLOaDGagqYQQHJ8foZg1Nltjd36eMUjRNwQ18jg76lAIYhomfesi6jdypc3pwjOO00SSbew9uIJYR3iIhMyVkcrqrG2gq6IaArZisrvSot9fRHI1Cr7PbH3Jx/QKyIjKfDEnTjE67Rmd1mdRfIKQptm2Tphn1WodIK+k2GxSlRrvdZTCZkyYupaRz7w3upaJl+KJEKubnvANDI5zNqfRaqKVAs1NDk3XavRXS8Zgw9MlzAT8vsaw2R/v7pCiUQF1MoRRBKahrOhEihS0yOpuz3G7gKA02tjfYXl1nuggQUMhjhUKVCNOU0WhEp1MDUaGzusp8NqK/t88sSfGOQ8ri62PIviEeB67sXC5/5V/9Jo6Ws7l9mXd8+/ewdPHbWKuLeKMDhKzAaLbR7DGm1OaFrzyHYRg8evUyN1+/w3d+x/fw0qtHlCX8we/9e7oVjavveDdWxaBjV7n56ldIix6rKxV279+lfzbjn//zX2C1oXI2OGRz+yKD4YRG/dyd9uHDQyRJotNsMT07QYgWyBWHycmI9cuPkcgpmiDhhQn1qs3BwRHLrRajkzMkSWJRFpydnPLYY48xHw7oezM2O2sUuoDbn2BaNrqtUJQJhaQiqCJpGqPEKmUaYVV0XnrxBk889jTTxYL15WVuPPcFKkubBImPVEo8/qanGQ4OibwMWYE4TOgttRhPZpCKhKJHq7nMcDgnjwIOdh+wfuUKt55/lqfe9jZE0X7Dhl3i4f1dti5cIIgTdFXDT1OSJKJp1cC0WZzco12vceDPEQoRQamRZR4kGe16hcO7r7G6doGDwZB6t0uUFJi1Cg/u3GZJb5LqMloaMitFliybMElQKDgLPLZW1wnTHC9waTabiFlJXuYImcBgdoSkVtEkESFPiaKISrXHMJiglRndepN5cO4cHA6OmGYihupQa5m44zlxlKLpCgs/YmVtlWF/gGxJ6JKJISvEYokkSKhlQCzoTCYTGmYFTZUoERlP+udMyTwj9FK2L22wGE/P2Zh2jUJOaEgqt+7ss311i74bAwlFmtOq1hBUBUmVOTs7oSgKxof7LK1tY1nnxevFfIFITq1ZIwwysjxGQOLo7IyqJiOYBt1eBXec4QUBSibQ6da5+dorLC2v0+52ODkcUOYxiiLjJj6GbqMlOXFZ4NQqBPGC/t09/tlv/Cp3v07H4F8qExAEoSYIwu8IgnBbEITXBUF4uyAIDUEQPi8Iwr03jvU35gqCIPySIAj3BUF4RRCEp/6/1pdUlWuPrPJ3f+Af8J6/+fd49/d9E4H7Ort7B3zww/+ESX/Gd/z17yOfrbK0/hh5YqEJyyTpMuOhyK/9+sewdOh2bd79Hd/FN73ne3nxT77KS5/8HF/+4quUjUtc26qxu7/P//4zP8cn/s0/pl3Jmc13cTor4MdsrDXQNIVo4tOq1snjiELSKCt1lN4mjfY2nZ2rHJ8dI+XnIhghniDkCcvLKyRZSmNtg9r6GpWKxcXtTWSxZC6UvOXpt1JbblMVVRpLHZLCJ8tLFqMFo/t7tGs2lq2TSgV6pU5UKDQ6XW7efpXOao2kDPnr73kPsmpzuvcyB3eepcxcBElmOhmRUxKUGTdvP2C/f8b9oyMUxSZNUww5wKnqvOOv/TUajsJ7/4cfxE10ojwhyjKmi4CV7QvMw5DB6QmzMsEdjVCQ8YuAk93X8USNs0RFo0E6C1g2IZmcN0rde3CX9vYlElmk1WtjCPK5aWgSYRY6WTLmYsugNFWyxQm5ArIgMMkDqoqMrYmM7j1AzpJzBkQWM/FmTIMAWdcYjUaEcYwsadRVkyDvo6c5qV8yi2LcRUjg50SJhlpZIStCRv2EvBTRKy0KJGqdFoUo4JgWhmFQiNB3XaZn+/QaLRLBpFKxaba6TBcRuqkRCxlFtUK1t8TO8iqX1pbRRAGhgFwSGM49/CjnYTyn0V3l5HRCxa5hyVDv9fAWcwZHx+y9fJOWopOFGRubOxSiTHh4g/6Dl4mmZwR+xGw2IwkCgsAjk0UqVoW2UUVTTR6+8pCGqqAUIkNvytHREc1Gl8jNmAyO8fOMpdUuopTRtTQk/wivTEmKmDAMKfOMlY1Vvn4e8JdHk/9b4ItlWf66IAgqYAIfBCZlWf68IAg/DdTLsvyAIAjfxTm6/LuAtwIfKcvyrX/R+rVao7x+/Wm+evtrVM0N3NOQ5298GqH00TUJJzPplx63v/YKl7YfIQ4DjGab4eAAU1NIEoUPfOAD5FnJ5vo2p7OA6ckejZUtiiTm8pVr/Mj7vp8oD4niBY1Gh8VsTqPVxXcXzGYujz5yhf39fQrOtQv9yRkkBZZdAVnCnbms9HqUScrhw1M2L/RIhZIUmcFgQKteI45c2u027plHWHo4joVqWtx96Qara20avYsc7D6g3u3SPz3DajiYko6lqcz8BbEk0qzaHO7tIgkqUikRLWZk85jqo9eRFiMmnovkzdl54q2MhnM0W2MwGrGzukQuBkShjDtcUFsyEaOYfhxia1UkOWf33kN2Lm+d23aJOVGaYFpV1jbX+PIffxFMk+bpKywaW2xe3Mb3Qyq6zUF/n63Na3ijfaqr25zMZuSJz/6Xvsz2u96FrpjkeY4YeiS6jiUUpLJ1fq4omEzPaC9vMj4+wKk2UdQSIRMRJFiEKc2Kjp9AlMYYoseL//FTvOu938VwmuGLBY1KFdE2Od49RDMKlpZWMQyDXIDhcIggSMhihmM3WQQ+JCJLvSZ+nBLOZvhZAkJJs9k8R97FCyQvxdJUUkFGazkM75wSqxnp6THdJx5D9QpOwj6Ls4ALvQ5qs0EsQei6CLlMkmc4hopuW4znU2xVR3cqlEWGGCXkec5rr93j8pUtClFGE1VMU8YNfELPJ4kSestLyI7K3IsY9fsoso6i6tRaOvv3Dtna6pAHKq/efUCr49C1K4imhhhk+KnPIsixahXkIqAsUkZhQUWzSQApCkhEgZZV4cQd8OEP/xx7e7t/Ne2AIAhV4GVgq/xzkwVBuAN8S1mWp2+gyf+kLMvLgiB87I33H/8v532977h27dFyZfntfOyj/5JIP6EqVTk5OcKuVPEXHqKjcecP/pDKtQsstTa4d+tlLl9/muHxKcuXlvCjiDhKUVWdX/2tT5C6CgfePkbo81M/+cN0Ww61Zou7+7uYQUFpKjSqLXIhxPd9RFkljFJc16XT6ZDGCb1qlU/8/u/yjnd+C4ahM3MX2KaJnAQIsoXp6LjhHDOOeXA8xT+6SeextzGaRlxcazL3U6RcprPZ5ejOLkpdI01EvNmU7soynVqduTdBk00EQeT1e3e5emGLOHJZxCGSpGEZNeZFjBYtmEYuLbVGJhZEvkha+ETjOZ0rW4ilSLQY0V3dZjoYEYUjQs8nN5ssaT5GdY0MDVGIibJz2q0oS/T7QwzbII5jMj9h48IWy+sV9u71mQUh1WqV0/1D9KpInqvUhBwvCalc2GE+GmD5JfZqi1vPfwG93WOz02MqSTTjCFfViLwFruvhT8fUW03qosBCtpjNB2yuXGDv4T66kFHtrVCpNvEXHpKQE0x8duMTnl6/jpREnE7nmN0uyWzOw4MzLu1snf/mN5ydx+Mp9abMeBjQWW6SxyKmHJEVJUkikIoChqLgz10kTWO91yZ0A9zEpz+c0a7XSdM5vdo6Lx8+YK3eIpgcIE0DhOVN9JaFt4jP7dM1gRSZZqdNHHrkUc7Z+Iz13grufEql1ULwJjz35efY2HkUvVGjYRp4wYJqvQ1FRpzm2I6JJEkc7z0giEqWL2yQezGGZZKLKSElydkRFAZa3WDeP2Li5mxurJFoDnI4xXDq5HGMphvEecTx8ZBeo87Q91Glgmarw+R0SKNS5cd+9v28/ldVEQqC8ATwa8AtzsGkLwE/DhyXZVl7Y44ATMuyrAmC8Eng58uy/NIbY88AH/gvycSCIPwQ8EMA3e7S01969lnCeU4w7VPrdRgc9xnORlx+9En2D06oV0wcQ2OehDTsCoPBjK6WIXWWOLp3hOfOGA766NYyL41dXv/sHxMmPh/88A9zOphzsVdHjEpKy0BT4Gj/Hk88+RhHxyGaKaBRJRrfJ683UGUZ13WxZBNBV5CShDLweJh7VPM2Vl3CkTUGixl3797lys4lptMxl7avUZYl4/kI0zZ4cO8+6xsXKDIYnZ2e/8EC9BpdUOHg7i5KxaIkQ5clNNnk7PCEC8sdCs3ADQMEScJ0dF5/7RatapPhfEYvHlC7+s0k4QQ1W7AoRKLSwJLnOBurOGGd6fyMQpYxLYc7r9+m3qqgCgKyZBHgI0bne9C1aovd+w9Y6fUIkhDZMEj8ksX0DNOusHV5lcODUw5u32P9yiVUw2Q2n+Pevs+Fd7+T3Xv32dxcZ7IYMz5dsLraYHd3l83rlzm6t093eQNRUrDUhDBXaZoNBkdHSKZD7PcxV7poYoYW5Ih1G6lQGffHiIJAtV5BlSVc16Moz8nUqgaKUWU+OIW8oOI06AsJViYghAKZlWGhUSgK09MBaxvrLNIZZDqVZpXJ0QhBV8glHyKNlIw8CDCrJq67YHx8jNPqsbxaRUNh7seocU6oS8iKQOkXyKZJmPgEiwgt9yhsG0lWsUyTvBDQJIEyL5iNp5RyyeXL13i4e4ReUTnb26fZWMZuNyAOEChY+DMG/TmSWHJha5tIk1D9nMlkgrXaZHjrFpHuYIsSGQJ1XUHEICgTWgbMMpG6oRMXJfPAw9EtsvRc6eGoCpG34P0f+iC7ew/+yjUBGXgK+NdlWT4J+MBP//kJb2QI/78qjGVZ/lpZlm8qy/JNsqTwa7/+cT7xyc/y5a+9yEu3XseXRMxqjQd7hyhixsULW+zvHZO5KYkfsnNhnYfzjOl4gV+ElLrG9iOPs7ZTxx70+dmf+Xv87e/+ToIH+3zz255AKQpayzUsRSFNCrrLF3mwN6TIPRYTDzHfp7J2hcANCBc+VU3j4HCfyWiM6/tQNQnu95kqEVbVYRH5LDyXyxe3SeKSC2urIKcoVglxjDeP2Fm9RDkL+PIzn+HxR69hWSa97jJHo0M+/bu/TbXt0LAdtlcvEQUSkiLz5FNPUCo6cRIShiFZ4JEHGU2jRnu5Q6vVIVi9glDO8bISjAaKatKwJBrLbV76z19mPB0xS1LyMuPhwwPWl1doWA0UrYIXzbGLOqKuotcaSI5Dc2UZXxAoNRPDNAnCOTtPXicRc27c3uPG7i47Tz1NkkRYQk4jyzEvLTOaDLm2c4mD+7soWUm3WccxGqyvXYJ5n+vXr6O6Q7Joyt3XHlImLonvIgsjuvkuvV6PeDzl5MEMNxe5d+Me49EUWdNodFc46Z+xe3gIYolgqBh1m7RUSPwpbpwRCpDbGrVcRElmGGZKRVMoLRUhmrO8voyinjd6qZpAmkWE4QzPc6mVGmn/EHn8EE3TQLFwVIvtp68TJAt0Qefu7RMEQWDv6MG5maldQaubBLlPsBhhlB71rYvYmoUtaZReQBJ49M8mCEWJpql06238yRzDVon9jAyRLPVwpxPG4wlhKaIqCvncY3NlE0EQmewdEaYJZ4NTzk6PSdAxlITGcoelXodqvU6ppGTeiFC2SUWZ3NFZjM+wFAk/CtFsHVU9371orbQQ/4Lb8y8TBI6Ao7Isn3/j8++8ERT6bzwG8MZx8Mb4MbD2565ffePc133phsr6ap1KpeDecI8/+tR/4k+e+SM+/6k/4Nk/+mM+/dnP8LHf/A32Bkc8+danube3x+999nNUWw0++5//AEFSiZMMd+FzNAt47KkLZHsLHvumK7zyqc8TTSaUukUi6cTFeVtrnsbIgsjp2Ywg9XjhU1/j3hc+h2aLKLpKHGV0ux0urm8iqhpDH1SrykU5YtwfYmsyne4SVcuiWtV4eHjG2fGQ8SBkkWaYpk7/4S1CAa69+S3cvfOANE5YzEf4i4zv/dt/F0E0UaSSIJpTXapTrVZ58asvIJkWtm0iCSKpIDGcLehs9vACH+YBdVEjGA4xhQK5VkHWDfJCpPC6rD/9CI5moWsGhl2j26yDFDNezDm8/TK6YxCXI2pWnTzKKRceK90OFVWiqsnIecrOtR2iMEORReqOTbfq0KnYHJ/MMJpNinadZkXn+OYNJm6ftY1Vms02lZbFwpugGxLziUzFsBCXVpBEk5XNddJEYJrGiNUl4s4Ow9mElXoNco+Oo/LIo1fI84Juy2ExOGap3cE0bHx/zOSkz+jwBDVfUCoKm70Oo+OHNHWJrYvLVNd7TOMEWc5wCglPEEjEjFLIiP0YwjlZ5BNnCzRLZJGVbDx+mcqV65yNT9DISMWcIoj55our+L7P8tUGaqNC88I22WhAQzEZ7J/y8p9+hVa9w/LaRdLpFN/3mScl1x95HIqSTrtGkac4tSqq5bB/7x6ZkLFqKVx+6jp2xSLKI5a2VjjuH5OnBVtvfZpB4TEeDVnq1Am8AVuXOjipwdKSTXg0x+0PGJ/06Y+HBO6CSm+NyWKORk7sesyDmCjKkBQZxTAZTBZkp/cZn54Sx8nXvf/+soXBLwI/WJblHUEQPgRYbwyN/1xhsFGW5T8SBOE9wI/w/xYGf6ksy7f8Retf3LpYfvSXP4qaw2w6JC5z0lxAnQQcBGOKJOLilSf5zDOfouM0aK2scOurN3jsne/g5a/cIogGPPr0NZY769z6/Gd4y+NXMW9PubWI+finP8O1VptWM6JliVx923/LtR/6W9z7yqusXr7AeOLiHx+yvn0JL1ww9QNWlzqcnZxSorC6scrg5BjFsmjWGxT5nGe/8AJvfvvb8LwFqqIQlhFiliHkBW9+21t56YVb2KbOg9dep7rSxT045uJjT2GYMvP+AMEwWIQRuVAgzwO6lzaJ5z5F7COYVRq9Fn7/jLSUIEl5+YvP8PZv+zYCRedsNMW0FBppgifKGLrK8XBBfO/PqGw+hmbX0GyD6TygZkvMJz5200EpJMbTEUZZ0N1a5ysvvcrO9mWUIqfUZNL5hInnYekWjipgOQ5hnJLqFk3b4mw6Rs8gFXNkycAdT5AMkS1dQVla4uB0iJSXpHmCJKucDoYstRuoskB/6iOXMk63guDH5OmE7vJ1Fv6MNBegDCgzkfFkSKO7jExOKehoWkg2mxOoOuE8ZjgcsrW+RbVZZe/BAYqlcXx8zOrKCpYiUJYCmaSQkxNMF1gVB5IEyRQpEoFer8fh5Izw/iH29io1QWEcpjiSQVLG52KlrCANPGrLPU7u30M0bSShpOG0maU+0SJEkKFWtVGIOFuUbHWWuDs8RRjN2L11h0e//W3EQUnDEZkMF2iFhFJ1OD4+RlV1oiT5f9o78xhJsry+f17cV0belXV1VVf3dE9Pz9kzs+wuuyyrxdiAMJJlsMA2IIyFsZGFjSULZGFh/2PZsiwQGIHlQzbCGHxgc5jDzOK1vDs7uzM7V3fPdE9Xd1fXnfcVGXc8/5E5MKxn1yw7fchTHylVL96LivfNfJG/fPGLF78fZ05vIDSF7Zvzh978yjzzVKvio4uCJNc57A7BFjiqwqA3xTIllq6hKD5+xSVJQ/IwxjAl+0cDsOb+nbLjo5kKlucz7PdQBfz4P/xxbnyJW4R/3BiDfxP4xcWdgZvA9zGfRfyKEOL7gR3gLyz2/e8LA3ADmC32/bIIIZhMAqSR4/pLBOMhTlVDtR2eLJ1nsHeD2kqVbw0o1usAABwJSURBVP34J1A1g3EGs7UdDq5fplJ3uNi8QB4ovPjp3+T6tR6/+uJlpkdv8lipxkc+cpHZzgG2OMVzJYOND57ntatvEGczzhoqhwd3mKYz/CQmJ+bcIxc53N9hdXmJ470uu50jGtUaaThDEwp7RwHPfOADHO7uYXQGmA9tIYKAUWbQai0zHgmaK03CSYBVq7C82qKMwXH/kFNGk1RVyKIIXVdY9ZcZ2xNc1cTxBTo6252YnVfeZGu5DiJHrRlsfvgT7BU5stNlY71JOAqQtVXcyZDxYELZs5HPfD3TSYiDYLi7iyokh4MZ1dqpea4B10bicPbxh7j11nVKnoljC/b2jkhyQVU3qZd9XnrxVZ79xDfSCyfYmkMuJW9efhPTLxHrBfvbR1x6/CGmyRi71CAutdi+tos0wQ0jUsNklgSsrG8SBzOirMAvezhmiXA6QxER11+5wjQwwVLRTQdXMRGqwCnV6bZ7MB6yev4M08DEc9ex8ym5IXjoofOE4x57211000TkGWc31ii5PoN4hldyKOU2eZGhlnVWa1X6kylxElKzFUbTCaXE5LdfeoVv2zjDTnvCYHzMxqkmhaFTcnSi9gBpSia9HrKIWW+t85nnfpfGN38T08t7XHj0MW5d2ydjl4QqRhbS7x9QDUMiv8SjX38JS6kwy2+AcpaSPsVzShx0+pw9vYU0YJZFrK2s0el32Ty9TjgZoyQKRsUmznKkWebo9sucuXCBo6M+2izFtMGzKyR5hl0zKYBgGBDmAhGMsdwKmxtLXLz4GJ/8rd/Dcn2G7TYa0Bt3UcRXmXxESvkK8Oy7NH3Du+wrgR/64xz3bfK8wBUm+ZtXUS48jG+r+KoLVUmWZvitDSadIZpnIqOQumsw3jpDtTegcWYTMR3y0hc+gyZrPPXxFZ4EwugJRt2QXNE5++TT9PIR9ddvomkaVz79PM3VJW5cfpPXPvM85z/4JMFgxHO//Rt8x3f/ZaIo5NXdXWqmizEVZDJCKdl0B30oJNPhiKN2m0sXn8DWTQQZ5zcvsHt0QL99RJJnZGHOUnOd6TRkPBjgNasc37hNdW0ZRVewS2v0jrfpDLvY2nn6wZjTzTKtespDm2fYP26TRzndwYilZo18ljGSCZNxhC1NptGALAxQG2v4vbewmhfoyg7xLOXcxcfp9/v0tq9SanjkoWA2i3hovcKtvZsouc7q0iazSUIubSwLwtEMr7bGhz/wLLfubFOr+/ioZMGYjVNrdEcDgkGE7wiWV09zpz8lH0Xs7lxFb9hUYpe+KjAVDU1APBmRjCcYtoqhN7jz2uv4588w/MJtmk99HQUDqkqJwWAwjxgtBJq3wtnTKxzrKpMkI44DxkOFTMyfshTRlJLrcahELNse3f6QzniKYnoYqaCsORxMe8g0IYwTZorOm6+9ROOR05iUsXWNkR/z8T/zp9BVnUZDoV5ropXLRKOE/jBCyQ3WttZJBzGK53E4DTl97hHUUKOxfpoomtJYtpD6Okl0RHGUE3kqwnTQ0wlmuYWSZii6Q5bNGEc5EQHNzRVmsylq4pLECsf7rxOnBkL1MFydTm/CptikGG6Dcovlc1tM8hy1VGZmSzylYBpMWPJaGEjcyhJ6LoiSGckkwG2VeWu7zZ3OZ9DKDraqUFQMauunUF5LEV/GCDwQKwbPnzsvf+EXfgk1TRmOp2R5wlFvDz2D5VqDaRJhuw5BHOFoBpMwwS05HHcnGAy5eb3N2bUVjqc9UMGTOp+7+llWW+s06qsowz7dWYK9VCcaRTz+4cdZ8pqMJwGFYREettl68gmC8YDjQQfX8AjiGNO20OMEw/N4/rf+E1/7bd9Fd28Xxy9TrtaI4hDf0ZlNZgjdoN/Zo1wq469s4Kom08kxmWKiSIVpJnGVnMPDQ9LxBGd1FYKIkpUzSXUs2yMXGXmUIFILqcyI5BjDrGKYFrqQNOtLDLsdlFGMWKtxa/sKzdo67c6QUknHcn20XGIYBp3xEA2BUmQorsNsNKXqm9ilJQqZEvc7TIucarWOoWrkUmDZBrf3dkninEqtylq5xp391zErLfLuHtWVxxjFAa6m0TnuUpgazVqdoshICkk0GKN7LiXXRas5DPf6DPoH5JlCtVxBs1yKOGUyGVFdqZAE4TyI6riLqboMw5Cq5xPLHAtQhUKWg+arGBgkRc7ezj5nz59BQzAbzyiSEaZeQbcFR8MBFadGNLhNmik45SUMWyVIcgadLmfObzCLJa4oOOi1yQMbzSzwbJdZHhKOepTKLVQtRFc92qMu43aHzZUmheshU0k4OMA1Kmirq5i5QVzEDAc9guEQv+yQ5wb1Ront16/S3FxHyTNCckx3CUOBSa+HEJJUNWhVarQ7+4RJStmtYToGpVqFIovo3L6Dt9TitReucumZ81h2ie07N6nXmuSqYMkT9I8zzJpHGg3YvXOL8xcfQ3dKHLZ3SQ/3mKQWg+0OH/qzH+cHfugHeetBjjF48eJF+ZP/6J9SXVvGMnWCICRJc/a3b6PnKZW1FoNBD8vUGU9CqqbK7e6YtVodoWqk2ZSwyOnuHtCo+4ynKW7VZnac0J8esbzRwvAqZPsDqmvrHE06PLyxhSIsbh3t89Fnvga7VmHSOWCn3aHmVkmKnCQK0XUVVbfY3t5habWOY5RQRYZq6MRRhmeZKOSodplg3CEpJLZRsHP1GqsXn8bQJKZmsn/QxxQpMo/J85jlygojR6d/8zbSdqnUdESss3fUJlZidHSWSk3CeEalWkLJMvx6mTu7R+i2RatWIdg5oK/kFFKhVK0QzlLUPKe62uDw1g6NpSazJEPXFeI0hTjC1D2O24cM9g/5wNd+LYfjHvksQ9FyOt09zp95FK9eJRyH5EWC1FWy8TwTT6/XwVFMwjzDtm2m/SGN1WW0QjIcD1CEpFBtNDLCYR9jdZV8GhH2ehiOC7pKkc/PN9uwmYwHHO3e4MKjT9Eej7E1lWAazqMtZzA42Mdu+BSqTtl3WVpucuULVzFMwXg8ZWtri0QKyIYkkU6tViOcBhiOQp5IkiLH1iRCzG+taVLQnga4qopm67hS0I6gmE44t94idiWDa7vkroFXajFJp7gln+nxPo3GOr3uFKlCKkJmOwc0n3qc3s0dbEtj9ewFtt94nWZrHaUouDk+5ly1googGsVM1AhTdVCSnMF0jFuZR4JCUYijgOVGmc44Y9ht06rXkCKjO45YrpQRIiRWbJJZgDBNrFTB9yXjQGMWH5CHDmY642AWsrT1CN3BESuWT65lnN04Q7t/xF/9wb/GtbfefZ3AA/EAkcxzWuvLhL0+R9du0N8/wNclq1ur2KsNNNXA98oYQmWpWaUXKZyu24TKlM9/9nnsUpXTzTUqjSaG6SE1DaWQrLRsnnj0HK/utdn59AvIJR/Pc7jw0MPcvnaN42mfJgUH7T2uvvY6RTgjK1KSKGA06GIYBpc/+SlKjsr5s8sQFqhiHhU4DAPcmkOUwyjMaR93yWcpplRRFRu90kDkY5Q4I8uy+SPDFZvMMNH9Jn1XsCosNs5u4tgKapITJzm1Wo1VHU47Dv6yg6YLhpMhUSHpDfp4nkunP2UwHDLTcopCo2Q5TPpd8nSEqUnCJEIXCqmQWEXG3pVX0ZMCxzSwTMn61jof/MDD3Lz6aXYu38TyDSqezflHniCaxshoRjru0Dm4iSd0slQjOBqixRGzNCSeRmizkEzNCQd9ojhDyQpEmnLjlVdB0dErdab7bTIk9fXW/JakoeC7FrWGSxD2sX2L+uoW29vXiI56CFSqJYc4npGoOV6lzJIwULWCW597mYMbhySFAKnhVesYtoc2nWHYFWzbZhxOqJZtUqEiVYVgMGE4jOkHObNxSqqbNA2XwaDHpD0kskxqvg5C5+WjLvs3ehxJiRQFuqKyXKojM4EiVA56e/gVh2qrTPfOLueeuggYLG9sIkybYHiIyMcYVoKSdHhs9TR33tzlxZdvoq+VWV4+i172SVWorq2iaCq5zLAMk3Klxn73iCweYzgOCbB3tIdfMrny+v9GugIthpJXpaFbGMs2QawxvLWPOBLUmxWUssvy1gXKJKzXfeI0JB7GHB1dJY5yFO1Lf9UfiJnAk48+Kn/6Z38GWQjqTpVxNMMcHmOsrjAroOWWuLl3B9+vsH9rG88vMQ1C/JqPZ1qMi5zrn3mBi89eIo8LxvmMIjeZdA4p6zqpZ0CQUKosERz3ECWT6nIVR7cxHIMwLBiGY9YbLa5sX8czDKxcEOgaqysraFJw+/YuzWqZGLi9fZOHzz9GGo1wbI87h/tcvPgosyQFRRIedxgXGb7v4yo6QsnZ27tDo7GM5zmEaUFS5IggoTAgCEI2Tm/RbR8yGmec2Vzm1t4RjuMg0yntwZBzDz9M0BsQDbsEnR02PvhRrOMJfccmDkNUQ0FXVGyvxGg0ou5XaY/75GlGybYwDYXZJJpH0bVLTKdTlExB82wQOfl4huJaKEKwe/VN6pubnGpVOTg4IA9jzPoKvp0zmQgMU0VFYHk+V65cQfN1lj2bhl3lMI4QwGw8IiLF02xk3qdq1Lnz5hGtJzYYTyIcW2Pv2jar66c4HvQ4v7HJMBxjOz6qodLb7aDYGtF0RpjGnNo6S7/bo1AEZdfD8VwmQUAYBOiOS8W2mQxHTMMZ5XqNaNShwCGKZ5S9Er3hAFNVaW00ySY5k+4eaqlJuVyle3ATu+GTo6HlAt/x6fTa+BWXYRxxur5KouYYmslgOKbdbqOLglKlilOtERz0qTUrhHlK97BNybGwTMnN7oDTyw1UIRgOh1hBxvJT5xgcT7Bsg2AakqR9ZtLHrVZZsmJefuENzj95EXKIRimd2YCypXDn6muc+9AnCCdjUsUiGLUp2SXyPKfedMnGUyy3xuHxMYpIqNZWSLIYJStwlpb4Kz/wfVy7fu3BnQkkeQ5Byu/94i8xDXvoekbryUvEaU4+GnH58lUcx0NKSavVIowSDNshinPG4QwrkWw98TSjTgfbtkmGEzwbGo0G/soK+SzGtm0OjnbRmi5WycY2PQ77QyaTBGE7BHc6jGcxK65Py1+iuXGOZnWJzkGbfq9Hq7VEmAQc7hxSX6rj+CbCtGn3ulQaDaolm+O3rrK3fZ1eLrGNMkulKsLQUQyH5qktCsOmP4sRQqDEGRE5uWJhWC4Hu7dRLQ9kjzQI2Ww1cQxJ7+CYU/UliFJmWU5ldYPGpY8gJyEv776Bqet4vo+tG2iWRzBNODzoctw5ZMUxWF9eJRwFzEYhb13fRmQZo/YRSRbj2AI5HeNaJoapYRoarqJy6dKTtCzJ7vYt6o0NHK+OImKSTMUSMX7ZQ9VybFfhe77vOzhVXsGxaryxcxtVUZBJhmWUUKVOyatQaOuEukNWtuj2e9RKPppQqJw/j6xW8WoNJkpOmECpUiYb5wwsFbNcQ6uUcctVhrMp1XoZXVUgz5F5DjmUfIvxsEeYpxSWmOfriwIK1aJU1QnHfcIsxCjpjNOCcaDRHXYZTguS/TcYHuwhzBJlv0mRqwx6M6bRmFrdJ5zE9I66tPtHFJOYQbfHZDxkeXmJ1toGjWqFN77wPDIaoyoZikhxXZVMEyiF5NzqBpqwyQtBpVbDPr1GTauQSoW9wz6q7aKpFWSRMx3dZDDOefqZj5CGkk6ng1Yz0IIIy6mz+cyzEAyR0ZQ07JJFGaphUBgCqQni3TfYn4worTZx6i3GScwwnJJKhdGw+2UfJX4gjIDMMzJZ8LE//+dIgynSXWJn7yZCsbErJZ554iyFKplOZzRbZ1jeWCaLCnzTJ1cthtEETSSkukl/NOb0mYcxVJ1er8f1nR3s/BDdUalVq+jjGcE4ZL+/j1bExJNjyAJOPXKO49s7zBSLK7u36Xb7uIqO7dQx3BKGVAm6hzxz6SEq9SYWBuEkY/30GZIkodc+JHM8VM1mxSgQSsrRYIdkMiNKMtr7e6jBkJWaTZHlrG9t4hgKWRJw/fUrXP7sKyiziEcfukAym3B8tMt+t8eFS4+SazmvXXkR11EZBxNIdBLD4PylDxJlCWEwJS4iot4htq5Q8x3K9QbHs4yjzj65IVEtgw993dOUnDqyalMpu7QnQ041VugeDEkySRZmqErB8WhKUW7heT5ZEZJlMZZno2iC4SxiMuwRz0LCJOTTn/rc3A9iJZx7+BHC/oClqk+vc4yahmSDI7ZaPpaa88Slx1lvtajULILpgJomUGZTypaCYdlcePQsYbtNImHN1hGkpOMQs+RgGQZBmKAaOpkm2Dvs09+9RVqorJiCwcERTuGg6ypetUnJq2AULvW1ZUr1OvE0YXVlhWLWw9I9apunyFfO4TbWOHV2jf54gBpn1FeqhFIjkiZTQ2Xr4YeZ9EYctDvEWUi1ZKEUOZ3jNrNgwsVHzqB5S3SDhPZgSi40GmWP3KrQ7s0wDIMwSHBVg3DY5rX2bYp4Snhwk1c//Tyu7qIaKgefv0mCwWTUZ5gcMYtyZqOQYHdAOxihShj2hiilCg4uXrVE0OsyGU65s9uDzafQEASDkHBWoKsada+M45mopoEsvvSM/4GILPQzP/OzP/EXv+u7yXIYj4a0fJfbn/9f+M1ljjvHhOMIx3YZj7skMiNNUlzbJXZjVoTGcBLN4+FbFqqmEiUZRZKj6RZ+1UYTFfpBQDqd0nroLBWnCoaJJixU3WMyKege7iBsm9X6OjtXPk+15HGjP8ZVNYLDO9SWl1mpVNmXEPdHmKqKVzZRyOgd7mGYPqpiYDoWw0wSjcb4lWV0Q2U2neD6FXqDMYViYzomsyhmMpmQZimt9TWqS3WuvvkaS0ur3Dw6ptFYouxVUIRJnhd4rk8UZRiGzTAYocoCR5ikMqdcctEKUApl7onWXRzPIR9NUVsuZjdiHCX0h10mBNSsFlH3gFKtAbpKLnPUIkeInLXVdQ56beJZiKAgFAJX15BSQTdUZCYR2nxRTjKakqCgKTkyCbjyylVWz5yhOxmh6xKpakSpJFNUFNMmTWfoqkmGjl9aJoimyCTjKBiiKhrjwQSkhl01SdFwTIjTnPPrLbI4o+SVsEyTpUadNJtyausMmrBwmnWkoeM5Ns/9zidZW1lG0xUmsxGWqVPxqvjlEkma0xsNkOPJPGGn42L6Js/9yr/DtJpIXTC8cQ2/ViXLc+q2R57lHPR7CASlyhLd3oQoTpACDNXCrpfQhCAYdVlZWSUMMsxCo1arosuc0WREbpvIaUG1vkIch+S2TW2pRXNzk82NJqZUSTyP/U7ASy+8ysrGMp5pEaUxjTMeduahUTCRKpP+kFDJ8asuZTWle9hDCBXLKxGPIxzTwLElmZQUUmWcJAgm/Pqv/yZ/+0f+zoMbcvynf+onf+Jjzz7GQ+ceYRIk7G/fwD57gSIV+KUSoaJwtHuMIgtcv4rWuc4oMYlHU9SST2/Upuo30U0XITSiNObg5lu4tSpaIcDWqddbHNy6zfLGGsfTIfk0JZiN0E0NQU6zuYLjOBiOAbpAMRwM3abkzJNwHO8ecmPaYdqZ4aoqvdkYE8mpjbOcPn+Og/YRtm5j+yUG+3co1ZpUtIjL129SEFOrt/DKHoahkMXzvAa2qVNyqkTJ2/nqlhlNAyq2TcV3mEUBbtkjL3L6gyG6rjObBWw2qqRhhuNXmAwHJElIkoOiFlz+1KeITQuVhHQ2RJ8qZCULZE59bYV4EpEZGq3qEp32CJEXTGcB9ZUl7uzdmS9lVhSm0xEmgqwQzDSBUeS4vk8UZoRJTtl1wBQURYEqJNMkJ4xzDF3HMW1st4Rjl3AMjf7BHQp0TA160xlJFhOM+gRJRiGgkWYwmWA4ZTB12sddXC0jkyZxlHH58mtMgvkTdr1eB8cpIYQgnIzxHA19NkEvTHJb4dx6k6DXxqsvYZQ8FFVj2AuJwoCa4yHTCVvrp8llgYwHrDSXeejJZ2jYJrkwmFoWy80VBAqGBUKoHNzZY3NtmeEowHQNHMtjFIwAleMw4Hj/gDhTidMYUy1I1IjOpINbtVEx8R2TRCkYRiFpr0OWK3imSxhOEYrFcDpG1VQ2Wlssba6Q9e7g1Zr0On3Wa2skhAwHXVq1BqprUXfLeJbBJNEQiqCxvMyo02f9zBrHnS4lv4rjuFCkpEnErDPif372eX74QQ40KoSYANfutw6gAXTvtwhOdHwxJzr+KH8SHZtSyua7NTwQqcmBa1LKd1uReE8RQrx4ouNEx/tNxwPhGDzhhBPuHydG4IQT3uc8KEbgX9xvAQtOdPxRTnT8Uf6/1PFAOAZPOOGE+8eDMhM44YQT7hP33QgIIb5JCHFtkafgR//f//FV9fWvhRBtIcTld9S9Z/kTvgIdp4QQvy+EuCqEuCKE+OH7oUUIYQkhPieEeHWh4x8s6reEEC8s+vvlRTAZhBDmYvvGov30e6FjcWxVCPHyIlDt/dJwWwjxuhDiFSHEi4u6+3F+3NU8H/8XUsr79gJUYBs4AxjAq8DFu9jfx5jHR7z8jrp/AvzoovyjwD9elL8F+C1AAB8CXngPdawATy/KJeA6cPFea1kcz1uUdeCFxfF/BfjORf3PAX99Uf4bwM8tyt8J/PJ7+Jn8CPDvgd9YbN8PDbeBxhfV3Y/z498yD+fH4ntRuZs67sqX7St4sx8Gfucd2z8G/Nhd7vP0FxmBa8DKorzCfM0CwM8D3/Vu+90FTf8N+Mb7qYV5QpkvMI8L2QW0Lx4j4HeADy/K2mI/8R70vQ48B3wC+I3FCX1PNSyO925G4J6OCVAGbn3xe7qbOu735cAasPuO7b1F3b2kJf8wMcoR0FqU74m2xXT2EvNf4XuuZTENf4V5tOj/wXxmNpRSZu/S1x/oWLSPgPp7IOMngb8Lf5Atq34fNMA8bP7vCiFeWuTFgHs/JltAB/g3i8ujfymEcO+mjvttBB4o5NyU3rPbJUIID/jPwN+SUo7vhxYpZS6lfIr5r/HXABfudp/vRAjxrUBbSvnSvez3S/BRKeXTwDcDPySE+Ng7G+/RmNyVPB9fjvttBL7iHAV3gfcsf8JXghBCZ24AflFK+V/upxYAKeUQ+H3mU++KEOLtJeXv7OsPdCzay0Dvq+z6I8C3CSFuA/+B+SXBT91jDQBIKfcXf9vArzI3ivd6TO56no8v5n4bgc8D5xaeYIO5o+fX7rGGXwO+d1H+XubX52/Xf8/C+/ohYCS/TD7FrwQhhAD+FfCGlPKf3S8tQoimEOLtVHI2c7/EG8yNwbd/CR1v6/t24JOLX6U/MVLKH5NSrkspTzMf/09KKf/SvdQAIIRwhRClt8vAnwYuc4/HREp5BOwKIR5eVH0D8xSAd0/He+FQ+SodId/C3Du+Dfy9u9zXLwGHQMrc4n4/8+vJ54C3gN9jnkQF5s6pf77Q9Trw7Huo46PMp3OvMU/2+sric7inWoAngJcXOi4Df39Rfwb4HPPcEf8RMBf11mL7xqL9zHs8Ph/nD+8O3FMNi/5eXbyuvH0u3qfz4yngxcW4/Fegejd1nKwYPOGE9zn3+3LghBNOuM+cGIETTnifc2IETjjhfc6JETjhhPc5J0bghBPe55wYgRNOeJ9zYgROOOF9zokROOGE9zn/B92K4sSS6UogAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "{'boxes': [416.34, 1.85, 506.14, 488.06], 'image_path': '/home/rajath/work/iisc/data/coco/images/train2017/000000562150.jpg'}\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "{'boxes': [194.78, 165.96, 499.0, 333.0], 'image_path': '/home/rajath/work/iisc/data/coco/images/train2017/000000412151.jpg'}\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAW0AAAD8CAYAAAC8TPVwAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nOy8aZRcZbn3/bv3VHNVV1XPUzrpTjoJmQlhDnMQJ3AAR0BBARURcfY4gYjKUVFEFEEOgjKJoiIzIQlDEiAJGTqdpDvpTs9jzfOe7udDxfN6zntc7/PhdT26nv6t1atr77XX3vveta9/Xfc13EJKyRxzzDHHHP8aKP+nb2COOeaYY47/feZEe4455pjjX4g50Z5jjjnm+BdiTrTnmGOOOf6FmBPtOeaYY45/IeZEe4455pjjX4h/mGgLId4ihDgkhDgshPjyP+o6c8wxxxz/NyH+EXXaQggV6APOA0aBN4APSCl7/3+/2BxzzDHH/0X8ozztdcBhKeWAlNIEHgYu/Adda4455pjj/xq0f9B5W4CRv9keBU78ewd7vF4ZC0XQbBNPJo0mQWgatqKg6hLLo4Nlk8uZ+L0eogvbUAUMHzxMRPegoqLrOmXTRJg2BdtC8XrwhsMUptMoSBxcHAGmAMeVeGtqkIrAVUAAigAhBIpQkVKiaQogEUIiEUhXVA9EgpQIRSClxHVdNE1HCAUpHVzpoqgqitBQFQXXdZDSwTJdhFAwLRNFEVimjQRcxwYkjuMiFAVVUXFdl2KphOtKDMMgEPCjqBqu46BrOqZVplgq0NjQiG3buLgorotAwZYCTVPJZNPkc0WCgSDhcBDLNkEKfD4NkHi9gmKhzNhYhoDfwLYcorURVEVFHHsGEjAtGyGq+1zXxKxY2LaNbVXomN+MYxfJZgsgIRQMMDaWRjd0DI8PRRFouoFAYlouEknRzKNrKhF/AEPXkLZkeGySlsYmUolZXNdFIACBI21UXcOUNoqmY1k2Ht2LZVuYFbP6fakaCgpIl2g8zkxqBhXwajqtTc2kkgmkK7EtG03X0X0G04lZauIxEqkshuHDzBeR0iWgG+g+A6lpqEgymQy6VjUR27URXh1hutiOS8jnw7VKNDQEKZTK2OioqHh8fnK5JJriEI0GMc08miZBuji2n1LRQQiFimmiGBquVJBSQ9U81fu0LYSiAhJFCFzXxbYsIpEaNE3DFRqaqqGpgnwhT8DvZXJynJbWFmzHxXEcwAWpoKg6CAnCwXFcdM1DJpMnl8nQ0trGxMQ0llkmHo/S1NjIzGyB4aF+hKIS8HlpbJ3H4UN9CCzaFy7ArpRJJVLoukZbazsej8HOnQeI10Ro72isGrMooygGIJASEBz7Pv92Rq+ApGorikq5ZLO/twdQ6OpcQCDgRdWq9iglCPG3alE9l0QFHMSxz67toGoqINi18xCGN0B9cxBNh3LJQREKUlrYjoUEPLqGYpbRpIttFqkJ+THLFRwMhOGlonvwB4LkinkkMDYyScDrR3FcfF6dtrZWUBRc6R6Thaom/Ffk39zz/3tbIhDSBaGwZ+d+NNUDevUY25bYdn5WSln33/XyHyXa/58IIa4CrgLwBw02vHc5beg07XodVXrpPvNjzHrrWXv2Yvw1SzAaghR9ZeoCAcbueoDnvv19aprqyKll+rMu/qDKaUtWkOwd4/XRUU656GwaLn8PW1/cgXJ4iNHnX2PxCSt48tVtDJkV1p+9AUJeBtNjxGK1BEIRaqJhvIZCOByisb6RmhovSIVUdgZHZhkeHsaxFVzbx+H+ISYnkhRKRcwSpNNJAjU2jjAJRyJs23QIpOSUU5az9LhOYvEODF8ZRehIV0U1EuiGxC11ogibkpnDdVQss8T4xDSP/+Ev+AIeLr3sA2RyBToWNNFQoxMOwq9+9XsO9qUxvKOUEgqLVzXx/gvfhUotr+8aJJGaor6thh2v72diZJpPfvpjzOuqGsLAwOuUS0P84rv7ueKqJXQvnc99d71GTTxIY3Mnf3niOc49/+1IRWXBwi5GxsY50DdGfV0Lo2N7KBds3v6W81m8pJPmeotYrcl//PqP/OqON1i3zsPYUYeSJfj2d75E18J57Ot9je5FK5jfvADD9oCjo9b6+eMrzzMyPUy0oY6br/kyQ1PjGC6YEmrizRRSGWzXREiTc1aeRK5QwpUmJ6xdyrzmOGHVT21NlKHevRi46PYEqYzkpo0maqVIwSxzaHCAT155NYdHj7D0jLU8/czzHNxygEUti1i9bg37d+6mtrWRQ9O7WLmmm65VzWz/814WNXZQ8mioDfU8ds9D1Bo+5i1bhrVvgF63hOMo3HjTKq6+rIu7f3of4fnz+MMzOs6kw+WXXsToRC9BbyeFvMlZ515MU0M9A/0vML/uPPbve46ccwR0ya79ByiUBbt2T7D55X4UCfWxCOOJJAri2I8SSCl56ulnMQwvqF7mzZvPl754LetOWMU99/6Uu7/7AzS/F8MbwOP3USjNEvA0MJvIki9l8fghUhMinSzhDcZY3bmKr372Bk4+8y3c+J3vcM9dt3P4yD5Or+nith9+DW/wRPLFvUwqR5Fuloo08GoGKCrPPPUmTz21i45lNp/71KeQMge4XHb5xbi2zvXXfY3lqxvxqP6qQyFcNENHSokqwRUO2Dq4AocCoKDrtaC49O6bZOmyZlKz0wSDGrrHg+s4iL+qtqogJEihYMocCgFUaSCUMpZdRCGMbeu4hoZfhWtu+Aa7+/Zz5VXvYGzyAEG9Dn8owBu7dtMUhtChXo5f1EIx0cvxC7swRIgnd6S595lXuHPbGzyz+XkUn03FsmiKLSIxnmTNwkUkp4e4545fsb/vKA//5peccuJqivk8wZAPyyqj6gbggiv/qnV/I3xVJxAUHHRU10ZxVdbO/yCj6WGWn7qIzc8+RE66+IQY+p+08x8l2mNA299stx7b959IKX8J/BKgJu6RftvFoyoIW2V593JO/uwVKBNDlBPjDP7xBabSRV7bt51cKksllaScn6al5CdgatjSYqBgoUz34C0WWI3BxGMv8eAfnubtH/oweSSjlSJRxUarj1MvFfxeD1LVaG1qxecPYqMwM5vCUC2mpkfZsmUTiZkkiUSasfFB2ubFKeYlzc2tDB0dYdXqFcTrDNrDIVpam4gEGvCHDBAmwXCMbS/eABI++9lPk0pPMzaRxnUi/OXpxxgeHuSnt91LPlugZ/I5hOvB72lEKA75bJJUKkWxYGJ4BJVSiTNPX49VGsEqDvHnLS+ycdMYPgEfu+Ys7v35FgrTXg73HSaf7+PdF36CeGOUwfEDzE5n8KkBXnzxRT6yYAM9ewYYGd2Hz6ty/TeO44yTT+YrX3mAt73rfPoPjXPPfRu54vILec8ll2I5NlIFb/AQFdtHPFaPpmVJJ3McHRrCsiokm3U+d8NnqVi1zG9fyfTENBdsWMG8Bd3E6iNMT6UIR/1Egir1TRFKyRIxW6WvZx8nBAJ4XRXDBtUCx4AV71xDY7yZBqOe8YFhrJlJgj4Ps6OjLOxYzNknHsdZZ6zgez/+Efv6jnLjjf/OH56b5rRT1zM0bOJ2OHQt8SELgpWxTjxYrEpNcUZzE4GRNBeuOYN5Z13IgTd60LxB7ks4xJvivNJf5Ln+nRiRDlZ2LSQxnWJmbJbRHQdQdFi0bDHt7a1sf/lNbAQoLj1vwNZYHc21lzGVtPjjbx8AIXjqwS9RTEzhn3c86XyJsVmX0eR+/vLUnVx7ZZHJ4gDDw6PYboVkKkMyVaAp1sj8plmGxlNMpTOgaqiujWZ4iEajrF27ljd37SOXy3PVNVdx+HAvrS31TE2P8d5L3sWy5cvZ13cIxXWwyyVcFIrlArlCAU3X0RRBOpWreo6FAoNDPdz56AM06FHuv/tuhOvy6X+7iQfu/Q2f/tznGRncxcnrNzAyso2tvUmWdtcyPpPjC1/5HltfHaG2oYZf3PljViw/m1AoSk0kxtjYKGDz0IN/xHFNnEoWRVWwHbc6G1U0JG5VvBWwbRuh2AhVUC5mEKqPpcc1YVcKhKMutlmd0UpFIBStKta4AAhUFKWA4gZRJCBMbCuH39eA60qEm8DEx89/dBOf+cL3aGtvxrYmyCRtwoEQizvm01xTJjW0i0J6lO6OZg4e6Gf1qrP4xf33s/6Dl/PcllcYmpxmwaJGauMR8uksM6lpHvj9ftafspaTzz2Dls4OLvvoNRw58CaBUAjTLqLrOq50jt3n36JQnQGJ6riEg+WCqrrg+ClbJjX1DWx89kGu/urNvPra4N8V139UIlKjmog8h6pYvwF8UEq5/386vi4WlO9dfwaxYJgrL7qMXC4HMS8y5CXS2Eawu5GYGkTN9pJIpjii2hRzeSpHj/DE7T8n8cIRAHIu+AScprfgr9EYaKpjd12QmaN9zA9G2fLmfkoo1EfiNM5vRtVV9GCIUDhMNF5LPB4hGIFgwCAYDnHtNd/EdRRe2PhHJiYmSMwkqamp4ac/vY3dew5y483Xs2JVJ0LJc/hgglJRoigK0VgdV1/5RQC+edOXUFWVkpNDVco4uRbskk7f8BY2bdrI4s4TWHNKA2tWrCSfstA8GuduOBdQ2X9oN7Ozk+zcsY9I7QDh8CxexcHrtPGLO3by059/kS2v7OT22zay7twlrFp1Jm85+71E4372H9rOJ6/+LNdc/UX6D/dy8XvOZWRklFIxQ3ImSSozSslUmRrL0929kmjcz8GDO3l+4w66Fi2nJl5D56J5+Hw+Du4ZIB6vI5kbYnp6lvWnnsbDD/2eVCKLosAN11+JoavU19fy5JNbmJgZpXffMBJJtE4BTefaj3+GU9afyKduuo7Tzt3Ali0v0SH8hBN5Fk+XaHcNUhNjLFyyksFkjuHpCVpPX0FesXgjMYmnpoFxPHz95pt59wXvoGXBGu74yV3c8Ikr+PxnrqKuoUDP9h6mnj7CnsP7OX7hQvJmkdiidkZGB1l75in4GprIG3VE62N4Qn729+wmMXSE0NE9tOaLLEtPMpaX7KeCaofYU7JRlnSwN59m+sAR8GsYRZXaxlrOOSnGqYvD/OhnrzJlqdzxwGNsfeFx7MFHuPB9C7j9l6M892oOVzr0HRmmc0GWPVsfpZDXeOqJ54jHIjz11It0dS1k784Ei7sWcMMXv0ywJkqkvoH9u3exo+cAw8PDTEynuPLKaxkZGeWMs07g+7d+h/e9/938+Mc/4Ju3fIuJiSkq0kUKlWA4RKFQQEHFUAJk0jkct4KiK6i6AMVDMOiieWtxiiHamlu45J0fIFEsMNO/g7Sq8rufP8U3bvkJM+N9xMIWF7/vrZz0tpMR0kddzdmYxRybn3mWfLFEKCjY9/p+bJkkk8gSDAS4+ZZPcMaG83GsElI6CN3FlRIhlKpQOwGkKVGNAi42iuonl64QCodBSIrZAppHYuheUI+l3VxR1T0pQbhAHqQf3DDSSlOuZFD0IK4LQgni8QsUI8gj9z/NgaP72T84wfozT8AupWmtsQgFZmnKHab31c10dy1AceeRyhj02i1c8a2vc8vvHiYej5DKTZDITHPC8uMJ+CPEw60YuofXN23j4xe/nUs/cC2tjX5uv+1WHLeIooB07b/q4P+kjbiue2xICprQoWxz0Ttu5U8v3oTlOByeTvLnPzzNlz5x2U4p5dr/fo5/iKctpbSFENcCzwIqcO/fE2wAE8GgzKMFm5DdbfjUEpnMIMFajdf7nmFg6zAzY2Ms7GzE4w3xretu4WNXfIB10U6e3XyEj552Im6+wAEh6W5v4/UX9lJfGyHS2cEzjz+GroGnK0pz1zJqm1o4cOAA8xYvpLm9hcP9g+i6TjaToFJJ4Uk5RCIBFi9eeuzhauzd9waF8hQ+j0EiPcOXv/IFNr6wma9/5cfEIkE+8tH3ccqpJ5HOTDCbmKaQK7JkaQeHDh6lVLaZP7+Nnr5dxEJRDG+CaFxiKjFM06H/yF7e3Ffk2aatLOnuYtXa40inUoyODlOq5EklEizsnE/e9uKrKGx/cxu//9MuAobgve+/lWwBmhtr+eQnb0BxI2zevBm0Mrn8KH6vTiQUJhaLs2dfHz//yYOEIzYLFy6itqGGL3z6BoxIkF/f9UeyyQJPPvsmmqpQLJtkRyZYtnIxsZooydlJQkEviZlpSqUSGzduJJXMYvjArij87vE/sWzpSkqV3czMTnOgdxgpQFUNkrMmqqiga34kXpy0RqunBTFhkPcaTMxaxE9ZzUBqlvM/dRmbt+9g0q/ykRs/xw9+8kPa21sZHCnR4QsQjrQS1BZQG11CYVaSTdgoIoArPeheSU4pkVs5n7KRYeWVH+CiSy6irraWRx/8Lel0ipWrV7FuxUq+eesPWLh2JWrAwBuKMrx/Gn0mzzwyYGnM8wiCXQ1MGDaWz8v0a0dAKPjzNq4HTKuA5i8yf0knsYYw/YdyfPjCi0gVjrB/4LfMDk6TyJWqhiltUukpkokhZif7idUuJJcr0NbWQqVk4lguRwcn+fCH3s/zzzzBxMQIkZZ5FAolLEUjEg3TtWQpxUqGpvYGnnzqT6w5fjnbt7/CqjWrSOfSqB4PBgJF0bBMB583hFUxMQyFQECjVKwGl11HYHh18sUsASVHOm2SL1a46MOXkswksFUF6RS4+poL8HbEeeye2xnq6WPjC1s5cd1bqSD42e9uJDlzlKHeAYI1Xny6TnamQnNTA0UrhcctcsvNP+KMDRegKhpoGq4sH4vPS1wXNARCaNjWsTyRLBAM6yAlrl3C6/WCa+I6Dmaxgm3bx3IsDkgNoZjV0IlbwKfoOI4XQ1NIZqapa2pCSg27rHLzN37Mey45B1c5g09ffxctre307z+Ca+bZuP1prn3H6cxfsZSx8WnmtzYwOTbFJdd8lCe3vMTUzDixeIB8Nkc4HGZiehzDSJLPlgiF6ujpGeCtv/o489rifPzKjwAuigKOa6H8Nx/7WEznv+4SAtuqIDQbiHB06gDdi08mW5HIYo7EyAh/j39YTFtK+RTw1P/Osa4QeAyTTPYQFXGIQ3ueZW1zL/5shiVC4c0XR1i3roZl9W0cmUxzzvlLWXXyKmYzJdZ/+FwefugVlixbScXwcc+OPdQpBbxuHcGBUS5bvZR9hQpbe/ez4LjTyEyVOOm883jhpcdorGukZ89hTlt/MjfddD2rViyhr7+XWE0Nr+/YwbWfvpRNL2xjcnIa6ZMcPtpHS2MTqnqQpcuifOHz7+NA/xS/vv9XvLj5CXbvnca1NX52+ze55urL0T0ecjlJfe081vqijM4+z9GhLex9YZQzTw/z83u62P3KEnbt6qN5XiP9/Yd47KFBVq85HqHo3HzLD7jxxht5ddtWBvomEKog4F/IgT2/wBXQd7iX2WSGm2/9ARe94xoEDkjonN/M9Z/5AB1ttXzvllvIl4p85rMfJRiFqdkCszt34djw2B9epKujhfbGemqiId797lMZOpygt38IqUjSMwnaG2qR5RRerZl8poyqq8TiNTQ15clkLBzF4oorrqO2QcPvqSEaD1Fx81z7ia8yM54i5ItiV/LUxQLEbAsjYRLzmiTKCcp6BiPsoW9whI9c+jE+dt2niDzxGI8/+ihDmousjTOmOBzJpDhh4XIiXoPmZIKYx6Ux3kCtHsTw+NEDQdJFF4cgg4nDFKwUDzz6a6669pNkspP86u47ef6lHSAll3z0EhTNh30wwMs7d6NZNlGPghb1Y04nCahejhrw9MQhxhY1c+CVXuKugobLl1afys41ccyswxOPP8dJ3TGMSpbGWAPnv/UKegb/whWnhRHeGs46L8zEzAiusKiL6igmmDNZYo0t5JI5JoaHsUsGqZkceUfluc0vsHrdWkyfAT6F1tb51Ne3IVSV+V1LcWyT+e1tPPa7u3np5ee58ds/oq2zheGxUQJBH44U6LqLsBUqBQehZCm6WcIeBYEHWzFQlSCZSgFdSvIFk+aWRqTm55LL383qpjpe2vMmZ69cDRKaIwF2vLGHd7z1HK6+4noKpsZDD/6U5Mx2urtWEhIRBo70MzpRJODzg6rR1DSfRPIopj0LwsVxbRTbRarVRD+KAFdDQUUKgSZCSGyElEhbgpAI6UdKWU1+A4ZhIITA4/FVCwLMPIoaA28AKQuIionqehBqGKEkwfXzza/dwYO/+xOvbf81tjOGoIXv3PZJPnzV+/nI+48nYPdz/oYlHBgfYsXypfRPW0yjsXFbD0su6qdgTrBqST0+UaZYG0cWXXD9mJaFaUJ6IssLT/yFq6/8JLqZZFF3O/ligoDfV03icyyJigNSoqDiimrS0XXdYwlWgarqKAoIzeaR3/yI7mWtbNq7nXeuOZPf3fkQt/4dvfw/loj8L7gOSjqLryZGoaRQcIJcf/MOrJwHInm+/tHvkM6M8K6P3E3JtFBUuOiCItnxDLNjo/zw01exdsEKXpsY4pdP5Lj08+9Fx6DDq7HhU19Aq1Pxx2so5XMUikleeL6XO3/+VTrmt6JqYf74m/t537s+yIZ3nsx5p51BwFdHKBhmSfdizjv3LN7YcYiKVcuFbzubfDZN38FN1NZ5uO3W3yM1l29+ZQNlp0Ihq3PO+tN47KFHWLq8m+NPXMei41ehaWG27tjCrl0HWL06wEkn1VDbYHDnrUNc+N6TiY828+jvNiElPPXsAxzs6WdwcJAF87splxy2vvoGu3Ye/s/ksyICJJJpBo8M4vEGmZ4oE40FMCtlrLIgn8+TyWfJF01cFGKxGtKZWUI1HlI5yYoVy3htaw/BoIezzjmBrnmtfPITn2H5mpMYHkrQvWwJtQ21lEs5TCuPtMpU8inMQp6yXSEeDZJOpXCdADU1NZx11hm8uWcjycIMe/fvIB6PYigeBAJNkVSEQtgP+fwA8+tT6Klx1sVMJlM2NVGVvgP9/Phnt7Np+y6ef+lZKsUUQ5MzbH1lO/4aH+gOipbiroe38vTGAXIlL3WtIfSIhm2nEG4Sw53CLY0QD7QwVRzh5Z43QIV7fvsHXnhlF0a0DttysQJR6owQjiVormnAKuYxgn6kLCIVFTUaZbs9TuPZp/Hyiy/jUzTCusuZRj2DmSGstIcjB3JoqoVdSFHb4KF3sshzzz+IGqiQz7yFu+95iZGCxPDVkE2V0IUXKVOk0sPkckPk8zlKpSBO1awxkeQqNvWtjaxbfyoSL394/M+Y9HLKKadwYlMT5UKRdLbI5EQCy5asP+s0DvTtp1KpUFNTg6gGfTErFeKRWrLpaSpuAjx+vCKOI2xMTccwFVThp1g2OToygKP5OW7BKg4eTePFBdfBBM45pZup8f307unkmus/wJVXXc1b3nkuyUeH2bZpGGFF0fQmmueVyecSIEJYboGp4RDfuvnDANi2iebRqjNWRUHBQAoJOAjFBhSEUEG6COECLggHkAhHASlQFBet6sIihI3raKBq2E4ZRVGOee8STVhE44040uU737uR8ZFZojUVTHcEgeSpzW/Q0NbMy69v5dwlNsNHp2ibN4+J1CQrTlrHD77zEI31C9jx6l8YdwfxLlpH56KTmRhOEarzky1kkI4kFgxzpGeItcuXc+ePvs/RI9tIzkxRVxdBUkYRLkhP1VRdqjMJ162OVVEQQh4TbgVd+rGdFKZtsWhpKw8+8iyLWjyYwuTHv/jJ35XLfwrRlooKET+WblBTv4IG0+Utb9nLccu7OOf8u1j7rlnaauvoXmLT0NbI8y9ZWMFamha20tC3h3SHj30igddMEqsUefqRB7nuq9+g58H7aAmbzHprKY9nqQ8WOfOss/nQB9/NdOZZXnzqZb7xjWeobwjw+a9dzAN3P0zcZ9Dc2skJa9eiqGl++8BzPPLILv79zv+gdV4njjPBpld3Eoy28ZUb15KayDI5OUUg0syhwxP0Hf4Dv/zJtzFlnkKhwO59Bzhh3amsOXEVi7s7SPRPYQRVJvsP4VNf45k/7WXpsiX84Ps3smv3Di684FIsCddf/wl69vfRvaeXBfO7mRzNkc2a5AtFNm3cTlNDnKWLO1l/xmm0LWjjlpt/SDhSz7VXXUNv7w7MUhrhChA2iWSeutomQuEYHq9gf+8kJ51yJhect4Ebv/V1NBx+cts9fP3m6/nRbQ+Sz2cZGR1gxbJOjhxy8GgSQzWp5Iu4isvs9DjSlnh8GhUzx9GhfqLxMP2HRlm6ZBGNDS3kcz9DILHsNKYDja3j/Pkvm6ntqEX3pAjqUEglQSmRdQTTAwNcdtknePGFF8mlBDKvoaLgVXTidfNQClGOX3AKtjGPqX3PEIo2UnEcNCWGcGLYZRcpayiWEhgeQbTGTyaTpbu9jg998CJe2fIKw8PTdPr8WOkS8VCMnCdIsmBiVnR8aoS8J82fvCblBYt49I3tuPhoKpe4rLaNw6VZNjtl+jbPoNlxrIxCJpugratCeX+FoDafQmGQ5uWreN95x9F7YIbHn3yKvv4x1iztZu+uX6MZFRxZRBdQyOYpVyyKhTISl4GJITbt2MZK2+GGT32TSG0XqbLDiSeso3fPLpYs7OSLn7+BgrT5/Df/jT37e0mnUzS3tTOTmCZoeAmFAghXYlszNIdtjEAAAiVmZ2fQtEby+RKBcBi77MMrihTKSVYtPZ5CJcP27btZ2BEDRQXTRNUNmlq62Lrzz9S3N/O1z/2Zpvg83vueiznrk6DqPixLJ5/X0FQP89uaaG4xOOnUFlyZp1wu4/EZ2LaJqqtVb7MicWyJ1AoIxcR1dFQRrEYOhEQo1TAICHA0pOtWdVwqIATSUkBIXKWM5RTR3CC6UYPqy1IyZ/HSxknr3o5jz5Kzs9huCE3v4nO3fI3Fp57KynVvozLdj1c9TOfiBshM8/prh/jAx89h+XHLOH/telLpg2xYv4T+cgObnvkL+8bLeGvrOeWs9Yiyxf0//QVhpYYtf3mSbduexizmCYUVXFlAERquVHGlC+4xkZYuLko1dOLYKIpSfcaolFSB13bxeb3MzmZYdlwTG//4EHd+6Wvc8/1f/V29/KcQbc1xKZUi1NXUoosUPlfh8U29PLJlF2VVwTNi0hSJ07NXMJGYxfDNw2tE6fD5OKjqeIpFJmaz2A5oLXH6EhMUK2mS3gZcb4D0WBuIp9EAACAASURBVBERsrn4/ecxr81LKvUaC9vaGTlwgC9/ootnnzmImJllZdsJ7NxyiPrz6gjVGBR7y6iKi1ALlEo5XLXCgYNjnHfu9aSmcoSMLIqZI97ahN+I86fHLqL/8Djfvu1W1qxdy6YtL/Nv//Zd6uvrueP27/D0sy/SsbAdy1ZZsXwRSU2lMJtj1++eoFB6mLb2OrpXdtCz5yjbX3uNTCZFXV2M6ZkRTjx7GWed/VYU1UfP3h6O6+okOXIIqzxOb+8EXd0dhAIR9vZsQ1dVnnniFYRQUIWJQMFn+FjU2cGuHX3U1zUzM53hldde4pvf/hwLGpvxGH5+cucviUQCDPf04fEZ9PWNcvjQILiSkR0HSJZsHCmJNYWoUADLRff6KBQVfn3fw+zbc4TWtjif+/x1oKi4UsORGgplzttwB65iEQwaPPj400SiPoTwk5xxMXQVs6xy44++jIEf6fGzbecbnPaW9byyZTPx5gX0jY6RV5vxajW4gSh19XGS03l01aZkH6VYmcW1Ywi9iOoPYARqiPv8XP7BK0lkcyjSRXi8BGLtvNS/mVBbC8JxKJcLTFVmiAudtpJDvizYu3MIXZd8LtjIGk+En6QO8EZM4p/SqJQrRJnk4laJtnOa5pUNtPhmUGo1DvR6aGpqwqjx4VlZz9GhUV7fvZWT1y1netpF9xXJliZR0LDKAr8HCrkctVGdcrrE2NE8iYnXCOkP0di2kEA0zm9/8wc+9qGLeO9FG9jfu4+77v53onUBxseLBPQo+UIJV5coccFMwcQo67QELH578CFOa7Z5Z0szPZtm+e1/bOeDP7+X4VQRR/OSyxRZf8a7qKuP8uyTWzkyNMyiBSFcJIahcGh4honhISyZ5447n+X6a96NVECQx7ZdVARCqFTsEooIoKiVqhcsqnXNXi/gOui6juM4uI6Noolj/QxeFMXAsU2ksKtVIRIUNKSsljjicRCOwCw76F4vjgO2cFBVgaoaUKxQdpJIbxGDBnxGmCsuv5Ztrz2BI3MEVB9lRXDXQw+x+vhTSOcy5MMW6sIw+wdXsabRxhd9mdYF8I3v380ll3yerTufYWzREU4nybKmFfguPJ0VMsbAdJJGXy2vbX+JJc0L+f63v4srE1QqeTweBSmDx5KODo5rIhQVgYqQbrW6Bf4z+SiEwLYlqiqw3TJTKQ+5/QMsOnsVl190Bb9//D4KuLiOi1D/597Hf4oFo1xFknLylFUby83jOmVSsxOcsryRhpBBMjzBkDNBTRssWNqG5tFZcFwH07qN297I1q27aG9qZeGiVZx24hp27jjCfT/9JS11Pja88yyCcYEoKbiOQmNjB4uXrCQaq6e5vY3v/fIQuwfhy//+LL99bgef/9J1vOfDH6FUMSmZFjggHZfJ8TEi4ThbNm9DugpHBoZoaevi49dcSX1IY3r0KB//1Ff4/Je/jYvDE396jkyixOzsNP39/ZRsE1/IJRKsQXMtHr3vj/S83k+uMkO0PsZ7Lt7AcccdRzpVQkoIBsPouo7f70fTNLyKj97eg0zPzHLk6BBv7N6FNxhHMSLYMozhiSCEj3hdHYbXw97efiqmgmpUGywMn5f2eS1oSjV7nS9lmJmdYH5bO+V8DrOSZ/nKTsLBIG1tbaxcuZp0NkeuVGY6UWZm1sJxxLEQjYZC9QX06AKPLjF0STGfIhzy4/Vo5LMFABzpoqrgAI2NdeSzJh6fIJsukE4WyaZtfAEHoTgUUw65ZA5d2GAVqI3VIRyVSjZD2KdTzuQo5bP4pY6UNpVKCb8vit+IoLgRXFlAYuK4ZSw3T8VKY+guQnHQDXCsMp1dbVjSxZIujpRoHg0MDelV8SFomp2lYFcolywCrs5WkWB71KW2sZGUadOJyikNIWociVa2MbweXMOlUqkAOtKuYGZT7N2zm9nZcVKpBK7rkkoXKRdtXMvGlRLbkVguSKFi2xblEtTHY1QqZcKhAPM6W0jnZglFvHg9koHBg+gGBJfM56ibJ6taZMoZctk05UKeUEUjljFZZKl0VlROfWIKbTbKRCDGrle2E6sTLNTHidQfxqZ63UAgTD5ToauzGQwLqeuYroPtaDz08EvE6lbS0z/No799BBSbSrl4rJlMxVWLuEoJw6Oj6FmE0FFUu1ruJpVq2R8urnRQVRWhKFXPWbhI4VQTi1JSjSFU//66LYQEp6p2iqJUhd6ungfXBttGV3QUoaOpIQrlLJ++9jruvf/2Y81ZRSq2xabX97J/ZoA0GXweHTsP0lQRNQEGjArFSoEV9V1400kKz7+A576NdP7Z5OgrLnf8/jnuv/dR9u7vQysZjA0OceTAAXa/9gYnnrAa6dp4PV5cx8G2LFzXRSLQVB0FFVUoKFIFqRz7QRK4poVrWiiuxLUdFFfj6Ucewwh4WNreyYnLVlESCl3z5pMdGv27evlP4WkbLjRkKyyLBgmWLVpDMVaumsfP7j5AKacyeTTFactD6FmXxb4aRhhHm8oiKi5l1yHS0MRIdpal8Tjd8zvIouBEajADcdK7XsIulpG2g2UWmZrOkkxnyaVn0ZU4gwc3MjkzxaNP/pkD23sYKxYJpGaJNjYzv20Bo/2TgMLR/n1sfKqB3t272PvadixT4Rc/uxdV0wgEdFqaGvnSFz/DgoUdXHX1JxAKYCnMTs8QDoe56qqr2PzCVkq5DLFYHW0Lslyw4XyWLFnC9MwYY6PD9B/cRSqVQABmxcHQ/UgJlbKDio0XlaDux2eEqZgKlpSUTZWU6VBxJB6PS9608foiFG1JON5IImMiZYVdu3oQio3u8ZLPF7CsBAval/HL229n5eIO+gaGaVu8hLaWdjZtfoNUKo3XEyCXy+P165SLFqrQcKSJpldfUkUr4tc9VFJjXPaht9La3MK8+XX4AkW8PigVbSzAG9Cx8hb5ShaOjU1WW+UQwmVqqgyA369iWi6a0LDw8JZzzmd8fJzJIzNE62op9gwSq4lTKCeojwUQdoVQ0INhGKRSFSq2B1Xx4jUiOPYEAU8MBUkkBIVCCVyHJYu6mRgYIXDaGQzncpimi9cXJDedIhQP8jbLYJGnjNvSyJNHh0mFAsQLBtk3h6iTcF3TGjQ5TKmkEVS8eIN1NDYMs3tEEorrJMszLG6Zx0mrl4AL+3f3IBSFN9/oZUVDPROkELpBMpvDFZAtVQj6/cy6FVRVR1WLnHbGWlzVJZUYYuH8eTz8yN189evX0dzWihxJEi2G0PQcqtfPrFQoFw32DyZpiYTIFQcYvvXHvPOHXyX3+8fZNTrO5Xd9FyMYYffYs8zz5kglz+C4dc3MjE9jWRYzeYug6tA/MMbS7g72HRrj5i9dQt50eO8VX2LzCw8xOZuioTZKpTiF4TOQ0gvVkmPAgyMraKqG7dgoinWsA1FW/+MiNAXHkri2jaZVa7ZRXBB2tdPXMHAdq1oWKARY1Q5gTdHArdZ2CzygmEi7guaNk0taBMJ+bv3Gd/nu92+hZBbQjAqKjOKrSHbn99J95ulMDgxR79VpDjeQrZRxAw7GvgnWnnEhY5rDhve00SRBz7exOtTJvh8+x/zf/Bi3vYvJdB5fJcKXb7iGr37hs7S8PcgFb9lAoZhFUyx0XcfQVBzLpFKuVEv6BKiuUi1TBNBAVyQCUW1QFQJpqLjDGZQg3HznLaw/bjXX3XIdux96nmXnnE54edff1ct/CtG2kExZJcp+g5yQDMxMsP7cDZy0IcdHL3mYhqZG6hracSOQc70sXd5MQ0st/eOD6KqfVHGcrVtG2PPiKxRUCOES1F1279hOPmMiZDUTPZNIckLN8aiqJBwOE49G+fo3v8vW7a9StsrEAzHaG5rIzMyy8eVnSczMVuNTuNUyvu7F5PNFjh4ZQOClWKjg8bl8/WtfYX5HO+lsikwmQyQSopA3wVXp6elhamKahtYgXq+Xvft7aG2Zz4IFC7Btm8OHD+O4ZeLxeLUVv2wjJQwNDZHNZpmZmaFQKBCtqcHjC1EyLSLhINnkFLrajmbopDIzWJYFehDTcjAUiRDVFnQpqt5KMpnkxJOOxzDewDIl0ZowsWCQgcQoDz+5nWwmy6+vupLnN71GJBJA03VKZRMkGD4v5ZJVbdkVAsuyUEX1pbTdDHUNfu777U955skpVh3fgEuBQh40xYc36GBWJJHaID6Pl1yigqF7qFQq6LqOZVl4vQZen0GhkMexQLpldN0gnU4TCoWYkNNUzALHLVuE3x+na8nbMDQXKavTb8txsB0HQ/eiKjq67qkajFQolnIIIfD5fFhWHlVVq12GtoPf78fRBLO2g+7zkC7lGc/OEolGmSnZ5JrrSE0msfIlygpcrDfgKWbI5JOYuJQm0sTzeQI+L1aljMDkSP8hOpqiBPwGAY/K1NQEoGA7KuFQnNlctf2+WCxWl0ZQVDRDp1QsMjExhdfnxet16RsaQFdVSqUCY6MTeH02CxcvoYSOKWxSpo20c3j1IDW6jqa61BZnmdz7KpmBYexkL4OFAbbe2o9Tm+egIbj0PWdDZZy6dJzF7d3cdtf9+INxOhd2UypBXV2csD/MYw/+DAcFRYczTz8dzasgym61nE2pTs6FEAjhVqsgJKhCQToOujjWoi6qDeZV/1Phrz61olaXSFDUY6KuKPw/vSLVLtC/9q3/9Vi7XEbVNYRappBxCIS9SJlHKEF+eccD3HzrV7nhi5/CCFqYxSDSb/Cze+9g/kVr6RkdIxqrYfzIMLEGG7+qEhQ6cmKKHT/p4T/2vM7P73qeQ/1PkDAqqCLLZIeFLRT6Xu+hq3ERo8OH6Opo4/Yf/Tt7d2zDtqqjqVQqaJp2rIVdwfB5/3M8QirgCFBVUFyk66IBFdPEE/QiHMGdd/8cizLp0WleeeFZvEBjexs33XQj3d1L2DH5P3vb/xSi7WoqdixOoKkdu6zic3yMH0xTG1KoVeD3v9nC5NECh8fB4hDvu+BsEqMTGOkcnqkJilkXp1xkdedytmzfwsKOWvr2vcnqjlW4uRJB4WNCZNj66nbKdoXBwSGampoQriCTLHD9Z27ilPY27vn13QQLJkcH+vn+t39NqD5A54I2FEWjd99+6mJ1bDhnA78avg+/L8bF7/sAJ520jtmZEQ4PHEEIF8uuYHgUfH6dYq5Cb08Pu3btpqsUZWZ6kua2enK5HAcPHsQslTl+7RocyyGbS5DJJQkEfBRdk+HhUbw+jVLRor6+iYqtYuElVzA5fuUShvssYm6WYqVEbX6CWZ8PU4LlutjH1n1IpHI4UoBQyeSymLZFqVQgHIwiFItNr7zEVZe+l4fvf4xoCC772NfQRAUMjXA0zpq1J/HUE09QrlggFXTdg2kVWLfuJI4c+jM/uPlH/PDW73Lr9+9iz74hQDA+Pslt33uYSI1BLluilPUiNJVMIo8VcFAUjoUSFBxHAgqNjc1ks2lUPHj9HmzXoVwusnf3PkKBGnx+Dws62li8+CR6evrIl8a5+uNXs3VrH0KpGn7JtFCVauwz4A/j2C7Cq+I4glKpVDUuqiVkR/oP4zp21UuSLt5IDeXSDAPZDAPdDQyUbOavWUbvoy/gq4/gTeY5y2vQ6SlRrmRoitcxa6dI4WCaNpFwmFWLu9m2fTOrl9VQnD3K0FA/jtR4eUcOF5icSCA7GpgYGiUerWXgyBiW7cV0FPxRP67M8G9fu4L7/+MPbNn4OsGaCFd88INs27YNgcH6M88hW8pxZGqGoN9PNl8kXh8llyqDKVnf2s72px8iMDlAYJUg2G2zIHYyN160mnvf/Tgnvr2D7/U9x8KupXz0iuO59Xs3c8E7P4QjBJIwo9NHOdt/Oj/92W+467abOPNtH+db332UW75yCXsOTlJXe2x9HkPHdZ1q9Z4EkNjH1tyQf/UipUT7q1i7ElyJ4zgomoaq6BRyOTRNQVMNEFpVo6VEERqIqgi6UkHxeBBWBd3rpZDLEQiG8PgdimUbfzjG5k0baapfgu04vLLpJTqXL6Uh5uVtl36V864+j+HZFB7NQWRsoi0tTJUKBLLjNAxlOO+UBhJhuP/kYbb//h4yv34OZbSfiVYBXetR4t0sqpH86hu3U8llGe3dweBgHwiLQjGDR1fwB/1ItbreyV/FWgJCVavPQwFUiSVAwUNqJkkgFOTIkUG2bnyJp//4JF5ZITmR5PrLr+aMC9/Bx779dQzdR7Di/7t6+U8R0zaEhpoxMSyB4ffjGh78EYPeiQNYis7x607gw5dew6lnnUDaTnNk7CiaT+HIYD95S9DZ3c2Fbz2Pd779bL747e+TSyToHUjzjne8jfdf8HZifg9ICIdC/4u59wqS7KrSf397H5MnfZa3Xe2t1N3qlveu5QUySCNAwiOshhlgNMDMYIcBMVyM8E7CygFCEhLyUst0y3arva+25auystLnsXvfhyw0EzcuD/+He4MTUVEvFRlZmSdXrr3W9/0+TCnZv+8Qjz38DI8/9jQf/fgtXHzhRRzYtp1nHn6auGPiODYtbRaRcimXyygVkp8+Snd3N5lMpjkaEAbDw8MUi0Wy2SyhChCGJOY4JBJN7oJtm1QrFYaOHCWZSuAkYtSqDXwvpFqtMz09Q/jX46KOCCOPIPhrNyMJA0WhUGRqchrfC990U9WrZSxDEzTyRPUCxclhTK0RWoOWJBIpQBJEIbZto6KIbLaFXC6H2/Aolkr09/eTzaYJnZCJhqISGEjTI9IQT6TI5FrZvHkLCIFt2yAUftA8/pVKJaSUHBseor07y+ZtB8AURNikUgmcFKTTSdBw0kkn0d7eTiKZBGbVT7PXX5czlmVgGAZhqKjX67huHds22b59O/v376dWqxGLGQjqmNLlrW+9mLnzujFlSFtblkg1VQehCkgkEjQaDQyj+ZiVco3Fi5aSSCSQUmKbFnHbplF3cV2Xar1G1W3gRYoqMGZZLF13CS9u2o6TjlOZyXNprJV1UYaY8knGbCZmpii5AZ628NyQgb4BCvkZ6rWQ8ZEK9WqDeT199He1A+BFdaam81gyxsxkGdtw8D1IJlqpVjwMaQEmjhknGY+TSSXJpJNceflbuODs8zjllNMYGR4jP1Oh04iT8RSxKpSHZ+ju7sVJmOyf2YuVDbn8n95C97J+/vS2u2gtVbn3uRd47wO3ksh18s0zbuai89/Jixte5gv//gXi8RSl6WlQLplsFq0F5VINFUWcf+FFvPTy86AVt3ziZnrau0HHkNIEJFoLhBZIDExlYEay+aMMLCzQAqVAz/4WwsDAQPkRjpNonoa0xHfDZrFWBoQa7YYoN0Roycz4FNVyjVqpyvRUgfGRMYrTISq0uefuu7n2+nVcccMqDu2s8enPfYb2lhRPv/gGN1z3LrLd/TQaDRxtk7IdzLhFvCVF0rCpjuwl2HyUsT9vYNefPs6iDrjgs29n9aUn8MDO1+lYcyaT45N0pdp55ZknyNgJHnnwQRAKpTxMS+Ak4002zP8ylDdPHwIVRWilUEIR6RCtBH4UEEsliMcc2tJZOrtaWbh8GVv27uRodZq33vh+1m/eRdU0mSpV6Ehk/2a9/PvotLUi0Z6mdU4HUcZC5UxaT1jAbm+EKz9zM2v6U3R0+tz++U8R1EpkzRTF+ii73Bq7RUClOE3f4mW8uG0/fnc3NU/TkBqzJ8XRl6dJtSQRo5Kx4REuufx8WrJpWnJxqqUG217dRHsiTusJi7jjgZ9ityTwjnjUGwGuCzNRpdkxaEmmJUMilaJWqtPRYlIrFXEsqJSnicVMtFZEkaKjo4vdOw7h+xphSLZt20LPghhuzSOTyYC2KZVmqNddKpUKqWyCnt5OstkkU5Pu7E0u8P2Ars5efN8njDwM7SNjFto06Jk7jx//4DsUCj4dnRlOPut4giBAhT5B4IHQpJMpQt9FoBjcf4C1a1fhxOO0tnRSmJlhfKzEj773J1pam4aG4kyAkIrW9m6OHBsilUiCErS15qiVyhCBlDAxMYFSsG3bFiwrQ7olSXGmhm0LhJlEGlVGR2awrBh7dh5E6xrZlmYx9YxmVxZF6n+9/yFt7S3kp6ZZtmwJe/buJwx9dm7bRs/8uSycN4cVKxZQq+UZGtpKo9rFaaet5dSTLiGZlpiWIooCANLpNFNCUC5XMaXk1k/fytXXXsMZZ56OE3OoVqskkymq5TKpVJpaFBFPZ6DSYEHXHMZ3DrGl9DROQtBemuHd8U5O0CYhJeZWfA4kFdmYjR8kUT40Riq4lsnQyCTjE3kMI8fg7jzUihh2c4b5ymtb8bwEA53HMXroOU684HR043UyuVaC+iiGEkgJUkW0ZAwWL16OHzaoVqtIQ2MoD9eropIxKvGImCEIol4qbp3arj2csLyb0hMPU9u9nfXPTbDi6qtZc2k3D733p1z7ravZ/cpGDj+8lWXv+S4L557EooUmluFwx6/u4Pobrqe93WJqos6+vYP8+bFHWH3GZZx66lJ62pO8+PI2Njy1HqGh1vBIxmNNGl3UZLCAfHOc8b89f0KbSKERijcVIV7NRQhBpeHi+g16enpAKSI3IooiDCHxPA+tNYl4AsuwSbXkqBXKpFOtWKkYqazFu97xMT5162dROiCb7ufaq65gw3Mv0ai4rDv3BLZvH+H3Tz5P/5peXK9EGDUIfU0up3Cykps/einaTPCLy3+L9fNd3PrYnRxoDJJbNsDZn/sk5unHUxoc4+4XN1ErTrBoXguLVywh0grXq2NZs2XTtFBKoVSTNWL8tcNGgGhSGkFiCAOtJNIxefLPj/DIffdy3hln8saTD6OdNDuff5ltx8rc98DzzF8yjyl3lBmj+jfr5d9F0RZK0RJqoiOjbN9zGK8UsrSvxrkDS/DdK0nZW9nyg7s5MDRGMDnF8MFBdhciwuNbmbv4eMzFWe6++8esO+Fcgj2HOP78pYwdPMLXvvlNlvQvI5HrRcumXX3O3H7MmE2lVEZIhVtp0Kh7FPQMKeGRNKpgaaIQpLaxpIGUikjBkWNHqVQqSEOQTCYZGxuhWi0TT1q4bh3DtJFSYhgGvq+xLKupDPCaW3dhQqVSoa29FzUDUfjXv/Gp1z1aWlrwvHHQJlEEhmExPDyM67r4vkuxNE08naZWc2nPOOwYLAMWx51+PC0tLahI0tfXS293L4ZlEUY+UjRbgWq1Sr1WQytBFEUkk2nimSzKKFH1fJLJFNpogBIUCgUS8RSGIUFqpAYdgWU0u/fBwUGElDzz1HMIoKtrDk6iRmdHC52d3YxPTKMjA2FaKFVFqZCxkTLptE2TcSZmVQHN55JIJHCcGEJAMplESrjqqqt4/4c+zNZdu7jvV79kz94dPP3kk8yfv4hP3PIRStWAIwcLXHzpZUgJlmUxU54mkU4Rd5LE40lu/+73ue6aa9k/uA+AlpYW1q9fTxAEuK5LKp1+c57aaDQQgWCZmWSwVqAedzjpuEXM9eJkx4qYkUHMlPSKGL6EllgLos2hIvJMVhu4XpWXXn2F9rYuJo8d4JoLL2DhkgVs+t4v2LFtL2tPOAvHyhEFgnQyRzqZQWiBAqqVCkqHXHjRe/A9+MrX/pHLLn8LsbjNunUXUKkWWbBwLgcnx0kpjV8uQa2dRCxDmGiw/tX1fOaStbxRm2Cp0U3nCe0cGTnKVb/8GH/+2A859R1X8GRcY516Er+9Z0MT1RqGXHfNNUxOjNDd1UZXVwvFmSpThQIXXbSOSqnCRZet5Rtf+SEYzWO/EYsIAo1tmYDRVEIYAq0iarXamyfBeDyODkNCPyQMFZbR/BwpPyBQmmQ8TjyZQFoxLBQ68tBKYZgmCccEKfH95j6mPlOhVC6Ty7UTz1lctu46nnj2z/zmvh9TrZqcfuoZ/PK3P6M8UyCVTVApFVizcg46fjmPbXuK/mW9jBweRMkkquzSmjMJ0ppj5cP8x9M/5NXHHucnv/sR1556NZ26j/FTlxP2LeCpb/+Gua3dXHDa6dz+nW+wZ98gC5bMIxZ3MBHoMEQZYhbH2uyw/+pUNwwDpUJQEQJBqEJMI862lzfR09HD+qef48QFS6Fa5OG7nqDzpOXkGoOUilXS2mHSVyTntv7Nevn3UbRR9Bg1xp99hn+54h+QLZqt3/sBVWESRJuZ7EwyfvggftmjVPeY8g0ysTiH9hm01j3WLsrxQsnjJ//Xr7BsyWlrjqfHmY+YqvLqK49xREcIbMYnS+zfcwiUjyEdEokkw2OHkdFpWNFh9u2b4q3XXs/kcAHLMgh9n7onkIZFpAIS6XZWrV6HUt8j8CX1WoVYEDGQ7mLj9o0U6/u55NJT8auTWNomkUoxUypz+PBhRo+eSF/vfGamp3AkRH6d6XydNrvME4+vZ9fhCtqARCxFoDxMs8lWLhWnMYXP5NQY4/kG0oyDthgYGAAMDFvw6pZ9bHz2DaSlWHfRuSxZvBTHNon8iPauLo4cHUHpGr0DAZ5Xx0k6TE5J0nYOzw1JJFqoVcuYgDIkdkwSRXVy6Rak0AS+D0AQNZdo1WJEJp2iu7sVN5xm/iLY9ILJzPQYw0fHMUxB/9xuPFczlR9DK0g4JrZlUY2aj4WUszNQgzBQpDrTaA2jI+MoDcXSNMctX8w5Z53G975x2yzUq5fBQ8Nc8dabEFITeJJMa5z9+w4xXZikt6eVqakpcq0x6pU8r72+Ea0b3HjTTRimpFSeobenjdauVkYrBVZ39ZGuCiwrzYxvsVn7dMclV1ntlCYCXi8N0hjoY09KEQQ2srWNyz/5YYxCyMZ770f5HoXBFBXl845334DuElxy1WX8/ueDFI0xHn1lJ8/95T5iuQ4WzE3S25fg3KsvwonH6eseYLjsoWe/FA0t+cH3P8DGZ7biee289uxr/PoXP2LzG6+yadtGblh1NcuTHRwbLeFkcnS2dlGulKiXp+iZl+KXr/yO626+mq0btjH4nXv4+Ec/wkO/u5O3Pnwzv/rsBt79i8f56C1f4Bc//QafvvWznHvu+wcS1QAAIABJREFU+ezet49kKoM2ErSls/zl0YeYPjaCYQgef+pRrrvsy/zpoYc4fd2lCAFHj06ydKC3iZSPPCSC6ZFxlJC0tzaxz1EUUcyXyGVaiCfjhDrAlJLA9xGYZBIJEDG8IKA4WSSdSWLYBnYUog1NwxcYoUGlJHCSPomWNEYy4tXXNnLBReuYnnJJtwji1gAXnH8Jjz78R4JaRMZJgA9OZOAWqxw/32P14ut5etMmXjqkOPfsJYTlnXRLxW0/+SorliwhfeU19F52Mj2Xnkc1bGNwrMBBFSIPb0FMTXL4UIEXn3+Gn/76Sc47YwGWFHhBgMbE0IApIYphotG6gTACIh0R6gRCOHjaIy4Uppni8L4jHJjYy6FChXAq4rmv/4xPfPNbnHrtGUS1gHg6Qza5CJnyiWUU+cnxv1kv/y6KdigkU+k0xWOTLLr5E6Ql9CkDiWCCkOpuyBiQyaRROZNYVyfFaolAaablMMYbiqKnSS/oII7k5aFd7BiPqKmQjGVRCTRJaWGkbObPn8/AwAA7d+wnnXAYHh9DGQ1++dN7eO3laT79T//IU09MEzMjGkJQqYXYCQEKwqBBFJZB1CgWj5GfnqEa5ZmseLz8xsscGDzC/kOH2LWlQsKJYwq7OcPVPo3aDLXKNFHoUpiZwjQgkbDZvHUfoxMVBAKtNK7faDKEZ9Hx2ZTDzm3bmbdiOXMWLyabmUfoGixeMo8H7r+TyPdZc8Iybrr2WnKtLSxcuJhUKsVdd91DqVRiOj+DipoBDS9tfA0At+6zZMkKXnrlCe6/5xkuv+J07vjF7/jYLTcDEROjE6A1hYkptIJ6zUVKZmeUGikNPM/j4P6jdPYmeenJcZat6KRem8ZNppjMT6N0hBv4aMC0DGzHwfdCpJCYpokfRm922y1trSxetIQXn30Fx3H4j//4LF/72m2csHoVn/vc54hUwMTEBP39A7S0tPPCxpc44/Qz2bF7B7V6Gc9rkEm3sWjJInp6ejh8aJTOvg6+973vAFCqlImiENePuO/e3xIzJJlUigVLFlIs5rGyGcx5/Zy1dDm1Z18mDCqUSyW+8vGPku1uI9nXw59+czcXrDmdR7ftYGGmg6DFRnuCQ4MjzDlpDWdedgF9y+axLNHKgWeeYc/zOxiY38ntP/wRJ551IZ/54C185IYLMENNvKvG0NQEGCk60zmGJwosXZ7mlo99mxWL/shxq9bQ1bOGSGrmzZ2H69a5/55nKZXKXHrd5RSKk5iyTNyo0D83xXMbH+OGd9yI0mWWnbuaOUYrv/3pj7j+mksJNh1i7uXX0nrOWTxyxftJJh3SSYut2zfTPXc5jUaNMAybY6/xMWxTIlF093SjNEjLZGRkBKUhnEWlopqMa6UVbZ2d+H6A53nYtoPWBnEnTbVaJ20kME2J7zcwBLhRiCMcXK+Kk0pRrzW1124tj5NI06jXaYQGhtQ0dIGpsYBlLTaxVJLzL7yEm9/372RzMQ4dnOTiiy/moYd/iRc2CLWPYQlUKHBSaYgMkAGEmotPOoVtgxO8tv55Lj+nl2BmjFv+8Z+453f388Pbvs3xK9dw+Q0XM6UEvrIZCOfw54d2sXXj63z5a9/l53f9hZvftY5Q2agwQAiBJQzCIMCkeeKAcHZC5CFRCJ1GC4taUMVx0mzZ+Ao/v/OXLFzUy+PrN7Ai28nz5b388pOfQrtTICySToQbpAip4UdVYnbmb9bL/0/QrP+nV29/j/7o+6/FSlgs6+0iFBHS1lS1R9fAAJl0G0GlyujoJOVSjaFDeUrFOvuH8tT9kEgVKBaLNCbKGDrEsyUlUafH6aYlnaWSr7HryB4MBe+/+XpeeeU1DuwbprOjh9BQfOurX2TDU7ezYctu6sUsR8Y82lqS+CqOUlCcnkZKDz+K+MMf/sw7/uFtrFi5gD279nPOqXPZu2uSWCzNnOVtbHptP0JEmKIDTUTDK9Db20GuJcPo2BiNeohhxKjPzvfStkO9Xm5idoUFhkQrn3Q2Q7FQYk5/FxOjE9jxONV6QDyVQoclLCtGpeIST0AUQRBIUE3DQl9fDyNjYyxfvqzJbg5DVBgQBII3zQwGCCX4ylc+xqWXnMdjjz3J73//PKPDw8yU6mRzGYql2l+FuM25pf5fQHrAjml8F045fREnrVmGHxYpFOqYVgsPPfQChimpVb2/3tdYpkUYNI+PoQrexGx29nZRKs1w/HFrMU2TqfwYHR1thL7H8PAwXZ29DI9O4rouV131Fi648Dx27d7Lnj37qFebJp7AV9gxi2qlhhOPsWv3FlauXMnAwADDQ6MIYWFIk1JhiqXzFrP3yCFC00SagkZjhkUDAzz60KM4Gk5dOJdWYXHqvMX88enH+PhNNzKjK7g2TD2/i7VrV7Dz9deIZ1LEc60UXJfBUsCrh/YyI22OX72CnoSHk3Koh20EqQyGUiSnjzIzXUDKJNJ08E2TIAoZGjpGvpLHMEDLBAtWLqevp4esI5FSsmf/Pto6ugmVZNMbm3n79Vdy7dvWUfdHOG6xoFY6RH54D9V6wBmrLqbhVGiZKLDr2b089kKZLz2yly//7E4e/PUdqHKJZauXcv66S+jqX0KoBNmONtY/8RS/vfM3VAtFPv3Fz3HciuVccc5pnHjGpaw96UTu+OlX2bnnCGuWLYAwaJLrlEL5ikgrrFgSHSoaDY9EOg2hpuqWMU2JHTMRSiNsh9DzkEaEls2FuxeEmLaF6/ok487snSVxG5p4PM7NN32XO+/+MpEeA53ENvr4+m3/zT/ceDbtHWmQDSzTIApdYmYWP9TYZoqQCLfqoKUG28dB8eiGe/G8o5y5ZimFiWG6cu3sObyH1zdtQTtpzr/wWu69J8/Rox53/fwTWEacLTvH2PL6q4ioyvvfdxOBLmEKiVYh2hQIzOZSVoYoPAAMkQUlEMJmZKLEd//r35iaHCOcSuK++iqPuwe4/6EnuOCSczGkRho242MNLjrpsxx/pk9hepJqweOlrY/9/4dm/T+9lB9QrlahCpv9KglhokSEF/js3rqXZ3fvRpfrVMamqNdcIs8kZiYxRAopTSLDIJ6K09PaTSxuo6iijBQ9vXPp72qnVqsyZ06SdZdeQqDrbNiwgUwmQ1dXFwf2H+W+3/+OC89aS7ER4977tjQlWhMhyAIok5iZwwtD3CqcefrFIEKOHB7BicOLr42jIo902mb89X1ooRDawIibKK1RLixeOsC+nWWCegZEhGHadHS3MDMzQzWsENL8DNimIJ4yCYPZyDPbYGh4AidmoGnGhTm2pFKHoOFiG5CJZ5nOV9Dir0oMi9HRcdBQyE9Tr1abs2mhsG0H3w+xTIdQ1TEtzQvPv8wdP/4lS1a2cdyK4/j4xz7AF770VfJTZaTZxGkiZg0OVhNGb8fi9PX10dnexWubn2fTK4d47eVDWFIQiggVgeUI/PosAlmBMARBFGJaccLAB6G54ca3I6Smb04vuVyWHdv3YhgGnd1tpFIphNQsWbECFQgWLg6ZN7+fw4cH+cY3vsaKFcdRnJlCEEMIQTaXQmDS0d6JkLBq9TLq9TpBGNLT04PrhtTqDY47bg2TI8N0tLShYybxXApldLF82VIef/RRGqHguWMjEIZceN5ZdGYz9PQv5LlHHuSsK84jPc9l1coT6bKSbNn8BvWxMtgGC+Z0cfk1l/LYroM0JFSHDjI6kmdGlKm7Ctu0KQ3to629i6nxIUKaMVVaCFp6urGNFGedcTprzziTxWtX0ZpLousl9uzZw6KlS4ilMkzNFFl03CqCRoGhoSFWre1jfPQ14qaHbSV54fnt7Nv5I8694SJakzlOfufbGfSPkA80Ve3zX7d/m44gwcGxvYxPjjFTmGS6VGZACtxaral+isXo7+8nmYzjuSFr1pzIti1bkZgsXrAAt17Fq1WxbbNJqdMGgQ4I3WpTBWIowrCBYVgIQ+EFPraTbqontAKpifAxjaa2mQi0jGHGbRQRhtBEgU/caeHI0b3sG3yVieEyWsHDD23g1ls/wyf/9Z14nke9Po0wBSJpIs0E1SjEMG28qEqjUSeb6sELNdKM4QYRJx5/Do8/dS+HB328ekAsMU1Xn8Hbl70FP1zJtteGGDt0lA3PP41hfoZfPfgCSaOVB+55li9+6QNMDI3R0Z9GCBC2jdJh0yEsNVoIlBZIYRIChCGGYfNfX/wiV19/Nbs3bOVX9/83PVHItz72GS654mJwKxAXeJWARDpNoCIiz0VETf3737r+Ljrtrr4efcNH341tJEinJNlUHLdYoThdYOW8AaLeBThakkgaqMBlauQonudx+OgRhBBcffV72L9rP89veArLsYjH49hxm56WduKZVmy/ysatmxjoaaNYKfLM0xuYnlK0traze9cetDDJ2AFrV/QwHmpu/ejHEU6Oyckyv7zzLkIVcPToUXbu2o5peyyafwKxZDPfMPCael+/2UJiOia6Jsm2pGnrbOPA3t0sXt7J+WeczuEjR5mYdhGGjWGkGBkaIT96lL/qKISAmJMkiNzmVjrUb36rKilJ5STlQsiNN53B+z90LS8//SxhGLJ31zFOOPt6HvzDX3jl9TewYxJUU0kxf95iNm16A8M0UaED0kVrHykkylbgWkgRNDf8wgbt8/9UgmY72kjGE6w8bjmWZRGzk1SrVVJJC9OS2DFNpFx830cjadShkK9x5Oh+JkaLCEIUGgS85wMfZtmyZXiRx+TYMB2dbdgxg1CHyCiGUurNpZY5u9i1LKsppzJ8DAGNeoBtx2YddzZCWNRrDYLQnZVLKgxTYdkGQagJ/YBauYaSBtqwUa4PNQ9NRF01EAlNa2uOXVu3c911b8fSMW7/1reZmpjknOOP5w8vPceCXAtzV84jpsEJHU7u6oOah+v6eLbJoFGnYcEJK88hlUgzcmAnyVSKZKabTHs7KdvCER6NUGInUniqgRIuwrAYnyiSzraSND1ynZ2EKZeWVCuiHlKcLqBDm1INKm5IvT5NpV7AshXpeMRpJ8+hrdViy/b7WDV/Lum2Busf3YVKW6xYchpnnv4dDCPBRddfyrw5y0h5bRjpOulMjKVLVpLKtVL3NPf89jc8+uTTJM0kd9x1J8uXLaU0NM2Xvv5NQPLnB3+CFwQ40ifyPexYjFBppLCa1hljFvDELBjJaMKRdLOEoRSz+acaHfmEOiRmtzNTdCFmN30AOiKViPHzX9zBhz78QV5/ZQ9Ll88hnbYRwmGmMEYsblNpTNHRsphqrYpp21iWQBACCk1IpCVSeJgohLYhUHiBAsPBsJL86ZEn2bNvL5ddOYeGsxvHKrPz1S5e2jhMOtbKd277PE9s20V35wJeeeARdu8f5Nc/+DbXXnUFP//d9zFtA2SEFrq5cBQGWoDvCWJ2iijwMS2Hs1eu5tDhfSyZdw57dr/OIqq0HbeKh3e+QlifIkxkcVSdEBszynLamn+hf26eYjGPH0hefP3hv99OW6sIWyhiMZ9US5ZyaYq+vg5Ms8bcBT0oo3moHyuMU5jKc+zIEJVqlWoQYDsxHrj/fiDknEvPJxa3mRkfpTURp+wHTEyOkbYTLFvQxdRMhXq5xCUXnst1b/8Qa1efzJnnns2WTTuoBZoXtkzxuc9/gJ55K7jyimtRgGFBOhknDD0WL5pDpTEFQpFM2UhpUhmvE3MSJKyQXHuSWiViqjZN78BCGo0GmHBg/yRSPEZ+0icK45imSbni43sembYs9ZqLcn2E0DTcGmiJEJBKO025n9/k8KbTNu1tJvv37+THPxxnpnCUlmwHjz82zr0P/ScI6B9oZ/Hipbzw3EYK0yUsewTTsgiDAEM2+7sTTjyZI0eOYRkBToegnK+jBXT0JmlvnUNvby/ZlhaWrFiO0gLMOMmEQ3VmhiiKKJVnkLJpjqjVixBGKA1WPNF0H8YSpFI5LNMmiBSmDih5Pl093ViGSaEwTaNcZsniBSTScarVMhDDcxVhqEim4v9TqGfNGogIy4gRRQGt7UmU3wxARgu0jshl42iRQOmQSqVENpcmm83SqDao+x5xOwZIvEwSc7qGa1aJCU1DOxDTLJozj+cffZJHHngECVgqYEVHL/n8JP/4/ndxsDSO1dVGvGFgS8GhaogTs5G2hW9IOlMpzGwa2ZIhls6woOtUbClwnBRKC6bKeWQksGMxzKBBoEsUKtOgbUwzzuCRA2RzUB/eh6UjpBlnajTP6NAwuw8P4lZcIi248SPvJRbPMHRsmPzUGNdccx2jY3tYd+ZN7Nv9PLn5LVx+5TlUSbF3OOT3Dz/Gx275Z/7xI+/j2Nh+xscict1JylNlsq1pCqVpUlaWIPCIxx2Sdox64JK1bCYxyWVTNCIFaETgIZymySpUAdKIo5WLluabaS2SJBgzCAxcL2jqsZEY0qTeKJGIOzQCiMdaKNZqtOSyzQBnTDQG77zxJu695y4mh4t09GRBwNvf8S48XcJWDg0d0eIsot44RjzZBlENE4eIkBCHEDBxcHWd0AuJiZCEncMSoIRJo+HxD1edx1Mv9LF371YWL19EukszOrqTO2//LkpFuJHHH377AO95x41s2T7Fz3/2b5y14kJGxkbBElT9Iql4KyryEFLjCYXUNrawqXt1Uk6KX//wDs448Sza2zOUd42zwkgzYSqeeuJhItfAsBLNADIZQygbP1REoYFXr6GUIlB/u5n+uyjaSdvmN7fdTt0PqAUgbQOCJnf2r+LPbNxm2YrF5FrStLTEWLZsCfMS3UjTZl7/HIaPDvPnh+6nvb2Vc1auZl5vLz09fXjSYGhomkcfOsjQ2DCXXXI+WzYf5PRT1yEMZruBiPPOuZD3fvA6vnXbt3n4/kfpG4jT2zOfPXt2N0NRZxTXX/8e3vWeD7HqhJPZvnUrqCrSsJBhFbcc4tddGg2QSHZt38XcBXNnO944B3a5zf9FNIFQoinp5NS1AyhKtCR7mMkH9M2dx2/u/hOGZVCtukjRjIuXEiaGmwEYhw6U2bypjG1JLGOCUFm0tDogYWQ4z/DRPFKaCKEYH51CCqOZKi/rXP6Wq7CdNGtOOQMpXeolD1NITAuEqbDtOIlkEmEazMx2vK432XyyUZNrnGvPIYSgUa2RSmUhiDATDo3QJ5lMYguDWrWEaZpEWhGzkzgJh8nJMTo6MsSTkEhncRyJISMSpoEQklzKJooifC9szgmFaGpfzSZgyDYspDAJgoDIbrrsbLs5Bw2CYLbIG+Raupvqnygg5ii8KKCrr5PID6haklTCJqg5xAyJNqC/p5Nascx/feFLeMLCMwRh4CNCjbANJg4fYbmxGuFHhKFC2jYlGVLXIX7Dx3ED4pFAFV3yk/sYUgEy0igB+dFx4gkbbAi0iWU6TOSHiHSFyclJkok2LjnvKua0J3ESeWI5j9NXLqSlfwHPbZ5i3vz38ODTr9GezFDI5ylVihwa382cvi6uvupDrFl1Je9937v58M0XY/Wezb5tLyG9Scy2Czj79Btps5dwyw3XkkBy6PB+5q5dQn5nEdetMooH2iTdkeTI0CBe2SXX3kIsZpHpSBEeGGFidBInk0EgsGNJpKyB1CgfkE2CZNMkNXukN8pInFnUqkRpE9Ow8YOAhNWNW82jnSyRivHcU0/wtutu4Nvf/harl57M+VeeQmdyPje8+yY+/s+3cM5ZH+WZZx/ngft/3bz3AMcwaaBJOu14fogbmXh41BoWhnSxnBSNsEzc7CLnRMS0gaKBsBSeO0UqlaQRupx95gKmCr189Ys/5/IrbuSL//wZnnrxVb7xtTv5/L//K+P5gwwfGsQrb2fnKzt4+LENfOrWDyIlpOKzVnxto3SAqRUSQeCFpJMpYsLihAXz+PhHPsFr2/ajw30cjqY44muk20DExiFKAxZhFGEZHsJ0aMnlMGISk4jA/dtF++9iPNLZ16ErQZGU4/CJj3yCe3/3e/btG0Qp+P63/osdu56hXC4zlJ/C8zzyY5OsPP5ETj/5PK65+jraWzvQOkLlJJOFCVLKwJ8o8sbuA7yw4zViyRR/+eO9HNxfINdqUZpuGjFMWxLYAtsEt9JMfcnkTMqFkLZcnIG5XRw7doxiSaG1Taa1kyuvvJSR0WHWP/04A/MkxYLi3vs+w+uvvoBttLNv9zQnnnIR//bFr2DHEkxP1Zr8DqO5MFTESKXSVKp5wMQQgG52bXXPR0qaDstAUZldsmkUpmnPuqsM1l18BamUQ4RHOuVgqAxmzCQ/PcaOrduoVqvk8xMAtLZ2kM618N6b3keoQ4Ynj2A5BkoK4vEEmXiawHdBGEgrhRQNLCuGUiFB4GNbBomEA0gCz8eyLLRoSrtkJNCRgEihbIETj6N0QBSEEDYXTZFWRLaACBJOvKncSCQxbEncjuG6PmEYUalUiNlNna9pxAFJrdqUGMYtQUREPJ3EDxVKGsQsa7Yb17O6eB/bkmQyKaQB8+b0YVkW1UaDRrXG5i070EFIvlGCaoTruszUS4QSJqamyaXSVIYnWDBnAZVKDTMZJ4ibxJ0k08UZ2rI5gloNUjbKDclYDulEEsdx0FKQbWvHjFuIyCcZc5ieKeF5AVF1CqFDvvvD2zn/0qsJQk1va4y5C/uZGJ8knerkzp/eRWG6wqlnpnjvO0/j1b/8mUNTaZhzHNrqYHDY4Iuf/1dkEPDSE09RKueRZp3CzDhz+5aQTXfz1f/8Js+tf5xDh7YiYsOsO+FjfPkL3yUfHqB9eYbxY3nWLDyDH//3t/nVH37L0QMH8c2I/jlzEVGKT33m00yNTxFP51i/fj2NcpmZkmLo6Dh2Jsa1V5yGJRVSlJEaIm2DjJpOxjejtiTC8EElMKTB+Hiebdt2EPgRq1efQGdXG7VGlZZsC9sPj/Lk/Q9w6798HCEtDBlSK2ieeWaM/uPhuEU9BDLk6ME8r2wqM7T7IEUlePgP9xKTBzg8WqVWm8PZV17D6Ws6Oeskl/nHnUJfbztZy0Bgo7UEIoTQRLpA4LcTobBRzJSGSSYGqPseh45OctIJcynN+Lzr+g/gtMbZvfEJcsl21p5yERdcehGfv+2r/PDHt3HeOaejoqhp0oonwKwhpEUQSQZ3H2PtqlWc0n0G+emD5IIhlnZ28c7PfpNLPnkjaIVXKdLQGiMDKd1BpGeQIgYqxs03PMCB6e9QrM7Q0baMZ5984P91PPJ3UbTbunK65JYggosvvITnnlmPVgFeQ3PTdVewbdfjBBEkk2kMQxAojRNLcs6Zb+HM085iydK5DI8cJduVon/OfLpal3F08HU2bxpkx569TBdr7Nl/mPXr12PIEIMIQ0coNPUAhDI55VRBd1cP6VyWuXOW8eCDTzO3fzVb3tjORL7pTlI0NcbSaFpzO7o0KoJ3XH8lU5O7mRirMXy0wuEhlwiFYTWPjUKACG1MW+CHHkqZLF22hFJ5hqmJcVSk0bNzZGnYqKhJvTMMC9M0CQIPpRULl87nrLPOJZnsYGYmj4wFECl04BBPQzbj0NE+gBCCA/sPApJ585YRi6cYGz3EdHmUOXMWgbCbUi8d4VizHa1p40cS0zAwBQgibDskjBr/8z61tQOSei0g8CNMqZFIoigikhohNKYlMc1mRx5FTUmX1kZzYWSAGTexTUhiYCAIXI9sMo3v+/gyNTvDNpqPIyVdXV209WQJQo+Rw2P4nqZUqON6daIoar42SuH7Pm4QUi4XqVarvLFlE/mpAkeGhvGrEZ/45IepVipoSxATkvb2dmIJk7aubkI/ojWbI2bZNEoVhIIQgZFJYIQCXzQRApZlQMxAaIgpiRHNzss9l0bDwzUigmqFbDzJ8PgEjVqDmelJbMvgxQ2vkOvoI9faykBPJ9lcisJMmTn9C7jjZ7/i8nXHk595g3/62FsoHNqIbOnkgWcCivUM49NJerrbUEEdrzRFpOtk21LkcjnAIeG08MKG1zkweIi/PPkXpkv7mJl0+NF3fkxU3EvbwhydnfPIZZbywpMvsXtkB15hhrfc8BZuet+7SWf7+eQHP07tUJH4QDfPvvAX+tpS7DxQ5rJL30rvgl7+9Nsf09udQKsaQRAQi6WB2YhHFAKB5wfYttMsmAQIjGbyuDKaqhInxosbtrFl16v85s5fsmpgGVP5QR7ZsIHv3XY7P7/jj5hdHSw77ize+863c8E5PSw58RoeuPMXrF7d0oRPKQMlFeNTksODRX7206+jgxGmpxs8sdUnkU1ywUlttLU6ZJNZEok2LrvyJlauzZJSdQxpo5RESgXKJFQ+wjQxtOTMK97Hor4BDu/bxyXnrWTrjhfJTyepF4sMju/lgze/h3l9CzjxpFWcfPKJCOETao3bCIjFs7TFWkgLSdoXZOyIRSmbZwuTjCtNUK9hxUOoGzRSKSxARCWUnEaqLoS0uOKCf2NsbIiuOSZPPnM3aP5+i3ZXd6su5GcIFaw6aRW7d+7CUYqaJ/j+7bfRaBzGsVtJt8aJxeJUGyGJRIoDew8zOZlnJozwwoD8wV3s2r4D4g6FMY/jTz2dVUuWM3S0hJFYxJHDg4R+nTAYpDQ5SBgIfBSdbVm6W4tYZgxlOOzZVSIZNylUQ4QEIUGFNqBBhOSy7aw8YRmaFJ5fJZ8fp1ydID9ebm6TNbNRSOp/zWShp28+195wPa7vMTE5STJpIAOTZMwmFAHxpEPgNxgdGWdsbIxK2WdO/zzOPucirITFxNQk9XqZTDZOFCh0aGAIhWU5hLOMA8dupoUEVFDCpaUtg2HHMHWGRqMGWjUjnCxNpBWmNDDMJEqEhPYUMjLRdQmhwBYxtBRolSGZjBGqCqbV5E3EbAchHTy/geVYMMsUjsXiGI6NZdt4DZ+F8+cTeXVE0HTNeQ2XyvQMM40qM5UyvoooeFXqQYP4LHtEaJNauYrnBjz11HoirzkWuvXfbyGdyWI4FgmnOT9PpVLE400OhENALteKZcWoliP+6ROf4uCxI9z5wx9hpgRYTN//AAAgAElEQVSWhEwuS7VcIZVovmZSSuxYEoGBV6sTah9fNQmNQhmEKCK/ThB6SFMidJMeGKpo1vmm/idd2/XxpUZZBjOjY5RKJRr1Go1qnd7upbyxdRtPP/0Ud91zD4888gjnnXEhJ6xezX9//QuMDR1jYLHH+997HUP7Xmd4VJFMn8LmHVO0tS5i0471HDm2hzPPOAXLMnES7TiJBJnWNvr7FjNWKDFvYD6/+tlP+PKn/419ezYzOHaMr3398wSywtMvvMAff/Mkd9/3IMe2HGWMGba+9DjVyTynXXwJn/3sv/LGs8/QNX+APbu3Uw99pmbiXHLl21h58jK+/q//woK5JgZGM2hXQOgb1BslEAqBheM4HB4ssmRZP9VKnaRj4rseJjHQJhOVCvGMwSMPvcAdv7mb0V2bsbTkcH4fx/fPoTXVzr9/8T+Zv3Y58xctwJPwk89t5tbbLuLMnpNZuLaNw0ObWDQvy+e//yesmI2V7MILQkLHI27GyVqiGRysQYsAhUV5ZppGzWemWkdpg0wyxuDBGf74u/uolso8t/FVJsq7WLTyYqQcIZnweP2ZnWgWYkgDoVyWr1iIijxeff0vGKbm+rf9M4889gde3fwMJ686keOWrGbASlI+fIx+a4JIJsiddAG/WP8AulrB1yFWOgQCZBhDGAFKJ5AiDtrEVy6WGacttYo/P/gqZ66LI4X4O15E6qgZSSQidKTIpGIUplwEBvVaRLHsEoWjhKNNr//ggYNUKhUKxRI7th/g/Z/8T6Tv4nKM9v6FfO4LX+GFF17jN3c9yLyOucyUJRlMsq0LadQOEjO6WHd2B6mM4E/3v0a1VmfHlAV4LF3cwaIVOfbtO0oiGSeMfDwvwnEkrheQy7Xz9nfdhO/7TBemQKXo7e/C8zwkFr4XsO2NbWgiCoUCyaRDLpfjun94B63tbRwaOoJlWbS3teI4ccKGi2lJLCPEiYfkOtKceNpJxOw4xZkGTizFwYOHcMuaVNrGNNJo5RMEEZYTIbSBFCGmZaIjRUSInTDIOe0IqbDizS+Q0FfYlt9cbIbN/ymXy+HXTIj5uB6k0hlsbWOnbFA+jt2C7aSQZhumkSSW2g9BlobnIiRYMsbIWBFbCw4eOkQu18pYfj+NRoNqtU5Luo2777ybyYlR4pbkuGUL0UECwxIkkg4k4oSGoK2rhzZD0u6E2IZJT1c3jpMgIka1UeXFZ7Zw7bWXcPmlF3AsP420wK83msVaQ71eIuE4GEpQ8+tMjQwh6ib1cgVDwa79ezjnvJOp1WocPHCIgYF+CsUi0tC0tjYXSgB+5CIM2ZSyWRLHjlPzXKSwMUyQhkLRVK0YujmWcV0X27bwIw9pxRBVl5gSb3IoDMOkvbObRx9/nFKlQmd3BytWzCWdvpLhwyMcObyLctll1779NFQrL208xoK+C7FTZR5+epB585dwLD/Bxtc2ELND6p7P2OERVq/qwrLi5CdmuPCChfzhP/+b2zZs5N8+/yU+87Uv84Nvfo1jDw6z/+hOurpzZOIW/zdz7xksV3mm7V4r9eqcdu+9tXNUzgFJKIAwQQiTZUwyOGAwYOyxDeNxGowxzoBtbMAJG4xNNCDACoAEEghlCeW4c969O+fVK30/WuM6p874mzpnvlM1/Wf16q5+q7pr1b2eft7nvu6pU6eieFwMpccZ6jvG6PAwjQ3NjKfGSOfTpPQcU/wVw5MDEVWp7C2ogkQuX8Q2QyCd/SeFhKjYQAhBEinmCzgdAdKZEQRLQtcUspqGoZeRJBOn20FVtQenS+Sl9a+x7/gx6iNVWHoaV1xiJDrO+dPmc92Nl2MKAt//1Y9paD2HL94yj1ULjvP1n3+e9470MKNpCsf7S3xqzV1Ue1u47+efY/qUDvzOIAN6jFjZRMHGtGTCigstn2BSyE8o4KZOrK5skdkyLc11nH/BA8h2hRvy69+fpJAf5uDB7bzxyu+58JK7uOHyb7J+w7Ps2vcGTTOmUcqNMmlyJ5+68SZ+/uh9zF3SypKFS5kUaaOYTSNi40dFIMh4KcufX3wewQDNoyAJDrDTSLhBLmBYIhgGgixg2gXyeZ3n/7yTm274KjWzVYZjiX+ql/8zKu3agJ3JZSgVYer0NpLJNLF4Fku3mDl1Dp/9/FUEgxGMcpaenh4uueQSTARSyTQbN75FZNoVfOyS1Vx14UJCfpUrrrqamsZWTp7oRs6l6B2CeKqK5vYOdL2Xqy6bwUjvi4SrHRTyIrGEjqzUYRgmNdWNxBIT7N55mGyhSO+ZXs5ZvIjOzg6mTG0nmU6Ty2ewLBOf34Ng6diigiAqiILjHxtiwaAfh8NBJpuiWCzgdimV6hsTfzBAMV/CMisRS//BV5YkCUXxYRg5XC4n2VySUCiAbhTI5UuoqgtBsMmkEyAYOJ1OZFFAxkPRzOByCsiKF4CAN4zqcBEMeCiX8lCuwbYcJGITGEKS0egRRidOkM2Pki2WUGQn/oBGJJJl9oIOnM4yY6Mmvb1JUnkfklSiWv0YTpeMw+HE4wqz7d1t3HzLrYyMjNDR1nY2NeRsf9nhIJ3O8sW7vgqCxPbtG4im40yYw7gVJ+W0RkB2I5QtVKHyGVPVsQVweQIoDjctTVP50Y9+wp+ffpmFC5bwp6d+yfD4AA6tSKZYpKamhmQ8QWw8imnqVNdPont4mKPHTrHjw70EQmEES2LX7t3U10fI5/P8+Cc/ZPGS+cRiUWSlwgaXZRnbqvBHFLebYqmEJIo4sLHtSuINVKBUtuCszN9blTgoQRDQLRPd1LEME8ECy6jcsHO5HIl4HNMss/bqtfT1DQLw9NO/5uNrLkUvWwwNx2msn8ro6Divv7Geyz9+CdnCKLLqx+mZRCyRRDN06ib5aZwU4dChQ5TKOsFwFf39vSxdvJyW5jZ6+nqRRYnReAJPSw2WYpJ8ezM/VBuw5CLDNU7WjWXYsW4Pt9y6hrG3dxCpbqN7egPFhg7e2/Aeo/3dzJ41lZ17t5OjiFnwcO4FV7Ns2VKuXfMxrrh4MZqeQXU4ABlNs0mni5RNg6Dfg+pS2bdnhAXz6slnLWTJxjYNXF61EraQtdDtHNetvYVDBzbjcXYwd/Fkdry3kYDXDdkyERScgSC59AT1/iAlo0i2mMbZPA1njcKTX32AhTdcy67d7xMI1HHJ+d9kNH4Ih5VnzbzL+fZP7mTBJbMRbImMlcYs6wRkEJUAVj6PKMpoUhlBsnDgpWiLGLLAxy7+Lv9235e54dIGtu04zNKl05GQmbPoi1glmVOn/4y3oR23NIyuO2mffD7nNE9h/5HddPe9Rzqe58oF1zDed4IPEyd49/HnOPfuq0EXSYgl/KKE8z9CjS0bBIVCRkLx5BGsAEe6jrBg9lLKZgEZm2UXrGHX1i3/cyttXS8jCuBQVSYmJsjlChVYry3w6c/eij9QJhR2cnD/aQKBEH/96/M4nU4aG1ooZHNoxRw1VWEsw8Ahe0nEJpgybSbnLJjJur/8iXDNXIqWh2w+R21tmM7p04mNqpWRNEMmFKglkctjywJF3aCuqY3b551PNJojGKimVJqgbGSJxWLoukY4UoWp6yBYKIoCggJISLIDj+hEtwwypRSCVgFCBb0BrLJGoZDD7XExPjaMLKlnN93c6LpOIBAkHkviUA0csgKCRWdHA7l8ElnR8Xoj5PNFRMmiuaUR2yxh6ZWpCb1URhUVMERM28A0BcayUQTR5P339xKN9pNJpTFLKlU1CsGQG28kw9yFDQSDjXROa8Tjg6qqNIWcSjR9AsNKMm3GLBYX5hCsbaG79yjHtgWoqYogSgZOZx2hUIjW5mbmzJrFG2+8QXwihiBIJBIJli5dSkNDAw888E1kC2KxGLZSpLUmTCmt4W8MYVsC6XQWbyiIqRsohkpBK5PXNOLxOH/584944blXEBA5dGA3az9xJbbDJqC6SWsFfC4P09rbqK+ZxNjQMPm8QcIu01DfQm2omh07d7P+rXe46KKLEASBoaEhGpsa+eDD9RQKBQxTw+t1YxigqiqqpVI2KjhbbBOP20U6lcO2TcDCoShgS3B2FNGwK27As3ZWZNVJPlfA4XAgyzKiKOJyetA0mXu/9g0kEZqaGkhGU+z8cAfxZIL6hjYOHzlFMW8zfc5UXAGVuYvnoboDHDlxmun1IT766Bh+dwSnrOJ0CSSzKSa5Q7S213Dg4Ad0dx1GkqBUKhEIRyifnmBQS1CTTdLRNAuKFvlcmp9++nZe6BL45MdWYEcFXLMX82Sqj8LkWSTb4gyc6iORN5BsEacJBRky6TwlLUcuX6p8TVtANwwUSUIUZGTZgdvrp6QXKRegUNIolHKYtgNRMEmmE6ial1CVn2w2jlO1eef11/jsTV9k0wdPsePdXgQM1GA7qs+ke6SHZkFkxuorSBXPwAELw9EF0W6K/SKrb1qLeUuIVRfP52eP/5nd+x6noSHCl254jmc3PsjGNS8SFtp49PGHWHvH5eCyEC0R3UxhiyVELFQrDIqOabtxCfDB8RyPPfY9vv+Dn7B19wkmt7rpHR9g+45DdJ/exb33PsDDjx3lyL7NpOJxNr+/n/hYgvjgSabNnsx4/CjlokjezhFubuaz7R2cd9uN5HUdp6DgsUtY5QK2I1jZq9PyyIqF218FuEhm0xzdryGIs1i3dZCbVq+kZdHsf6qX/yNE27Q0TBNEwaBUcOFUPWSKeVSHi7+99DKfuHElqXSCsVg/WAbp3Dij0QJVEQXVWeK1l35DTVhi5cKpyILBcM9RtueTDI2N8oXP3siRrglKAoRDPqJjXbzxxjqaqj3MmbOQ/XtH8Xjr0UjgUEXcbhVb0ImnB9CsFGOJXoxyxb6tqgKWZWKVS+SLFVeYaCs4XAqmWcKmhKxIlLIpJlWHKtmOqhtJkvC4m9D1Mtn0BPWRILFYgmAwSDanYdpOurrO4PN5OH2qF5cik8tl2b1zJ+cuXo5WNCibBpJs43ErlPUCoigg2QIev5tsNk1zfR0Op0ptQyf79h2gd2iASXVV+ALH+MwXF2Arp/C4ZMolA5dT5mf3x3jh+QlWXmhxmXCaxrpqhs8kcHkjmEoaTc/w4YYJXn7uI7q7cmCLvPr6zezZswevJ4yhZVi5YhUb1m8iOjFGLBqlra290sO0BcYGhxEReP+DrYSC1ew7cYh31r+F3zJZumwZm/fsxjRt6uvr6R8ZJVhdhZAuk8vlKBoGiLB374c8+OCDJCYGePml53l/2xEGRscZPdGPjYRJjCMH+jGpMDFky+b4yVO0d3ZgIzIxMcGSxYvo7e3mhRdeYPfuvQgCOFQ3oqTidauUy2U8Hie6YaKbBpZZqaJ1XcPWddLZDKpTwecJYJcrwbIuZyW30yHLFdQunN1LMMChks7mmYglyBcLxKPjmKaOxy3jVr0oiospbdMJV3nIanFiiQSTGlvp7unj9dc+4J2332f5kkamz5xLT98ZRkaH+OLdX2J0OMbcGR0cOXqSya2T6O3tJxodY/nS5dTV1tPbd4ZgSMRjSLgtEb2qmryrmk+d2ccF8+bQldZYm1dI+MO8mjMZNTVqEkMIMzqYt2w2R48eAo+GbaawKIJsc/pgH6suWMncObMZHu4Ge2Ul/k7TKdk6elng9OkhVI8TSRZo6+ggU4xTtGsR5Qxjo0nq6hpIJrIc2X6C5ecuwnbILDnnKr7xL1/j5Xd/y659A3zzWz9FVlw89fgDHD2aqKQ4eYY5faaPX919P3/90y4WL5/N0eMjnBzYyfFBg+e++STzO2aRlwAsMDPccONaHILBM395Gkw/f3z2WdKJYaqVRby6eSPjiWM0dy7m8V8+SECtXGO2Bacm+rj9gvlILj/vbn6OS1dfxqJ5y/nKXWu5augagn6T5Rd18O1772TNVWtxiiI/uv9+TGGEmz+zlk9c93le+dvzbDr4Ns110+gaPoFtlfHoWSwHuIUwolzhFxWLEldd8zVyWgVmN2fmSrp6+pk7bwZjE/u4897fk9eG+MStD9C9Y9N/qpf/LdEWBKEPyFLJbTVs214kCEIYeBFoBfqAT9q2nfzfreNwOHG7ioyNmaiuAorgroR7ChaDw4OcOt2Fx+OjobEOQbCZN38mhlGmtnoSVVVBTg4fw+1wMDw0QE3YT9/AMIuXrmBwJEo6nqOvt4t0IkKVv5o5s2bjcUWJhDPs3r0b22plIppCVYJopTzZTKoijj4Bp9tEEkD2+jA1KBTyBP1OJEEmFKpDURQksRJ8UCzlcbllDKNMJOQnlUpQyhfonehFLxv0D45jmzqqZBKLR+ns7OT0qS6cbh/RWJLJ7fMZHYzS1h7GMoo0N7WQSQyTToxywapLCdUoaJpOLBbF7SlhWgWmT5tCKOIinSgyNtxHNpfBF8wTCkF3PyiSn4H+JIlEikKpTNBVT0tzhSL41e9OobVpHrZWRTERIZPrRw6uI1dIkM1kyWVhfDxLb1eOSeEriU704FC8tDR2YloKsgyjo+OEQiGCIT8XnL+KoYFB6mvrmT9vHi+//DKlXJ62xmYEt4vERBTbkkmXBN75cC9lS8IybPq7xpBEiXR/7D+uKWqqgmjlEg5VpqYmwuFd79J1oos9ez7CRqLF6UUwykiCQsQXQJFkrvj4lXhaGnF7Xby/8wMe/sFPufdf7yMajbFw4RIM3WJwcLACwMoVkUWZdDKB0+nA1Cubim63G5/HiyxJeDweXG4vbo9KMpWmWNRQHR7Keg6zrDM0NEQ2lWZ8fJxsOkMukyGTyXDo6EmSmSzj0fjZWDYwTYFSSePr934Brw9Gx/pRPY14fV7SmTwlTcflljnvkmnUhhrIRm1On5igq2cM3TDYsP49rrriSj46dIienn6Gh0aRZQdTpnQiWAp9vcOkk0WmTJ+CkdPJpvN0HT1DpLEOYeYinuzvIz4WZdz+kKd3rOfOlXPZ0D/INHQ+tnIGhmRS3TkJh8dCEoqYhoEtmbS2NbNv3z7K5RLt9ZXZfJfTg2FqmKaJ1+OlY7ILp1+mXNRwOKBtciP+kBvJcOP3+ykUSrg9DpavWITXVYnpEpUU99x/Bw892cHVl19BU3Mnrzz1NCV+hlwa5PD+Ie65ewXntnay4o2pHOz5kOOxMrOWzmTe0isBhfs+dz0TWi/b/qrx+GPP0BXdxAsvvgK2wpsvhog0NfHNf/0qay+7BdFXzayljZh2mfGom0svvgHT6mF+2xyMSA1P//q73I6D8KQ2RAEmojnuvvNiTMkglUrz7e98QMJ8l7nzJ3HD1avY/UGZI0dPMjC4m8suX8Xr617F44LvPvgQ/WO9iGVIZrL4I0HKegmHDdv3HuDLd3wbVQlyzvKP0zvSy/0/nIpl+njqD0+jlwyuufxa9uzcxOSdr3DhRR/7p3r5f6LSvsC27dj/5fwbwBbbtn8sCMI3zp7/2/92BZuKCxDQSmVsqzKpoWlFCsUMbmcVhq4RDERIJBJ4PSFGRobIuYrU1zZw8PDLfOpTflrbJtN1uptURuCV9du5+47baO/spGnaOTz/4g4y6QLlXJZAcJyONpuLzlnFtndHsUQHwRAU0haxRJ5SycYoWMTLZbLFEsnkPoq5OG53EI/Hg21LJBMZFNmFJAvIio1Dlmhrb2LylGmcOnYEnzeIZZjIhoLq8OJRkxRzGjfceA2ZVJTuvl4+tupmymUZFIm777ifSCjIe2+N8cVvBjhn+RzaZqepCoUYHXkaU1PY+PcRBAlWXDCJxpYcB3veRB2p2IPDDpWCpjF64gQlzcVAd5LG2qnoBuS1MvWRVoa6FNy+MaprvZQKMYbG9uN3LMPrWoQkh5jIHsfUnIxFt2GIMGXGVIIBifhEFpsBvO4IB3atxxGswmGbFMsakeoACBXGtqo48fndhEJ1vL95Mxd+bDV/fPpVPnH9xZw60V3JhbQFLlq5hkd+8XN+/8QT+LxuFsycTTgYor6jlebJbQwMniJSU8137v8+j/3ySSwL2puaePgH3+b2z9/Nro92sWzlhQyO9JEpFYhGY/QNDOAURf6+8Q3aWpp59Y3nWP/3jSxdOoOrrl1LS0M7H2zfwTnLl7NjxwFyyQlOjnShFYuUDA3TtJHLGm7JpOf4KcbSRXRLZuGCafiqa2lqaqF58jT8YYWQz091bQdCVSNKKIJLlAn4/LjcKidPnGHdq6+xcIGLj3/8CizLwNQ1SsUMhpnHMMvMnNeI1+shlzeRJTdtbVPRzSkcPXaYSCTCieIZxnsmmLNwLgMDQ3gC9TzxxxcZH59gy1ubqK3141advPH6RqbPmUouq1FdXc327dtZsmIpu/bt58HrHmfkzBDjsTS1oQDBSBXPv72Fr85eQiRZYvq8+Zx/7kKm+sIolkxrdR0tShtd0Tiy4iRnxagOBMjlU7jdXuLRNEDl5qXaiIqEDehWAavoRpANhicG6Ohs5oWXtzJ30TKKsQROj0VQBUE0GBgv8vSffsM1l13I8uXnsnr1xSTSGRYvXsrV111MOjNA5xI/FzVO5+BgHzXBaoKTm7loeiO6YTGaBpdaoCCWyHptCpZB46VpXrnrXgKOBwgpKlgQPQ4vvv4cmzd2cXjL3/n7picJ1DppUVV6R05wOhtHEEWOHDjBbZ+5i3vu/DGdtYs475wZvL3zfX788+9zx+ceYu68JXzr3y7j8V9ejcXVdJ/uxigUmYjvZfmqi5k1o5MNzz3Piy/8jo66Czjv3NX4Aw5+9PivufX2e/jVE9sIhByIdpHrL1vG/mMbsSx45vn3cfXarFu3n6pImEWLbufMvt3MnLuMmuphpJzOe6+s/6dy+f9He+QqYNXZ588AW/kvRNsyTdxeFdD+4YC07UqfsVgsMmPmNKLRUSxbZnBgjKDPz5Z3trJk0TmVmVFFYHCoD61cRjcMAoEA48MxbClIU9tsNrz5Gq11dRw7OU7b9FYWLpxGNP4qLzz/DIV0E/FkiVhhEEu3UAQviuwBy8Dvrcbl8tDU2ILT3Vzph7k8xONJ5syfhW3YqFIIURaYMa2ToycOMNDfw/FDx8ikK27CffuOYQEujw9Jthns72LZ8oXs2f8hb29+h9mzZ7JkxbmIVi3hUCcmSVIZlf2HjuFxFpiIjjBrZhtWuZFgOEoibnDyaJy6+hoWTAtg6HnyJROP7CWZzrJ73wguzySaOuqYPKsJ7ZQLw7SwnYMULZstm9IYaEyfUcXcuVVki0dJ6kcxNRG9qCOpOlMaWilqJfpP5mhtDPGxmz7Pw7/eTlkTaWhqI6PplPMZJk2aRFNjHROxYQxDx+n08LNHHuXA/i8wo7OeWfPmYAs6uVSKeC6BaMGCxiZ+9+uH6Z0Y4Ce/fohyqUQym8Hp8nD6wGHe37kF1eOmoBVoa2/k0V88xIu/f5bLLl3DqnOWsf5vr5MppokPjZMrlMgXSgiiTb4Ux9fRTjKRortHw+NVmTd/Dpes/ji6ZmDaFk63SnZ8jP7RbjLJAheeuwxX0EmzFKEg6MTL4HG5mDWzibJp0XfmGP1DE6jeIDX1k/F4FPpiI4xoGV587H6qa1q54ZabKSfKZDITxGMmPd0DjEdTuN06sXgKwyqjOkQmJqKEgk6cTieC6CGaSCDiIVwdoVDMYttuAv4wkiRQW+snlar0xIvFIrFYjPNXrGT3vv0MDp1h01t7mTZlChPxfuY524knEmzZuoPYRBxJmY/Xa/P2ppfwhDqIHxui12FRN6UV2baZ01LP/Gvm0R6dS8jrZKCri4AnTDFWxiV6MLIjmCgEDR+CQyDgrSabzSKV04CBLNmIooVlSxUcqSUgiSaFYpHqSB3RiQkWLZzK5+++m10bn0C2HQxmk3hkN4/+4geMDo3y858+xjVXfJIv330vF110OecvvZo/Pfsjnnn+EQwjR9IWCOEiO5hA9UUoFGwy+QxSxCbSEkayZVyCh4IziLemmoG+CSLVNv1aBlGCGbNa+OKs6/mSJVHKl5n7hxl8675HGbEnmNawjOtmKpTNFNG8yeZNG+gd6sMteDl9ysHQwBnO7DnOmos+zoY3C3z3ey/wlS/dSigs0NTqI5VRefLxX7NwyjwOHD9ITdCJWWzgT88+RU7UWbBgGfFoP/sOvsOUuZ3UN1QhWyJ/f20rRw/2YmomZwZ7KBsi9913N1esnMJXvvZHvvfwQ8Qn+gl6PEyqnsQjj3z3n+rlf1e0beBtQRBs4Le2bf8OqLVte/Ts+2NA7X/2QUEQ7gDuAPB4ZJwuhYqzSkLXyyCAYZmYukUwFCKWGKOqKoDqlrDRiFT78AdEcpkSXqfBwQPv4/J7sWUR2RJwuYps3/0W0+e04gvD8UM7uGz1aroHenlry3Y6Wr3Ydi2ZfIy6Sa1cPOt8isUSoxPjlQgwj8S0yZ24VTepfJrauhrefHMd05vraJvaQilfQMsVEIQYzz37CsdP9VeilUyorYmQTCbRdRPLLlYg/wEPWh5Onsxx8tQwliWgqC6OfrSdV17Ygdvvx3YNUYy78FTVUF2vMHSyjEMdxyE3kSx0c8PNs1DsydRUTyWV7eFwzwvYpkVNqBqHZNFQ7cbpyuHyFTCdSQpCE5qhEItZVIUjTJ3WwfyFTjyuGkzNRcDpp1SOInvzlNUS44VDONIyzngzDs3BTLGFraVdXHDpHI6OfxLDKGMqoCWijI6OEo/HyaWTVIU9yA6RfD7DrZ/5NF/+WohYdILRRJTrbrgUWXUyaWCYP73yLFoxzeZ3XmU4Osb2dzegqA5ExYPD6WT3vl3k80UaG9sp6yWi0V4iYS8XX7eKA4cP0DA0nZIoECvlMW0X8UKSjvZWzpw+gWVpDPWfpKW5k3CkBmyL0ZFBjh8/ybwF8wkEg0xqqEdPpamf3si8oJPiunUsap3N8K4oW86cwPnJz5HpmEWvz8nCtipqOpx4gjpaOYctulh/4gx7u/dTbC7wy38NsfetA+zc3MAkTy2icxyHGmb6rClce/1ajhw4ymWXXe3p5zoAACAASURBVMqmbVs5cuwgtmzS0FDHnt27efSxvzB3zgxiEzmGhob4zGdvBruEbpQIBhupClUxuX063T39TJ8+nVgsw86dO1m+fCVz5i6mKhJgZHiQGbPmEY+lScYz1ESaUR01nDo5TtjXQmI8SWuzQrZR5bLzVhHwuOjuOcpll5/Py2++iWoJrFh2ORl7GGe6SGtTPRl3CY8MyVSMqoAHwYJiMki+GMOripjI2EKasqFV8KNiEUOzSCXyVNfWYJcEBC2A311m0wu/YMPWQzz52ze47apZzFm8FKdrCs899wROdTKaQ+b9jw7g9FlMWfJxvvKDP3L/v/+ef739C/iCFlqwBtGRxRBs3EGFYtxBVdhPRktR1vNEvCVUt06tR6U5EkYQ3Vh2pYWjYZFNF/A7RNwek5u/PJtbvvoKIiaCpfCdL71F7+gOPnrnEOncSRrbZqNbcXac2MJVN66iZ3gTr734Vz5909dZe9U9PP3ENlLG+6y+eAkNnrkMd+fA9DKzoZNjJ/M888qvME2JG+/8d1xSnmf/8jaC7UDKHSHRUsOaNWvxzlnMp25ejUMRsE0bUdKhqPOJa7/OjGU+zjnXw+mBCH96+Y+8/9EYdY15ev7zMPb/tmivsG17WBCEGuAdQRBO/t8U3bbts4L+/3icFfjfAQQCsh0IBBDFPKZhI4hnaWGGAQL09PRx8OBhaqqrKeQ1wuEaWls78HqCSKJCY0MtvT2nmNw+mWA4QDZVxOcKMDE0jGJB15leBJefU2cGmT5vNqPjToajB3C7nMxbNJ0dOz5Cly26uvs4ffowxWKRttbJPPHkn7EB09BpbammpqaGXXsOMXf+PC677FIKQpZ0osjxE/2obnCpDgRbJJutBDTYIrz3/jZqItVgytiG+Q/ancPtoFwsoKoqZV1DtgR8Pj+1dTk0c4S8LpMsJNDiBpvf207ArTJ36goaqpdilBwUUlFmtbcxMT5E39EYLXUuRGEylPKURIVSroCWF3A6IqTiUOVeRWPocoKBCIFgFYJlk8voGO4UyeQE5VwWh1AH6gmy3mPocpberqMM51Ns2HCQbVsG+Jfbyng8CkokyKSaOlxuH6ah4fU5SOfiBIIVZ+O6da9hGxLnLlvCYP8QosNBWRA409PD5NZmJoQ0/vp6DMusTMTYYFhw3gUXojpcjI+NUS6XqKsLkEpMYGk6Vlmnv7cX2wLVI5Mu5HB4XKCIrLxgJeVinpnTp3Ls6ElsQcTpdBKLJ/C5nIiyzMjwcAUeVcyTHy7j1A3iuotdQpjhJotdvSmquz4gnDzIbx/dTm/faAV2eBbBKNsKBiaOKjf+1fUkWus4dqQLQieZcf5kJIdCVbiVt976kDdff5unn/oza6++grZZ0xgcGyQSlOl3OOg61cX8uVPp7emntqaZutpa+vu6UVWVpuZaTNOuTEY11rNz1160kollizgcDvbv38/mzW+zbNkcdu7YRlNTK6LgwqVK6LaAx+/B43Hj9/rQ8wUSJQ2nKSOJTlJ5A1l0EkuXyUbjTGqbRpYCRcumoBkYloBpi1iSzKmeQVbMmw+iVZldt8OUTROohCXIkoyuWyiSiNvtRBINBKFIMl4kFsvS0FTPmcEJrjz/HFbNaiNQU41gw+9+/1c2bniT1Ret5uUX3uPyi6/ktttv5wdfuouqcB3XrjmXuAWpWBm9nEcvFdEFSMfLlIo2DlUiUO/GIYMDB6IoYVOhDMpIWHYlPEQSQPSDA8AQQCij2xqa5sKjwkO/Xg2sputUmr0f9vPVf/0yDo+KpdlY6Wa2rDvAoYMDaGYGtyRy37cvwLTns/icqdy29qdcfeVNfOeBW3h7/bt8/1ePsu3McapCXvZ/cJili1uYGD6Mw3El33/sa4hnqZTtrhCmDfl8Aa/Xia5rKG4fF12xiLvuuRW16kKefOYnDB/qp6GumubqSfQMnf4/L9q2bQ+fPUYFQXgNWAyMC4JQZ9v2qCAIdUD0v1pHEBQcrgCiNIIky5VK2+YfwP1iXiOfMYjHMsQm0vQPxHCqET7cfYSRkRHymo3LrVBbHeHY0YPIgouA20U5m+ThH/6AupYaNNFJzkwxfc40XL0Gp099QF9/kifWvwiWjICBjchd99yGQ5b45S9/g26VSeUSPPS9H/Obx39DX/cE333gftpaWvnCbV/AMnUw4YJzF3D9xy/npWf+QiqW5upbrmb29NnMnjmdQirNeF8P0bEzXHHlNVx62Sd4+uk/E4slKAsqWkFHtEBRDVxeCOEnlykg2dUEPVXUTVGpm+RAFR1MxKKMx97ENDREOU2zR0YuhTl9eJT1zxYQXIcoC6B4y8imi+R4Hr9rMkN9Q8yctZKuY+P0Dvah6TnqaxrxesEy3KTT6Up6vLORMgnOjP8df9CLq72JhDXG1h3PcvWV09m3dwcvP/8crpCHL991J0MjKUSHQjqfBVEgnU7ypS9+nfu+9g0CwTCT6mooFW0KEwkyhRzjRY0tr/8NI1/C43UjSCJOt4dgqIpIpIbiUJK2tnYC/iqcqkKhGKehoR6HKLB/31FWLF9Ed99JbJzs2X+QBx58iH37d2DoFi+9+ApP/eEVPtj+ZiVYYGiImppaBsYHaJ3chq+piVwuy8Hh47RoTmpq2nhk02H07UOUC0FERxsnt0ygWCeYPb+RlrlVbH33KOQd3P4vX+OjXQc4seM9prYvY/kF8xD1HVx95fl84TtbWDH/GnQjSldXkjWXXMDe3Tuo/tq/EJ0Yp6O5lUw+S8AtMNg3wtHD3SRzoEhBBNtNJhNjaDCJpmdob28lk8kSClahOF20NLVy+kwvTY3tnOk+TVtbB+lkFsOwCEeqkUQF82zaee2kWgoFg3whh8spU1UTxNA1GjvrSBbSlHJlWhvbGR6boKmhhkVLp/PRR4exzTyj4z24fR50S6e6sZah6DjJQhHF7WLukum4/SVSiTGGhpK0NIgYuoGiyFimQCTiIp8rMx6N4fH4aGmscICqXW5OdUUZG5pAt0xAJBktMTKQYfe2GP/+7//K8e59HD44wCVXnEcslmfP3s1EExpm2eCyi5ahaW5swyI6lsWpKtR4vdilHKrThW1aOBDALlTAVEYJWZQRENEMA0kqYgKC4sXSJWRTp6zkKQsWMiXSGWhpDtE0tYVb7tzJ7MZL+NxtN6M6Sxzcnea2z9zCsgXncWKgi8uvu5Abrr4Fl+Tj89/6NPlcgomYQsYd5v09m7jhM9/jsV/dxa9+9jg78jkEGy49bw2CmUOQvdiijmWJIBVxug2yhSRet4plW9x51ycppzT+/tKzuFMaC6ZOQVFMNL3/n+rl/2fRFgTBA4i2bWfPPr8EeBB4A/g08OOzx9f/q7VkRaGxsZmamjFGRpIIImBV7N+CAI8++ih62WTTxs0IgsDuHYewbZNwOITH46GuuYHe3l6i0SgzZkxj/87DqA6ZyQ1T2X9oP6Y4nZ/+8jGiExl+/JPvk8+M43NreD0eECHkcjFJKuD0hnjq17/HkgRUu1JdRVxVFBNJDK2EAHzvuw8yZ9ZsyprOp278JAIm3/iXe4g0VrPmqktwud1EWpoQDBgeHGJ0IEltcwfvbt7E4nMW8O1vfQcbCIfD5HI5rrr8GoxymfXb3qSsF3A7Amj5EsN9AmtW3INLtWisraOQdSLX1WALaaKJXRSKwwyPfkgpb3L12ll41xoIUpA7v7YbbUJHCQtopQI+byOG6MC03PiDLkYmhmlrrSccVLFLNi6fC8UBAg48gTqGkseoF/wkMxmSuQTnXbCYfGIWzz/9GI/87Nv89smHWXXVdfzkZ49wxxfuIZHJYlkGTlUkl8sxMhrl4Yd/Tm1tLfliDq/Pj8vtIXo8hlXWuPrKK5FFkXColsbGRvr6+ug+3UO5qBGqDhKNjvPd7/yQ+fPnseK8+ciKTSAQIJ5I4XBJeAIOTpwc5o+//wtvv/02j//uUSzb4Kk/vEJNbZgXX36JO+74PMWiRiqVRHI7scsGE4kJFIeAbpTI6Toep0KsqGEXB0Acg5yKKCYpWLBj7xiKo5ZLF34Ob1DgDz//Cdg2givE8Ngo/Wd8vHNwP6rPhycU4HTXR5haHK2gEvYEefjhRxkcyrL4nEV88uZbiKWTZJOD5Aolzl1+Hhve/gDdLCOrIslUnJXnLWFsfLjSd1dVCsUcRiZHT08PE+MT1Ne14HS6MQyDffv20t5ZQyAQoCoURhAs8rkk8VgSSXZVAoqFEPl8iZIlQjSOYHhJZvIonhC6VkTTimQmUux4bwtefyOT6iI0NTWRTqeZNm0am995l86WNiI19WQLMUYmYjgVo+IJKMuIkoheKiEpLtLpJH39o0SqarFtm7JWxKEK1HUEiJ4+yaIF9aTiafweL1U1CtU1NaTjCZ7+7ZuYhs68eY3c+ulv8+gPf8GS2Yt58q/PU+WKMNAzRr6Ux+MO4vSoDA5ECYcdeORKG9UWFUzLRBYrOmHbYBuV0GhVFMAOgFT5zVTRQCvn8bkkNAxsy4nH7yUaN6l3BxDNMnd/4RMcOrKDZcsWsOzuDvpHWuk/FeO9t97i2mtv4sEfPYJlGJS0NLLLQbAFrmudg43AmlWzcOHhiaee5a6bP8WrL63jvAuXURYmsA0Tj8uBRalSiNoKLocHyy5jaFmGT+XIReHxR76F6olw6TU3ojhUorF/PnD336m0a4HXzlbDMvCcbdubBEHYC7wkCMJtQD/wyf9qIUlSmTy1k3giy+jI/koFC3DWkSYg4fW6SGdzWKZJMpXBsiwSyTwCEv92+SWcv3QJe/cfpJQ3uOXTn6K1tZ0P3t/KLddfhS2Y3H/f3STTKWoiISxLp7k6yP49B2nze/j8XbczPj7OR7v2cO/ll6O4nLR1dPLMU7+hqJX41nfu5Te/e5RJja0sXLCULZvfQ5Lg5z/7Hv1dp1B8OQp5k4lCkljvIF0vdZEu5PB4vRRNHcO2GDjdh6aZfP0bd6M6PezeeZDm5mZcTqUS4mlAOpmjs2MyE6NDXHbxZYwNVKGXU8QGoWT3UNV0EqPsQLDqKZfamNm2hp6hzYxln0Exy0SqZ+JwugiECpRxkUyN0dTSxFB3hmymiGjXMCnUTjEN/dEc4aoA0egobo8Dh5Ri5/bfk7dOoVslbEmgKtBMwl3N1MhUrrj0d3T37+Rzdz7NH371JLfeehfHjh+gsamdfD6HhcTRU0e58KJVFIsa5y5dgVYUmTZtBnv37kdRFQ4frkxHZDIZxkZ28tvf/hFJgN/85gnyho3L6WH9318DQWLb+zuYPXcKuVyKBfMiFAoFXE6J81Ys4dabL8DhVPnc7Z+jmMsTy43w7W9+kYd+9Dh/euoFXnt1A6+88hL5gkbIE2E4nsQdrsbpcuDPeTB8BfqKw4QboOv4KO9teQ9fQOLkqZ2sve4bXLBkDt3do4zs+RuHjQy1NR0IsslY1M94PMnhwWEuXtOJSw2z8eggiVyUB+77On1nxgl43HSdOcXKpRfx4jPPsP/UCdrbppDyenCJQwwOjTA2Fq0kLukikiShutyEQiHefmsLU6e189GBfbQ0d6DrJpqms2fPHgzTYHh4EEXRSSXPp6yXOHzwMLXVYVZfcjlV1W2IksyZni727d/FdddcC7aMS/VjCpVOTzIHOw4e4torr8frUll54cVUhaspamVkUcE0LAzD4NWX/8Lkzk4uWrWaH37/HtZedw/1LTWMDQ1TE6nHrTpQnAqmZRHwB+jscFLImWRyaSTRyej4OOMDBVQ1zPBImWJRY8BMU1vTypn+M6xaPpm5y3LYJnQPa/zkodt55IHb6Jh/LbffeC2CoJMr2kQIY0kiTodMoaAxFhtjsj+EVS4g2l5ERUG3y9joOBwSelFAkRVymonXEwBTRMbGxCaVKVCrNKCYZZCdCIg4xSgfHTrFr373Z3rPDNPaNpuRYZFywc1FV0zBcVkHmnqM/r4RPth6kiXLzyEcuZix0W1cde1qnvj1Y9RVVXPLDatJxrKkx4a56Za7OX76FFcDkiUhSiLY0ln7vAmCfbato6LINRze/yrf/OktFMUibsXF+OAA7csX091r/p8Xbdu2e4C5/8nrceDC/zdrWZaFZkiUdRNb0JBE6R9xO7ZtUSwWqa6upbW9jZaWFhwKzJ4znUl1IT7Y/j7NTe2sW7eOk6e6mDdvAR6/j1Nnuti580POP+9cHKrI5LZmbLuJ/r5uIlUOFEuks7mJiz+xgqtvup6xfJavfPMrCIaF6nahiAoTRY1MqUCqnGT3uvfwehxs2vgOwbCfzo5WXvv7q1BMsWHTa4S8YcrlEgGPF7NUJhAJYwcDVEVqEB0yjStX4FDcbNm6F6fqo7GxkcHBYVasPIf1G95EEGUMXcAyRWRVwKCAbqbRzRwefxCr7KzA4h0VRoqMSaqcQJfHQc0TCroRFY2CXsAqgikVkQoqkmxgk0O303i9YXIZk2CgFpfDA4JFY5OPRGKAbL4HWz6OYuQopC28fifR0Qk8rhY2vvU3br/zenzeAOlklEsuXcHFqxfwm8df4rsP/hs+b5iynaWjYwrrXtrC6tVraGxuJZPJIEgKgiJj2hX+tYSA1+UmlUoji0JFNHJ5BMukUMxx/vkrefP1d5FllaHBURqbaslms5gIVNfWYFkaPn+YSFUds2ctYNqsanxqFUdCB/jsZ29iw4YNDA3GKZXLxBJZFLeLUqFAKpfHZzupC0fIiEmS2RTx4SLL5y4hFY+R14rUt/r43W//xKneOKFIBydiFYbd2NgJQEJ2VmNqAYp6GafqRpQMstE0uaoc27auRzC91EbqUHrg+99/CEkQmT13Ljv37ePuu75KJOTl/PPPp7o2QiwaJ56YQJJFwtVhPF6Z0Wg/oijS0tKCLMm43W46Otrw+HwUi0Va2zrYt+cD9uzZQ0dnC4ah09zcjGmaaJqGz6fi8riZNr0Dh+JhbLyfuklO0iUTh6CQypVwuVzsP3gIpyIjCjKpVApJcWCKJi1NzZQKRZKjowz2dhObOcIlK5cyc950kuPDjKeTKHIr8n8YiQSFYqlALJ3AgRfd0PBVh+nvz9Dc6SQSCqAoCopSiYQrGzqO6moMMUfRzuGTVHx+J2XbIJrMkxhNktE1hgcKOCSdTC6PK1AhPGYnSnhVE9sSsAURW5EqjmRTBMmBUU4jyA50sYxbDpNODeEPNXPqZC8jfe9y7MgOPvfZX+KMVPGXp1/k+IksP/7Z7QiiSEPjPH76wx/g8ZZom+ojEGhh89ubGEmdobY6wN7tJzGLLnZs3IWVO8nPfv4XNr79EqpVGXcdHx6itqGVD7ZvZngoQ/9wmXu/BorTRhBEbFsHxH9omiBU6Ifl/ARXXX81ZhacEQe2AYVSEZfLQygUJpb4z1sk/yMckYqq8syfX6SYTeLxQS5jIgnus/bhMqIo0N/fR1+fyEf7DyOLEq+/+haKExqbG5EIceTQYUbH4owMR9m97xDzzj2HecuX4Ai4CPj8hPw+Mtk48xfNpPtMD353gJJSYN/hjzg5Pkj9zBmMj4xS4/YzMjhAIBJGViXGUnFUp0QukeDzd9xOwFfDY4/9gWSiwHN/fY0bP3MDF121Fhwyp7u76Gxrx+VUaZ86k63vbWfj4VMsXLiIQEogNjFCU+MssgWdobF+fKEmfvjDX1AsZfH7vUyMRFm0MMhAd5TRsT5mdSzFsi0CEQtlrI7cONiChdunoWmnOTX+HNnsMDVVzZTkEXQ5Dg4JU1CQlAoHxeOTcDg1uk5/SH3VCA0NS8ilFApGpY/v9qeJ53cxMnoQlyeEwxAIBErkMlk8VRO8/e7fWPyx3/LU81tZuaqJh3/5W85deinJRAxLN7h4zVIiVXUMjR5k+7YB1r+xjUKhRDA8CX8gSChciyJXjFL9Q70IioVt2mzduhVRkfnEDddSlk3qGiaRT0XR9TJtbS309PSxbt1bLFkyi6VL5hLwenCqEhs3bsMyTH70w4epjdRy4crziI1n+NI9n+LTt3yGLW9/iChkuPH6z/PIL37KwV37WX35pQwPDDJ1WifP//0NZs9voGfzIILtYmAwhGFNIRKZRCyVw1lQmDzZZvGFc3nvwDtEdw+xbvu7uJVaJjUFGO9xQlKmNDqG119Fo99FPprAFl2c6vtfzL1XlFzlmbZ97Vg5dXXO6la3cs4SQSSJDAYMNiYYbGBsbA9jG49JNtgE2+BhbGwMDBhMGpJNBhEFQkIBJZBQ6m51jlXdlat23t9BaWbW+td4rf/g//7l96COa9Wufa/nfZ77ua9Rnnt1Ay01lVx4ziVkjQL7jgwQiEV4c/NGiuOD5FKTzJjfhih7GBicQHBhfHiIqroa1q9fT0UsQD4/hap4OXJkiJ07d3HGmafy4osv0nv0MOeddx6hUAhN05g3b96xZxxi1+6t+ENxkskk9Q2V9PUfZiqfp6auFdctoLsS4YifTn8L+/dOYbug6Q6ua1PrC+FVFeqrq/HIKunxHl78y5M88JtfI+Dw1O/up2XOKnzeY1krlo0kymWsmKJQEa5GK5ZoaGrhSM8UNfUtWLrCwICBpAoIso2ml3AFlUjAy+hoiVJOwyJBQBFxxSg/uOan3HbX9yhM2uhajprmRqLVVSRyOaqqK8BNEJQMCpk0RmmEaEhBM0qIYh6ccoSEKan4I40girzw7F84++wrqKqczgXnXMQp6+fz8dYPqK1p4ZJvno/iqkxr6+Du2+9l7vwGXn/7DQzNQ2oqzB13Tefssy+lt99g5dJq7vj5Xdx617WEvXGe993JY3/5hJ17CyQSe3nqsUd46bknAIsv9+/la5eez+w5c1G9NoKg4poSgqSDICKJlL3MjosgKBjJGN5mkftvfYjb/3w7C2a1Q4VMXlRYsvxUunr2/K96Kd1+++3//6nz3zm/uffXt9/ysxuIxcPs23MA0wBRKE+DoVyJr1mzBsMo0dzUgGmWMT+Fkk5yYpK9e7+gUCrnd6r+AJIgMTYyQWoqzaZPPqW7q5tUOo0qe5A8Xpqb24hXN+Dx+/H6RRqbGlgybwGtDXVMDvcT8slUBnw0NTaxfP5idC1DZUWE1FSRPzzwEI2tneQNg8lMlr8+8TynrT+ZiCfCT2+8n7df38yJaxby1vPv8OCfnqXOH+GkFWsYz+QZm8zw8oYPyBZLXHj++QT8Pt57ZwORigpM3QVRYMacaYwn+4lFY8xpW4Zf9lIZascXyuGQIRr14wpdJFKb0ISdhMMGgqvhKg6OGeTjjzM4toTHp2KY0NbewVhikMUrFfLmdppqp9NQWwFWgsbGEpt3/ArX+wWSZxRXSOIPKtj5JiwzgKFHyecDTCQcxhO9rDvtdGRZIl8cIZ/Pkkik+cvjz9MxvR1RDHDhVy/kg/c/QhIU5syaRSQUJBzyMTTUz9TkFIVijuNPXMPBQ9188vFWqmsqWbZyOaFIiIA/TENNE7YNzdOaOXBgH7qhMTI8QeeMWWTyOYaGxrn55vvonD2Piy/5OpaV4OEHH0UAlq5cxIyZi4lE4+zavZt1Z55G/8AQp59xPps3b6amuopioUBtQwfHrZrNkqXzwfVz4PBniN4acs4YeXOIYmKEyjo/U70J6oNxajvm8/DdT/LOW9tJ9fsx3SL55CAXnLkcFA8Zt56AP8DshdORBBmvpBAIe1myag0lo8TEyBiH9u4GwyKTTtHb38uzTz8FpoNsSeTTWXTLpLWlhvr6SvwBDzV1VXh9AVSvh6bmFt54YwMnnHAia45bQ76QJ5VJMr2thZrKKlS/l6GRCVSfn9q6GvKpPKJUYKB/jMbmeoK+AK4iYeka/kCUkEegtaWZ6poGdF1DFAVc1yEcjbB1+3bmzZ+PIMG+/YcI18jkJZPZ06fx/PM7OPvMxdTVRZBVCUmQAQFTEMnoGnnRw+jkJE21cVDAGwoQjKlU1gQolBI0tFYRifrwRcpGg4IlU1+lUN9Qxb/f+wwXXXw+FY02thIiFAgwmdUpajqpXIZ0SidWESUYkIgHpxCtcSStiGhkURUNXI2coRGumsWPf/Qznn7x9xiawgXnXY7P5zJ31mnIXpVPt+zi1jvv4vb7f8+Dj77AqpVzufSqS5G9Dg/8+88ZHD5EXbPGnx99kJv+9bs89KdHuPc39yHJAkvnz0XxKAAsWdjMsiXnM5AY4aXnH+PTT/fy6H88z8JFbXz80SZ+9au7sCwNOMaRFEogCLiuBAK4goWLgzfqY/kJqxj4Mk/f2C76BwdYMvsCJhNdmCWdgcH9o7fffvsj/0+9/IeotEVB4Oc/u4Pauko6Zkzniz3d2I5xLItaREBi69btNFdVU0plkSyTM9evJ15TQzAY5riTTmXLlq3c85tfYxoWU/kEZ5xxPompBOeffTaLFs1jWms9Qb+P5GQaWbXo7e1jZGyIZDaDqShsf/xxNm36iLvuuo1cLoPsC3HtD3/KqWtP4Yz1q6ltqODNVx9BlWFoeADdtqhvqGVkcIING3Zz0WVf4YFH76K1ZTpNTVHWnHgmQiDEopmzaG2qQ1NVLFniiqsuBwT2fbGb3q4uEGwMw6IqXsfIaC+CbGM5fmwHJGUE14wxPNSP11cNqEi+LJpzGE3qJt5k4hfClBJxBE+ZW6fIwxQNA/AAMg4yHl8YR04jyL0c6trBrFYfuEk273iTgr0VV/MyldSwND+ik0MvZlE9Aj7PHFzN5bRV3+Dx7nv5+MM3uOKKK0hN5aipq+aWn9/AL395F5/t3M3MOdPp7sqiFXU6p89AVkRMq4TPX4UsKYSCYYqlDHpeIzEyAa7IaaesIxQIUBGKUUjn+GDXXuYvWIDP5+Pc887j8ceeJBaLMTicRJQUjvYOYdnw1NPP8PkXO/GrCtd/93J2fHaAc8/5OulsngWL52E6Nr++9x5+c98DBGJ+An6VjR9t4LTTTuGJRx6j+pbvktXSTBam8MiVhEIqq9eeyu49H6JLJc5afza+7xrjMgAAIABJREFUkEoipeOTHbZ9vI3c6AgRbxxdiCGIXu7bsJlMLoc/MIsl7Qvp6e0j7mnELpnorsW//vxmZk2bTsjvw9V1PJbGZCHNvAVz2PXZLFwDspkpipbBRHGKeJWHcFilpjbO0NAQrqsyMTFBqWhyww0/JJvNks2mGR8fJxzxsWfnLhzDQAl4cAQv55x9GZFwkOefeZqVqxZh2jqu5sWrBHGEHJ6QikEKU3PoH06Tyxbx+TwUii6qFzx+gVQ2Sd/QEKqvgobmWQz1pmjqmORv776Haoq8/kYPa1bPxBZsZMo8T2QJ3dHI6iqV9XWEZAPFF8JCQBRcJiYn6e+dIJeyMESVsFdkYCKBo0Mk0EKFbVNRrbD25Dk88PAWvnn5iew/Mkx1Qy2OrRNWfRTzNoJoE4mGwe7DG5BB8yJYAoJXA8NCkSrBiTA6nuDUU9Zz7TW38Ku7H+GRP/2N66//OgI2ITnKVd++nKu/eRUFn5/582fwyzu2sOGdXUCMu++4n6qqEH/492exHfjlL36ADcyc285P7/4t+XSWRKKERYATVi/g8ktW87t7n2Lfl10MDOzjk49e58orLkfARVbKIi2KABEctwwT+a9sfQB0hx2fbqGY1Nny+Q+oUgOsO/UeaqdpeFTp7+rlP4Ro67rGj2++ke3bt7Jrx24EodwGKPeDRBSPjKGXGBgf5b8YL8//9RVsQcAVgHvvBWD1mjWsX7+e2269CQeXq751FZs+eRdNTzOt/XIMR2Q8kaJQzOHa0Dqtk+GRXhLJKbZs3s7YsMHePfuprKqgt28InxJkaHiQipoWbrz5RmzdS019K5W100il0ny66QOCHh+bPnqf7RveRHMARcQwHWwEbFy6vPCBA9846ysc2vAu20sFVNlDQzxGOB4l4Dp4nAJaphcLHb1oUtRH8EcEeoeeZkbTV9CLJxMLmpTs3STGu0nmP0Y2dLLdlRieEKadQRZTeL1eQlEoFFxkXwHNAAmdqliEZI/LzM45aOI2dhz+gJnzaph7coyh/tUUp1rwCwIT6T0kJwps+WSAsWGVvq595PMm608M8etf3UtP7340zWThghXU1tYSCTXxwosvc/nll7PUX0NPzx4qKmNUVseoqophWRayLBONRhkZGSM9lmJ8PMmXXx4AQWLm7FmUijk+276NP/7xUXChrqGaG/7l+8ydNwfHgXWnncl/vvA0VdVRTl5bh8cj8cOf/oQLL/gK4+PjNDa38+XBbnr6+qmqrubwwe2E/DLHrTmRk045k+uvuZWvXvgV9u1+hVNOXEdjfROimaMwPsysphArr1nHts/2M9j1Mr/71Q/Y//lOVHmcQknmg3c/IJ1OI3t9mLlRlBoRO5FFteF7Z1+MIfXyt5d2I2eDBKUKFLPIzm27Gc1OcO655xKLxdAKRYZS4/hr02zcvZ3WbAdXfOefGR0f4+P3txDweljfdjJ2cYRSPsmRAyNs2nwEWVUIBmIMDY0wOlTAsizCoQAffPQJp562FtcoEYmEkHwRBG+AqWyCqclx5syajdfjIeCTiVVH/xvEIQgS+UIRr+yjs72dbEnj8KEeYvFqPAoUihpnnH4eR3v6mTtnNpZucv9vH2b52mcZ7hvlzffv5qlntyJKKoogIQKSYFHUTFLJPL7KCLlcjmyhgN8XAUSyhSlURWDpkgVYlsNUsYRlWWSyScLRCJPjGoKu8sPrr+a1v75Ez8Bhzl5/BvNmNZFM2Ai2SEQOEfA5yJqI6ADFIHppEoQA42NTxBqihGLzUKQYF37lOrLFSrT8PDTT4pNP3+Kfvnsh//SdMqn9xDWdhGtUWmc08/zbL/OnR1/mnTe2MDa4F8Oc5Pf3PcVXv3YOZ124hv4BjY6OBgxzAsXrcs/PfoIoOgiAZRtIkkp7+2x8vjYuvfirPPXnu/jb317lwovOwzSK5W1RwSpT6CUX1xERBAcHtwwxFhwsZQzJqMcTUVgyfzYVVUFMO00s7i3vc/yd8w8h2oIg8srLrzKRGOeEE07g5ZfexDIdQMR1yvGjqqpiWCaCJCNS/hPKx0LoERyWLVvEJ598SEkr8fEn71NVW8Wv7r2Nwf4JdF3hww/2Ma25iedfeIevXfJVFNXBtU0a6hay/8vd3Pfb37B75x6+fc3lJCbShCJ+li06lXg8wmhinOaWGViGSilfYv7c+bz44ouoigqaS0fUw/ygn7U1jUwMDvN53uE9J0PRgeOEOCtbmphmC5xW28Dp8SrGRYf+XA7ZcglJIAoOvmCAolNmJLompCdzlGImk5P7mNUxC9ceYqDrNYr6EKGIQz5n4g/XEAz5KBg6k3mYcgoEfCKOKeA6NrYNrlNerijmhlHFIGNTQ1TVVzOc1Xjw0f28+9IYUwOflpdIBI59CMcwUiaiFGfDuxtpbPUyo7OZqngjXk+ZjehRfVx88SXgugQCAUzTZP78uTQ3N6PrOoIIsiz/N9nFo3oZG53gaM8AjY3TOAZTJ1oRIRBQKeQNVNWLJEnoegmv38PRo0fLdjtJxjRtDNPmlFNOYzJdIOwLcuNPfohhuBzsGeW2229DUXUEAcbHE7Q0t9PQWEddfWU5nU4TqQgG8Uo205urmdbcglcJc83VF3Lg4F6MwmFOWjON/fuGGe4fp+fgLlyxiOqdhi8SIjl+GJFmXO8EWw70IUcVEvIMQt5qcpkUfb3DjAyNEG2o5KOPPuIrF5xHIB6mJiizY9t2LvvmlcyfM5/MeIY1C1dy2vFnMjzUz1MvPIwgwfDRIZoaW0imNJJTw8xs91IqWnzx+UGmd7ShazZ+f4BkcoqOxbMRBAmPx0ekqgpd1wmoPvz+cgJhLl/OknZdF0cECfCrfkzLxsAmnc6CKFHSDHL5PLahEwqFqKiooLq6gvPPP4c3Xn2aI0cSzJjWiC0EWXNcJ5YpIMvgOBqSJOPqFgGfBxBwRRnZ46NY1KiuiNHTm0ZVvIwnBxBlkYqgB0FRmdW8ACXipSXmY2wiz3Xfu4XOWa2cceZxPPfsa3zr+9eBUwDbIKu5+MMVmI6EIZjIoowoCSjkaG6rAEmmmNnLScuu4eorb+Zv723g/ffe5YSTOli97GQMfQRHHKCYy3Pfbx/i5NPO5vprb0KwAmz88CmaGisZ6xtDFgx++MPLueueO7j15lsItcq8/MLT/MsPfsSK1StZtLiOoLeWQqFAcnKEm25+kHw+TEtrCz/92VX87ncPcPrpJ4ELiiph2noZ4yeUcXxiueRGcMuvmCAIuNgIkoFrmqgeCVwIhWU8Prc8rPw75x9CtF1cLvn618jni/z6nt8gqzK6oSHi4uKCIGKYFrjgOhZI8jHKCPgDPkzDJZ/XePKpJ1i8eCHxyhj9vd3cc9ezOIJIXUM9O3buYnJikuuuuwYlMEnf0V5Gx4YQVZOdez7k/Ys/JBTy8dvfPoTr/Jd7xUIAGtuaEVUP/Yd6EAWZbVs/L//6joEiQMkxqdIlajwKWQMsj0JR8pDLa3gVB22wGxyNYCpBKZ0HEXQtj7+6mogD6bzNRMEm7xo4CNgaZJIgdaqMJDYyrr2EIkssXVGLqvqRhWZKmoPjBHCtINlsGL27CZFq9mx+m0gcrCLYGhTyJXz+EK4okNG6aZ29iPc3HuKzI6OEK0ykmMiMOj/pSYgE2hBME0NzCQQM8rk0lhYlEpc446zjeeG5Z1l78nJisRjBYJC777mdUDCOz+/hi327aGw+BY/HA0BPTxeO4xwD7bqEw2HyuRBHeweIxqq46GuXYDgmnqAXVVR5+pknmDVjKUUtx/sfvEk+n+XEE4/nnbffP0ajFwmFwlx44Vf5Yu8+IlVVtDU3UBGvZnx8HFVVSU8mGRuZQCsVaKldSE2siTXL5iE4Bfw+h/7unfzo+6cwMXqIZGKMki/P4Hial/7yb7S0NKOoLun6KnTdYVZrFd2fv0w4VM91P/kZ7777FqefczbvvvkWQq6CqsQkq2aGCFYcITEwQSZyMr7qAE2zOgj6ghhajprqJrZv28TBA1/ym7vuYeebG/jwvU00zJzG4nVnUQFUN9RycMEqPtu6jXnzVvPlgcO0t3USUIcJBAK0t7dz/PHH8fwLz5DNJSkWNQp5jaHBEWKRKAtXNFAsaCxc0IZgOXyxZxuBsEJNfR0lQ8fEwnRMbBdcQcHnC2BThkf3dA8wMjJMvDKEKgtEolEi0TiHD+7ihh98j0LxI+77t59x8llr6Rvdx4K5y5HF6YiujSjamJZJyOfFQKSERC6XAwdkxce+Q91Ma+/EKJUo5adwXINSTqRQnKCqvoZ8YojPhyp56i9P8PAf7wDBpvvgLTz4wJ1lTQhGypnluOR1nampHE4piKDYmLbIROkIQSVCwbCprzibUWkCZUGJX1z0r6xfdTz3+a9HM45gWVmiUQlPJMqyFct58MG7efalBxgcCCKZKjVVFrlceSEGyeGmm3/OR++OUdVyiPPOX8fpp69D9mjs/XKUW2+6l3TqCNlckqqqTp556mlmzGrgn79zMw/88W4KWoKilkJVBCRZKgM0XAdBkssZsELZR+66LmXtlnFdHdkLqpwFwcYUMghSlHza+bt6+Q8h2rKskE5n2bjxY047dT2u5fD6a2/hCC6qR0RQA2UblKjg8XiQZRlJEghEg2VwrOHgkRXy2QKmYeAKDqWCyeHDh/n2t6/Dsj2cd+Z1JBITvPnG31iyJE59VQetjR1MJIaRpQDBkMjak4/jtdfeJhQOYGg6umEhSTLNLdNA9KBaZRvW5198WX4IIriOgOJIhCJBIo5M3BtEz+UwRRMcSGRTdHh86KqCJKpkHJ1oRTXO0TTJTA7dVQiIkHNMvIKKKnsIhqKIgog/IlPMm7RMryIQDfPsoz5Ghibp692K69qMjlmkkjZaDgRXRhIlwMI0wdWDBH0yxXwJr9/P4e5e2mbUs21blo82pqjt6GDbpqNEKlUmJyxiNXVopQSSY+ANNaNpDpIUwrBD+KVO2ppXkMk8zNTUBMGQQr4wieNIjE8MguCiKAK27WBZBqVSgXXrTqWyskyL6eo6jFYqkJxM0NbeSSAQYObsuSSnBhEFk2gkzLZt27j8G//EWeecyarVC4/xJj381x55ZWUloigyd/YcXnrzXTrmLWDdaSfxi1/8gm3bPmXRsuUgOPR0jZPPmQTbQtRWxmhsiODx5PnedV+hrXU627a9TltjNclEPwHZ4MjhXmZOn4ONQHYqTUpVicbDiEKWqeQ+wjUyF19yPK+++ldKKQvHUBGCKo99eJid2iy27lNYvWIeZyyaQXasxMZPHsPUdBbNmsnrL71AtL4KQRAQczr5oVH8QO6NV9gzPsEXjkiotoFpczvp7htEH8ihDWQwa8NYqktLSyO7d+/m0OF9zJ7diW2ZDI6NkMlkyOVCxONxisUCpqbR19cHZhkh5/V66R9K0j59Fi4isiQjAiXdAdvCPUZKWrJkCTNnzmRsfBCvTyI5cQTD0MoRAMkJrrx6DTdcP8ynH3/Kmad8hy8PbWP1wlVIHhmQkVURQZAxjByeUIySJuFBYnQ0WY45kGxk1WR6ZwuiBANTNgsqGugZTNLc3IyoqPzx9z9m47uvc/jwZyxfvYzfP/AnYrEIDW1V1NfW0dbWRsAjE6mroHz3rsUrqjSE5oAQIOKIZMY+4ZzFs7j63GtBkFh3xkksXryEibFBUHVMrUQu5SVeDZmsw/jkGM0ta5nZWcdn2zfyyCOPMHfODKa1TSeVjLFgdS0V0ZmI9kLqWvo548yzOevsr1JTNZ35s1fzwnPP8vZnL7B58zZaWmZwtHsAQbQI+mOAjuUK2I6NYZt4FKV8bz224V0GhZXzEWQlhIuDZYEsqVh2Cdu28ah+LJ/49/Xy/6oa/788rutSU9dATXUdf3v+ZdafuY658+aQnBxnwYIFfH6wh+kzOqmqiCFJEqViGUBQKKaRJIFQsA6P5GNoYIiJtlYsR6e5uZmLvnIZJ6w5ifMuOIstOz5keMNhdu56mzfeeBZsL9lcklDQg6hYIKocHewFV6GUN7HscnUX8EdIpRPEKhqYSCYwdQNZEXEcEBwbCQddtykls4gNKnFfkEbdIG6KpLExEMhaDobfh+z1kdOzKMd69oogIGFiux78Xg1fWMIsFbGdAgXLREemsnYOd920lYlsgrlzm0iOqWSyzUQrYsSqJohVmxTSHqYmRslNaQhCiGLWobZGxbJkTENEFvwMDqns/DzF40+OsGxlCxtf68IqSLSvqCbauZzB7lFkLUOhMEbJShGOmExlxhFsk6PD7/PkM4dZtGAhubROqWQiqg66oaF4FGzbJhwJ4A94GR8fZ8XKZdx66y3E43G+9a1vcdzxq+k+0svatScSDley6eOtvPDSX1mydC6VlSFSmSJvvfkeAX+I5597jhUr51NdU8n79/8RgOqaGhYsWMCRQ4f46oUXcfsddxKubuCuO3/NuaesJBaN0Hu0m5A/wMhgDo8ax++HxMQh2qfnKWWnyA4doufLbkw9y2uvHGDe3OnksiUikRi6Ca3TpvP67g3ISoTe/gPoVo7+4W46v+hE9MwgeXQf3/znOxEjAmY6Rkzr5/iKCdZfEuKhB//Kt599la9ddiFXfOdS/ILCOy+8zMebBvDHg1x26aVMjqbZtOFTlq5YyOe9Y2zuf4fRz7tonz6bH//xP/CuOpmv33ELQb+Puv6jzOmcz8DgUUTJoVTSGBoeRCsWUFUZr9eD69rs3buXRV4/jqIys6MDCZE/vP8G8xfNIhSJYtoSXsmLiYPrWHg9KoZr4yCQK+VB8jIyOkqhqBGNVhEIByiMp6iuriabzdLSLHPSqV/lw/ef5pX33uTU5Ut48823OWv9qSCaeH0eFES8XpXhiVH8Xh+p5Dg+vw8THQsZ2RugaEGpoBHxmuTMAHXxOH6/iJHXSaQUDh7ahO2CKMjg2hRdmOzPoWsFDu/rwXEsTN3BMQQc0cRxVFAkphJJrrnqBo47fgVf++a/sumTPThOnu9ffycvvrSYbF6kq3sARVHwevxM5lxeeWU/S1e1MzR4hK0fPct9D9zG1Vd+t5zf78pY08cRKOBYo7iuj4lJjZefP8oFZy1CFiOYTCIJM3jxhc0sX9OA4+jkshouLgXDpVgskdCKCK5Nc00lIIFjUfZp2xzTbwAcWwZRQJQEEEo4SEiqQmIyR8T/v+bsAf8goi3JMlu372Djpk2sO/N0Lr/yMm75yU9pam1iMp2gpbqOE1efgOB6Md0UiiqhlbIU8vWEYw5TwwZTk1kaG2vJFVLU1MZZsmQud9/9SxoaGvEpFcxqPR7TsInGwgS8cVJTY8RjMUqFDD6/h1TJQkFGVi0U2YdVLOI4kMunyCQ96CWDcCCI43cZGRvGdRwQHWwXZMmDFnSwK4MU8xlKgoI1ZlL0wLghMRhRWarZFASXuD9EPB5DONKF5biUa2MLGwnbtDE1C1mMkk0nUJQKDh1MobsC09unM9rvQZWqqaoOlUnspgtCiajHj+bJkRPK1zwXg3AkimNLZNJ5mqbFGT4aZbArgjV4lK39/QguKGGb0b0mu4deJRaLEQj48MhetKJJ96Fh/uXGa/ntr1/kyBc5mupE2md4qK9vZDLTRSgQRI8YFAo5CoUcpVIRr9dDqVREVSU6OtpJp7N4VD8FbZJILIiu68zobOfEtatpaKzhSF8f9U0rkCWRuXPn8vy+V2mb1oYouaRSk2glHVEs325CoQimXuLQ/v0gCKxcNp/h4WEikQgRv5ecpiGLLnv27ADA1HLIQhYnPUphcpTjV8zDdRReefUtli6eSUVFJcFgkJJeZGyixO59B4lVN+AqArPnLkHTc2z59CPGRwssWBzlrrtv5rkn/0wg3I4jDFKKNfOb53qJN6m0H3cc31q5AidjcGToKEPFHGtPOAlJUdmwYxMZ28EIStTWN3B4VxfeYgFPc4zl11+Nv6Gedye7mRxJcvX8VaQyKSZIkyuWEEWZ1FSOyy67kldefRGPx0OxZBIIhKiuqmLBvNnU1FRR3dRMrlhAkQQ6ZrZSXV1NySgzSTUcBFxKTjkzHEEiKIs0VdfSNZDEsWVsbIpFnZA/RMZXwjUsYpEoSaPETXd8k66eL9j05qdEVGhvVNn++X5OWT0HU7RJZNMgi7Q11uBiE1b8eGUd3bUx7CIuEolMkXQ6SzweZ2owiU0KAZOop5aSNkx6MoDPr1JdGyOVsfAHPdQ0R1GlKAI1gEjeEvDJLiIWgpsEt4JH/u0B7r71dK76/t3YYhrJncARGhHder5x6enEKyLEVy7FIYnoVvPkX97kk22vcNcf3+edl9+ntj7MVVdchWUeBaeyDGOWS2A7GLKHUilHbWU1131nNv90fYGSK4Lt4BNEBFEEx6JQMlADColMir6xMUquQ0V1BzYlHLGEgQ8RBy9QrrBdbMpWZkG0cV0BFwkXCUkSUEUvsqTjHnOb/G/nH0K0bdOiubGJ2TNm8u5bGxifGOWss87ijQ2v09rWwsTQFP/64xs44cTjEUWR1cctZHx8lHDEz+Cgzl9ffIvm5kaitYuZ2pXg1Zff5ciRfgQBRNdLZ0cbAY9KtpBHQqChsZ6a6kUIgsvll1/Gs8//hcf+/AamaSKK6rErjIMklftPoqDi9QSZHOnHcmxEQcDGKUexAjIqMVHCO6lBwcQzMsF0RyViWZRwEXIOUqNLSyjM3uQwHr1IAYuAXg6Wd7CRbD8RNYSoCFhmiPHRSTZ+WODtVwdZdS4IKZl4ZBoefwnB0jBKCj65BlVxMIUjjCUy4ILq0dB0k9raWrLZLAV9CkFsZ2x4AtwJps/yILgi0UA7+VGBn//sduJ1IgPDvei6B9vIkkqPMzU5yvlnnsx/PPAMlZV+3nn3bUae7qYiXkd3Xw+qKoNjUF1dS11dKx6viKJI1NSUX7KHH36YQqHA7t17WTR3BQPdI/h8HkbGRvnWtddxxTeuxF8RI5sYZ/niBSxctIj1686hpGmYdh7TEMvgYxFWrFiGz+ehb2AIUZKZt2AOP7jmWnbt3UNbXQWZVJKuviO88fYrOE55DjLY18Xjf76d41fWEJ8Q6Nt3CI8S48c/uoM3NrxOX+8AjfUeKmvq6On/gpLmEqmsJW+mOHjkILKg0tKwlPGxJJ9u2cm5Z5/L7+/5DiU7RX7IpbpJ5uLzW5k23cOWrXuYET+LpDOKXVdDIR1EsVyybokVJ61FDofRAwFmrjuVd157m7qV5xCPVvLZh59S2ZzitKb5IAp8kuhjYmSUhdObyWVLpFIp/P4Qd915D0sWL8C2TCoq/HhVl0AkTOfs2VTW11JRVUXMH8ZxDOprG6itrsEfqsYvBXFcEUEI4JV9CIhkHYuugQEKhRIzO2bz5YEeMuk88WicklHCdgyCfj/jE1N0NEaYP28GNfU1pLIjPPTgX7jpJ00MjUTYekBl+dw5RMIukzmdnqFBbENgXlsjmiEQVCVMs/wAC4Uk4ZAPxXVRRfD6owiig627KIoPj6oem0mUAAWzAK6uYboWXtWD7drolo0v7MVUx5DFArKngXNOPZtYvMg1UphsrosvPt/NwcPdXHX1TTz4+xdoaIrzi7u/Q9g/g80bP+PRpzawaulFvPD4Du6/9zacko5ubsTjiWPqERCDGFodWknAFg1ESWEinUTxetAcONDXR01DHV5XojLiQ6SAT5WwbYt42E80Mp9kQaM3axKPVCBSREFBEUrYxwo0R3AR3GOuN8E+VnaLx7YkRfwRAc1w8Uf/72SP/H92RFEk6CuHu1x59Tdpb5/GC//5HJKoMHvufHbteIbT16/j/n//BTM7loMgYNpTvPLai0wkJ0mdniU5niQYjvGfT75Cz+EhKiuDfP2S86mIh5lK55m/YDaiZNPQ0EBibJxcdgpT12ibVs+PfvRDHn3s1f92Ofh8PrRStsytFEU8Hh+K4kH1elBcF03TkIRyz8lxHUaMPAlTRTiapMK0cMM+Muk0mWMMOlMSkeKV5MbG0HSbXF5HFiDsixAslnFERVfAEmUyiTHqKoOMTET428OjoMjUSiehKz6kqJ9coUQunyM9mSEYUnGlAI4j4doqoqijqjK6bmKUHILBIHrBIJ2eoqm1hWkNHfQc2UouV2BEGwLb4cbbbuS2O35Ed3c/wWA1up7BcQRGkiUOH01iuCJzltTTrsVIZWayZNliGlvC5LIapjNJLOJH13V27NhNPlfg4MHDZLPp8oRfUZAlBUF0yKaKTE2lufSyS0gkxkCA+bPm0dvVzxXfuIhEcoie3iNEIhF8Pg9ffP5l2frp2nh9CnopjyzL2LjMnDGNSNhipH8fVr4S2zDp6uriwL7PwU0giBkGut9FtRN8tvEwxWKexYuXs3TJKj74YCuJsXHC/gAd7R3s37+P1MQU8XgVE2OD5WefMykWM6xYtgTZ65JMZ3jrzZe55GsX8NzjD3H5Vd+lrtLH8GCK6s45TJsdQg9I+IRWhFw3Dll0UyQaiWClDXQ3Q3xFJSMNzZz1ne8wNjBErKaK71+8nvr6enZv38nE8DjFrI7X46eYy1MZqyI5kSAajdHc1MRnOz+jMl6J7LEJtbVR0uHtdz8hV8ji8fmY1tSK41g4toGmmziCj1htIwuXnUBldTV/ffFF1p18KvW1ceqbpx0LWIKGhga6e49SKmpEoiESyXFMy0ZRFHQtR8QXpaKigsa2+Wiaxp4DvcTDFeyamGR2Qwv+qIegquORppA9fjJ9NiVhDAHw+4JYlo2YNfD5AqiCSVgS8Cky0VgQQ3dRVQVFFcpZ7baL67gUCmkmUjoVkSATYyPYroMv6kd2wO+4uJbL+x8+zKlrr8PSLbqPLsRyCqxYczErV6tlP3uiwMhojjffSfDyq38CJJYtnsfHm59m266/csaZa0Dtwy6UcEUFWSmCEMDr8+L3SOVqARfHlECUSA8NUxcMIAgCSjDCeC5N1OMSUnwoqomz2zDQAAAgAElEQVRt2+DqVAS8HE1OYloCGhI2IkHBB2g4govoHjNqueWaG0FEcMBxyrBof9CHqfsRlMzf1ct/CNE2TYNsLs2KFcv5/W8fYPGyJVTVNBAoZfnko81UVlXhCg69XUfYu3MXV172z/zuwR/hDVUhCC6xeCXdPYOMjiW56urLWTing/HhEXS9TEWRFfCFZUoFjcGho4RCIfSpErUNtfzu979C8nhBgFwhi22AEPif7+a6LpqmM72zjq4Dh3BdF8syyqLtOjiArgiMVsoUaqso6SUmvhiiEomCYxMWRHy6jWoYeFQZW9dAErBFSBl5dEmihI0t6iDYeHzw5dFRRodStHQ0YxQsvtjcTS6tccLa41my+lR6B48goFAsZamuifPkE8+TmMwgiGBplG8GapzOGU28+MZLdM6YweDRQQYPHcsycEUkOY/jikiFSa799o9YtWIl519wCpIcwRWy5ApZ4vEqLrzkPCTR5uON7yFKFmuOX4KlT5Y91U3NnHT8OjKZHJOTCQqFHIZZwjRNHMdCFEVEqZyTk5wap1DIkZiapGNmJzfdciNPPvYSy5edyOZNB6mpCeD3mygeiy2bP+OD99/HdSFeFUeSXCTZAtElnc3QUFeBKkmsWLqMl156g0KhgC+ocMedD9Dbv4k7brqbugpoiLfSNdSL4lEZz5b40xNPEg1UkNPy7N/fTbAiSmtnB2OTGdK5ArWxKooFGzWs0trWwucH9tA+rROPVCBSEcHr8fPFO09xb8/H/PWTjdx252/4w71vUNsJ69esp5AtElV0rKCAGAmiSjLZgQEWLZ1HfVMNBw58SToxyRc9X1KVjtE6vYbHH3+bn9x4C7XtPRz8sp+jPUdICJMUTYtYLEZFRRxJUnjvvQ3YjskNP/w+06ZPY+HiRViGydBAP8tWLsPRbXbv2cHgYD89R/tYfdxammfMZ+vWbRx/wqmsPfE0rr7ySlzTZu6qRSxdupTpze0EQyE8koDtGNRUxxkZGcLWDXTTwedR8EqUF5sGewiHqtiy4T32bHmdn/3yNl5/90WqqmdSEWmlunohqclxQlUJBCNAsVQgEPCRy08Ri1egaUWwvdimDo6C6Kq4dhERFcEWcG0R17YRXJuqeBRJNIiGVWRVRVAkbAGCHgvEAGYmx8nHn42T70FUfMyZ0Uk0MgNXUJi3sJlrrrmM1csu4uprr2FkfIzrv38jiC5WfhjZLXLffXeyetkpZDKvEvDHsN0ssugDDGzLxBQ9WLaO4DqokoKLS33LNHQE+nJJ0noGJBNTldAEUBwbWZIQbLBwcM0cuZyJaMiE/B7Cqh9B/J9mtiAIOLgI/x3YLiAi4roygizh81aCVPy7evkPIdoIMDmZYMuWrcyePYMFCxbw2c6dCDj4vV6OHDlCfX0lCxctwXZ0wnGLRDLFwtb5HP18Kx7VR0NDHfl8lmDQx8jwAKmpPLV1cSZS40QiQfzeAHoxj2U7ZLNp6urqSKUmcQRYNH8hovQirivg9fqYmkqVJ/7HvJWRSARZVvH4fBhGuc8q4OK4Aq4ooho24YKJMJlBNi2qw2EmtAkkoOQ65LBo9AaRdAvBNNHGErguKKKEY5ere1EFx3VJJFNUxqPUVDdgF73k7RFSUzl03WTrts9IZ3OIIgQCAQqFHB5FYmI0gSiAbYPhGiAIbNz4Edu2i3gjPnAEFi1dRCFZZCw5QnYqg+uCJMhk0yUEYNv2zcyY2cwZZ53JoSN72PbpDsaG72B4eIxAsJl8doy1644jn29koKeHgb4eRocGeOONtwj4g0xrayUajjMyfpRisYCu6ximhmFo4KrU1cfwelWy2SzFYhEHGB7upzQvy5YtB7j06xdRETfBlenr66NUNBFEmarKOgzDIohKPp/H0Ew62qbzpwcfZc7s+fzs53fxpz/9EdUvsGv3ezzx0HvMbmvGp0Y41LWPTCaLpmnojlsO8rc8TIxPMW/uLHw+H0d7+kilMqiqSrw6TqprkIDPg9/vw+v1c+TIAZavXMWO7btwHIeqxtmkMgXaI14e+fkP+FFhH00dMymIQVK2gybnkH0ydklDVFSCAYX+vm7yRpaSq1E7rYEza6sJBv30jgySyKUZyUzi9cjkS0WCsQjZbIrKeIih/kHSmTzJZJKmpiaKxSKhSIzhkTFcYTfRcJSt27bRO9TH9NYmRNGlWDKZOWMe8Yp63nz9NY478VTGh/tobKjngvPOor2ljcaORmrr6xkeGCEc8pNNCbiOhc/nIxoOUSqUsBwbWVQRHKitrkMKNZEd1Wg7oZ4Pt7/Dh1t30z69mZaiy6F8Fzd87wpq4jEQTQRHQBAqsI6BEoL+AKqsIMoShqMhShL5QgnTtHAooUgqIGCZIqZpMpVKkkqVKOSCWKaDK4gYgotWqVIXlhGUIGZuD6m0zNFdm3nosd/xzDO/paFhFrHKAEhxJpJ93HLzzQz2pfjzE48Ri/vZ8dkmdm77ktUrT6SQ3UIk3ADoOJaAZTrIioUkRxEQsB0LQZQxAUEAG7McX+zxUZQsTGQMQaSECaKA69pYtosjuTTW1qAqXgKig0eREGwXXLfsyxaE/9E9V/if7ciyCuD3+9G1sk/m751/CNEWxfIE+uKLLuSJx5/mzTdfZ2IkQV19NZIMJ518HHV1NTz/yovMmzOX0cQ4Bw8f5M9PPYksyxw+2ENvdy8nn3Achw9389WLvgKuQW/PQSzLYOGSpRzp6iGXn6QiEkXXDRQZOjqnsf9gkb7BPkTJxtBtCsX0sWt52RQPkMlkGBkZKafUSRKO4yDKIg7lRXFddYlpfgRFxhIlApZLAIVGJNJopCQBq6aWaLSCyV07UFQ/lisgevxUe11GtRyuJdE3Os6SthmkcxZH9u1FcGVcLJBEZNshmczQ3dXL0sXzaWxsJJ/JE/T5iYZ95LM2jlseaaqSwmWXfg0Eg6efe573Xn2fQDjO+ESK5sYWsIapqq2hr6ebb3/rWoaHh/H7/WRzBj+/9ZeoXoWW5k403aIiXsWhg/sIx6LMmjWLfKFANBTm5FNPQxEDiIKHgwcP4lglKmIR5sw/DSgvRJW0AgCGBVPJck9bRkDPZxCMAtNa6zn37NNYe/IS7v31H6iubeH+f/sjh/aPcvBAL4899gS6rlMykwiiQnU8TGWskqu++W0+2rKdhx56jPc/+oza2mq6jx5GMEXOW7uCYsnh00/ex++NYboCmgmSGmKoqxvZDRDwh+nu6iXgjyIIErU19SiKwoGDR2htbWUynaK7txcBFa8SQM8XWXfayTz33HOsWr6Q6Qum0Xu0n7HJHPfd/zfuuusmopKJZWewBJe8YyN7vdiyykQySX1TGwtmLmL31i9ZMGc+u3fvppDP4RVUls1byMLO6ezff5SKeIThz7spZHPkAnmKloCoiMRicYKRahqbm1i+enEZvHHKmQQCPmTFg+qRcSwbxzVZumoZfm+Mo/0DdHbM4ND+fQz29tF3tIejRw5zuLsLvwyJyQleePk1errLCYa6UaSzs5226R0c2neQQqGAZDuIIvwf5t47SrKrvvb/nBvrVq7OaTpMzhrNSJoZxUEzEkgIhIgiiGQDBkw0QQjbGAeMAxgQApOUnkCAQIAG5ZzjBE3OPdM5V6668Zz3R7UExmD7/d56v8VZq1dX3+51q3umap/v2d/93TvXnqE4KDhxch8nD+/lzz75HW7+4Q04zc/zvitfxeazzueGH/yQFRvOYKC9hWIIFj4zczN0drYzOTeF67pEKiQIfBJhHF0zCLyGvNBxHIQQDdpRF+imRlNbglwmhWGCpht4KFRYA1wi5RN4edo6Oqg4L/L3//JKQjGD6x1CMwZ45rmn2fXsMSYnitx59z0IK6S1uY0Ltqznucf2UHd/TMLpo16eIxZzEEiUDMDU8HDxpaIcVlHafDUcKOqRwoo51KoVvCDCcuIUQo9Y2iCh6ehKYVoNSmVBwgYaPIiIIpSSKCI0YSD5jV5bAEI13AobPc4qH3z/B7n6mi/R2hf7g3j5RwHaSoGu6/zyl79k/fr1LF++ArdW5YYbbuCaaz7DUy88BUpy6NABJsZGee75pzl56hQd3V3s2LWTe37xBE4yjr/JJxazqLsFVCRBSDq72qhV8iTiBh0tS1m7di31ep2hoSGKxSKFfJXuzsWEAcSdNAt6UoyPjxNKH01oSCmRUjY4viDAsS00TUMphaHp6CH4YUgYKNrbumnPpLhrcoRZQ6MQNyh7kDQFd0yOMufWGctlsZb0c3JqlL0z04zKCE2AH3iYts7oyDgXXfQqlNQYHhrHrVZoSsaw4nG6O3oJQo+Dhw8zMTHJlVdeST4/R7VSJ5i339WFgeMk8H0f36/R3dOLkhqj45O49YBTQyfxanVKxRIImJ6epqWlhUqlSmtrO1u3dePEbYSmzdtqmkxOztDT28vo1AShL2lv68K2bYr5EpmMybnnnYmhKSrlItMzM1SrVTy/0f32fRepAkwLwiigVK5SLPtgZFizYS04FZo7eog1eezde4SLX3kp1994E6+/4kryhRLLli3jyPEphBCcdtpp3HPPPRw4vJd8qcLw2AR79h3Ftk1a25MYlMitSlCuBCgpSGbSlMslpKwzPTVFW1sbumUTKli6YiXTs3ni8SRLlizhiSeeZFH/ALmWZvwoREZgaBqDM7PEp0pgZ9i0cSOHXnwcZ3AIO9NLJTKIZXOs3LCJVEsHXT1tVAOdSkUS10BJnbnJMseOHWPbxRfwyIOPgYBPffIajhw5zB13/ByAqYkR/vYfvowQgoH+Jby4a5zxiRGa2zs5ceIES5evZNnqlcTjccqVGgML+/jFL+9g3bq1jIyP0d7SiqZDMuWgaQZV16Ozq4cwVHR3d6MLjeYzTqc5k2LJ4gGyKRspJZlkAilDUulmbMfGdV1q5QrJZLLRgJ8/aTqOg2VZzM0VQMT4yEfezNGxCk/f9T0mJn12vvAUa1euZNfO++h5zZvIOinmpot0dXWQSicoFjxy8TSWZVGr1WjKpBuzFto8dSzny00ty0u6fFdKbE0jlB6RioiUQkkfMEGExM1m/Ok6UmuiXAwwk3Gy2eVMj0keu3cQx7S47Ue3MTw2zJZtG7nr3ru5c3sNxC5slQAtxLHjKGTDs180ZoBD30PoFjHR4LVfmkzMmibCMEgnLcJI0bDsA0fXMVSApoGcl/Y1bqW9XFXPw/Pvwb1GBS5QL+NMa2szKlLU694fxMs/CtDWNB1Dj7N61TqOHj5MKuHQ19uDbSjcWh5LC8nPjvH2t12JlNDW1sbmzZtx4glacs3c+bMnaM6kaW1t48SJE3iRIG7GmJgs0JJLUJgrkE23MpefYnh4mEQixdPPPQ9AtVrl0KED2DYo5ZLPV9F1vfEfIxovoOm5KTJNWTRd0NHdRaXSSH32XQ/iDgt7FnNn4PK1J3+B7cNF285ldLeLpxRvffWVHNi/l++Wp3GaMgzGbZ6eHGfL299JtqudwAsolIpIqrj1Cr/8yR08+NBTDJ+YoHfBAEOlk1z+xjcjkIyNTyOUZGCgD4XGN679NlEUEEWQy+XIF/Kce94WtmzZwonBgzS1dXLZZX04sSSaEUc3DCIZYOoWlmnjeR6z01PYtk2HMNGMGFKqRtiupuFHAZEUxLPNlGoBqWRzQydfKaNpGp1dMcKoTN2vI6TCDVySKYtU2sbzXYIgwPNswjCcbzRFRJGPVAE6JZYstpiZOMzQyef51le/z+VveC2WZTM1fh+HDx/lqne+mWeefYolSxaRL8yy9aJXcd89TxMqnZ7elRw+OklTczMbN55GcxOU80NMjuylWK4Tj6fJF0pEkWLVyrUUi0WOHDlCW1cfiUQOw4jT1p6lpaWFuXyB5StWkEjGsWIWzS0teH7IooHFLFqyhCP79rJ/9/M0X3QJyze/nta2Zopje+nv7GHoqXv4xPs/gjAyODEH3fTJ5hKk4zaJZAwVmixduhrHjHHbbffxv354C088/ggjI0Nc961v8cE/+yCasNh/4CSzs1UUEYlUmlKpxOvO3Uw6nWBB30IqNY96vc7gyVGmpvPEEzEi+SKXXnIxQejR1ppDygiloFajcVSPNCzLpu57+PU6y1an+e51/8ahvXtACD72mb9m8KknkMqAomLTWRvZPTZLIpGiWi6B0JBS0d3dyYH9AZqmIwhZ1t3O3T/5PHE+h7DPAdPjzz9QZcVpi3jquV8zNwXbtlxAa2sHUaRozmZASMrlMplUHMOUSFUF0dCMK0GjQFIN4IqiiGoYEtoGhiZA6GjCBl0gFZjJGJMTB5G+RSq9hrjVzL6DEzz5wo8wtAT7Duzgnu238Y53vIPjJ4+y4fSl3PHru0DsRkkNqefQdAt0hSBEoKNFjanFuBUjwiSuN8BaKA2lKSQRQklsU0MZ4qXoUEz1kv+DQihJo9XVuPYbKkRDCb3Bs6h5vTaA0tFEBCg0DTQ0unvSSAkx2/mDeCmU+sPGJP9/rbaOdvWWt19Jd1cX13//O2zbegH5whS9Pd185tMfY2J6gtnZWfKFCqdOnaI4V+bo0aNICT09PXR29DIzM8fCpQuYnJlmyfIB0gmTLedcyPZf/pTm5qaXzXdc3yOdTiPR2L3nRXTNYHx8nAfufxLf14hCg/GxSYKgTCQb/7iJTJJ0KkukJJlMhnK5iu/7aOg05VppaWlh2bIVBKkIEfnEjTiBnPcOcBo7cKfIUvc84lYc1/dwdI1qvUbCktiWRU16RLqOFYsxPTGFW4vo6R5AyoBUTmdkZpaclaTm1qnKAC0SJBMOmjBYvHAhc4US2Vwzu17cR+B5LFrci+eWcCwHTVjUgwjTMRo+CFJr5HloglQshhCCSIEXSYQS+IFAoBHKEMPUqNRLCCWJmQ2dqq6bjWZj2EibD0IPTUk8z8OyLIAGtSQaSShRFDUqN6AwV6K/bwm+r1PzhzhydD/3370HTYNXXXoJ3d3d1GolTEvD9Sr09fUSj8eJxVMYwuLo0Uk0WyeWiLNnzwHcYoVFA+3ErQJebZQwP8nMbJ5KvoYRc+hs72JuboaWpiRLlizj+MgUaDrHjh0jDEPe+MY34ro1TNNk4cKFRGFjklYTJtlMK6PDYxw8fpQ161bR2ZQmUYdQj7C7WvGNBIbdxZkbzqI0doTxmREKxVmQECEI/YAdO17koUefIpHqYt+BE/T29nHhKy4mnrC47ptfByF58plnOLD/OE888QLHjh0jl0swOnqKuWqRv/7Lv2JmcgovEiQyOZqbWvH8esPetFomk3KouzU62puR0sf3Q6LQoFYPCJVHKCWWnaZcrtDd04vjJEiYJmNjE/ihx9zcDJYOlmEyPjJJPJ6kuS2HEBHve+/lOFqOn9x9gGu/+WlmJ4scfOERKvUqCceg5kbEnTR3PXCAD332MwwdfIyPfOSNrF+2hraeBbh1n46OHs7eeC5SwrETh7GsGG2dbQShC1pjYxGaQgiBYRiAbOjLA9A1RSQ9NGFhmCkMGWGJhqdHnYeJghYO7Jhgx879tHf08/VvfoUwDFm2fCVzE9PseP557r/vEZauCIkiGw2PujcHJFAqRBEgNIlAJ+H0IYwsUjooTZ+nLl6aYlQIIuZLcpSU82PvBlIoXsJQIRreQdo8VjcyzTWU1EDo8w5/EhrplWiYIH0EOlILCGXEzKzgvLM+xKqzdbbfeusOpdQZv4uXfxSVtpKSXC7H/v37WbhwIUIIZmenWTiwgCOHDtLW3c7c3ByJZJaFCxdy+hWn43sNdUKhUGDwxAi+77Nj5/MMjYwxNHoCXWjccuPtPPLgXSxe1MfaNeu4/PI3cPDZZ9l49mZm5/KgBMViEdd1aW1rY/DEGLnmZlatXY2hSSYmhykWi5h2jChStLS20tTaQlNTG5YZo6u9kygMkEFEddZFCYmKKXQl0WyHhB2jHJWIp+PEtSQZx6I8NUdoRui6gWFFmDkTTSmcKEahWMb06wz0LcYy46RTrSBCTo7sx0EnsnTiToZ4GGFbDq7vUa3WOT44SCqTZmhsiK6ODlpbWwnxSKr4fG6eiRlFVLwqTjxOuVghlXYIAo/Aq6NpGpYTo+rXUEqg6TYxpyEl1HWB4aTRNbC1EKEUph5HSoiiANtq+CMbWsNNzg/ceZBuUEqu6xJJj0qlQqEwx0xxnD6jj77uPkqViN4FC1m36lLqVehd3NVI+7YiEAFd3c24Xo3J0WkiJSiUS8zM5hmfmaBU8xgZHmf14gFkGNDakSRKNLFv8Bh+FGIaNslUisnJSXQUSxctRkaSrq4edu3eQyado7e3H8+NqJRdWtsS1OselqkxNTVFa0sH8XgcU9Mp52d54ZknueD8VxBPLKASTbK6L4Pr1glERCYBpXgHs7VZdGGBKhIFVWKaxcZNp7N+wwb27Bums6ufbKaJ+++7i2w2w2WveQ2u6/LWN7+dbFM7lu2wevVq3OocAwt7qB0s4AVFarKEbTVRKZYol8vUajWSySRRFFIuzpJMJZianMH1Ko3NNDKp1lwCH3LNrQweP4Zu2hw8OIiRSpKLOcgoolYuk87EWb92NWvXrCHppBkeHubY4CEQYWPYREJraztSCex4HF8ZRIZF4I8RF83kkZx/9hLGJ6usP/MSrv3KjXziE+9mjSHp719IMqnx1NOP0tnZQ1/vAmwrTrlaIxlP4UcS07bRfzMjSCQjNKFRDmpEIiIWSyA0HS+KELqBQOAXKkzOZJkYrfDC7mk0rY2bb/4ZUxMB55+3lV079vL8jkepFmeIJzWk2IfvjWBaTSRSTSglEDKDMKqAB0oRhSG6UvMgHTW8RBXz+ZMRQtcafiEChK4h52kN5ittJRrEjvwtJqTx/QZQC36/AZR4aXegAfqmrjCNGLr2h4vpP4pKu6W1Wb3jPW/F90Lu3L6dt73tSpy4wbve+Q6ueP1lfOVfv8oDDzxApVJh6dKl3HDj9eRyOa699lo812d8Yobx8UmefvpJTp06xfnnXkAoJd//3o0s6F5KrhnWnbaK5lwX27ffzUc++n66F6QJI8FPf3Y/iUQz+YJkzWlrefTxB9i4cSOTE6MgS5h6IybIsmIEaISRACOGqVtokcKOacQdB6kUc5UqTiwBoUKICEPXCPwa8YRF0o6haTqh51Ov1wmjAMPQcNJJYhrM6RDVApqLPp6uMea5hBmHRBSyPIpQKsOTGRfDi1hRFJSloNiUw1SKViGZpEZC12k2k6RSKZQTA92gXvOJ/IBQhjgJC3ciINJMqrFZYpokLlz0mQpaaLHfrRAVq5TcGqZpU3HruEFIXYaEbh0rjLAMnSNHDtHX10ehUCAI62SzWQLPa8Q/6RaxWAzPq9LU0kytGrB02RrSqRyjU3UOHSsxNzPNyOgkxbLbcKqLJUgm0kSqQltrM+25GD09LSSTEIQuhgOxeJxUuomOtk7CaoZvXHc9l73p9WSzFVRpiD13f5N6IU+5qtHSnqNcDnHsGMmWVjTfJ5VJIYKAiXoFDYdazUOIROPkYQocx2ZgQQ/lUonh0SE6u7qQUUBnZzcx3SSZSDBy6iS1epXTT19DJpFhamaaCy+7jMODg1x4+Zu4+577mClNQKCIiSSGplEqHCKTy5DQc5wqHmAm7zHQv4ZMuoXqjE69bnLDzT/kmWcf43s3/Iq/+vQHuOjCz/DL25+gLA+Tzjr8yd9/iLCeJylsTh3ezdatW1m+YjFxO0YYeIR+QKFcIhaLU5or4XkeubY0nW2tHN6/h1jMQgnVSEUXBoYf4Ngx9FgC07TxhcaRwwd4xbbXUKxWGB4/yvREkQ+88QqUkLy4r8xbrvpTmnscnvrFzVQCSSJWR/ouutmE50pUXLH7xRE2n34pS9fYHD18kDM39rNs5QCvftVmOpvaWb96K+NjHhGtVGogLQ+lHJyYS3Nbhqpfo6mlCSmgNjeFaeo0pzpwvRkyTg6pPA4cOMDR40c4dGQQXdf4zr/fyKmh47zhte/k2acfYnTkFM8+t4MNZ6xBhvcjaEWKIoQmSgYo2cjllCrAUA4qNFF6nUh3MJ0FKNmKEgHggrJBBKB0eJkQ+c/rPyhCfmc1QF+h6aKB7zAv0haAgabVgJAo7EBpRcolwZYtH2XlhiQ/vv66P95KW2iiYb9qmPT397N9+3Y2nnU6R48e5bTTTmN6ZopsLkMyleDc887hxRdfZPv27TQ3tTE4OPhyw6S/v5+mpibGxyeIJIShZOfOnXR0xhkfH2XrlkvYvXs3x48PYsS6iTtpEqk0GhqrVy9HqYhyuczg4CDJRIxUKodl6JimjWmaVP2QIJKEkYGu68SMRlNEyIgokiQcB6IIhSQKfZTU0LRGiMPs7CyxWAxdCAxTx45ZjeNUzaOsK2J2jGQ6h7I9rNBisZWgVKtjpwyqKUjYaVaJCFvXaB0pU/ElMmmhq5CoXCIWsyEMqVSrFEslTo2PEmkavhsQ1j2CIGA28llcjVMxI07KcSLH4sT99xPrbGfZ0jV055oa05LNzdRqNWJKI2E7pGyHWCxGXXo4CYdVa9aQTKdwTI2YYzWOfZGOYWrUa0WCICIIQ9rbO2hr6+XggeN89WvXobQEpbqJiiSpTJaWWAzTsAmCxuaXSLYjo5CDB4+gpM/b3/E6YjGLybkxEokEmVyOmGnz+c/8K3v3v0gsrfHed19CfrrO3MQUubjNhOehF0qksm1MTU6iJ5Lge5yx+SzGh4eYnqqBhEqtTDaXYkHXAo4cO4QV09l38EUCL6S7u5uYY2GaCTSt0YjTtMabPR6Pc+DAIbZduBU5MwWaoLu7m/GJEba84ny2//o+YjENEflYhkVb61mUqkO4VgpR2sjSxZv59b0j3P/Ao1Ty0+imT73YgZZ9Px/5mx20L3gvf/LFy6jlXuCWf3mEr3zr5/zlh/+Wb9zwI8ZmX6Sjo4NFixbhVms0Z3Po8QTlSpHOZIJazcVJxJFScvPNN5NNJZOwS0sAACAASURBVLn04q2Uy0UkEt2yCKMQO4qYnp5m/6FGpuqytacTj8d58L4HGJ+ZpHdxB5b1EqfaODEFQYBhpBpWGrLRONM0raF/NkMmxzQ2ndbPd779ba7+wrWsWbKIHbsfZP/+U0yPznHBBVt4/vlR1q1fxmlrz6fLskglc/PP0UQkFVKYaAKk1Mg2daProKRHNt5CKCc5fmyQe++9m5aWBQwNjnDvPfczVx7m4osv5tixPQyPnuKLf/cXrF3VQrF8G5n4AqScQEQOmlAoXUcJDc000KSCcB5whZj3HvnPBexvTJ7+8Pp9he9vA/lLFMvva0b+7moM89n/5UbwRwHajYEVF6l8Yo4GIuTAwX18+MOP8ed//iG2b/8VhUKB4eFhlixeyvv+9MNceskbGB+bYWx0mmKpwuDgSQ4e3Ee1WmdkeJKzz96ErlksWNBGqTwNxDk1NE5raytf+tKX+NZ3v8nDjz6KZrawadMmurt7WLZsGXff++vGG9S00AwNy7Qab1rDINOUJIjCBidtx0gmHJQK0aVOLBZndnaaMPJIJmPopkW9FjA7UwHAq9eplovU/DIA1UqNKIqouQHlukunb6E0wWROI69r6KFOb6yZqFwjnUyQDiV2p40MfMxUOwqLalWjLiTNkUSzYjh2DCemYeoG3T1tREpSL+VJOQ7T9ePUmEA+dQh/pMB5lRB3eJbZfAEn18piz+Efb/kVG9eezoXvO59Jt8xgJU+kC2brVapSktNTuFWP6kyBW265FbdW5G++8I+Uy2V6FuSo1Ytga6xatYabb7qNX/z9t/DqBt09i9HNXjTdpNkJ8TwPZIBhgCY8pAqoVEoUCxZutYIgZM+eEzz94c+DjPCiOp5bJ6oV0OMWzc29dGY7ef7+h/jyZ9/O8THFmcsXUpqYYDSTpFStE+h1Mp3tHBkapKOtnQohpwrTpHNpBk+M0NSaJZGMMTZ5koElPeimRnfXSmpzZQpzRWqVCv0LBzh29DAb15+FX6sTd2JcvO0ioijixIljxK0Yv/zZ7fQsXMxCwyQei2MpB0PoBKJOqV6gRo5CNcV5Z7yaK193Ia8692zufvQGIu18/uqT13DvPTt5zZ+v55pP/QV6uo3hySqLB/4S5Q3zkezX6LTbkfI5PvKWj3PdT2/gA5/6DJOT41x4/nkMDg4SKUkikcC2bUZHx0mns3iBz+c+ezWeW2NqdJQwDAmiECOEWq3G0tNWMqBpbL34Una9uAfbdjj/ggupluHL//Qllq9YSKXe6OcoFE3NcSo1l0QqxWTVJ5m00DGJZAjSJW7G0bQpXNo4+7JVzH7gpzz48D6uerfN3MQElWoHN9/6AId2HiSWcLni8tejiDDMIt29GTTDI51O0tu5Al0lMQyL8bkXqFcFB/ZWGTk5iQozTM3k2XvgBXo6Onn9G9/KBRecyQ9vPM6OZ55gx6495BxJGB6iUtlNrqkXFXlImUS3Q6JIEnk+kdQwZdTgsyOBphrBuwodVADIeW5aob2k/hC/X/3xP1kvg+/LXvW/efwfsF4oQGGaJu3t7QhR+IP3/KMAbW1+J2ppb+FHt97Cxo0b6Whv4aEHH+HBBx+mWpujXq9z3nkX8Mwzz/D6K97OmRsMvvpvX2V6eppytQJIXNdnw4YNvPlNSzl58iTZbOPotnLFOhIZk+deeI5U3EbT4Ie33Eom18GGjeuZnZ2lUChw9913sXbtWpqbm0EoHEvg2CaB51OpVKhW6riBT7XWMEiqVEp49TK1coAuBJoKkYQcGzyIxCDwYWBgFZZhErMbu7luS2wnhtIiYjGLns5+hBLoTSmUUKyybSw09CjCsU2cWILWbBvJsErCm2W2XqF8dBykTd/SxRQNhVHwMOMOQoGt6bj1OvVaCd2A8tQYntCp3nkva13YYyp6+noY6O6g0F9k2wc/iF6o8eQPf8mb3v02RgaHufm2H7Hs9HVsOHszR44d47XbtjIxOoaMIoSmUVOSFevWMnz8MKbZ+LsOHTqGaepcevmr+e53ruf6m35MNtNGz4KFmFYC39deHigyk0lq1ToybFBE8ZiBH0FxpopSEZlMitB3acq14HkeaStLFPjkcssIozqT40UM0yWRtDm8dw/dLc1EbV2kNZ2Dw3liwmJkeobuWAdtnV0ovSFtLJXLxA2DzuYWTNNianqSTeecTaFaRKmIwtwM40NjZJJN+L7PI488QiadpFYt05zNkYw1RswzqQwXnHsBQ0NDiJOnKM8VmJmaZdHCpczmh0nE0/iBj24FGLUyLXaSP7nqKp5+Yjsbz1lKQIQgwWOHdpLsN2la0I0y4ujSpb89Tb7wTf792qfIly2WLSux/XvfZsOqAT7xZ+/j+b0v8qlPfpyHHnqIdDpN30D/y32ZgYEBaq7faGZPTzcadvU6nZ2dGIaB74fUXZfu3gXk0hlGRmcplqv83V9+kR2HdvPTH9/Jr37+K177hksZHznVaLjpAtNq5LQmHAc3kKQAMIiUwNRAEDI1N0N7WxtRfYZdp/Js27KWhx75R+59dD/XfOAm2tuWsPVVK6nUjnLrbT/HNBxymQS2naAz24Gul0glJ/CDKqAxOZOn7ntMjM9gO5JKSbB4eQef+PjnyM+UuPGm71AuV9l+521sPHMbza0Gw0fvoSXThBHzGobyQgfloQIboTmYpsJUBg0VnwBpQqg1mAqNl2bLgf+a8vh/uXRdx3Ec4I8ctBEaqUyWcrVCMp2mVKmwevUq2js70XWH5pZ2XNdlyZJVGIbFxa+8hAcfeJxPfvJjNDU1kcpkGyO/uQzHjh/hF7/4Ba997WupVuqkUhlODo1Tqc+wenkfU+Mn2HzW6SAFe/ccYMeeIT760Q9h6TqDJ0+hmRYvHthHb88CLA0sTZBKO5gxi6Tt0JJLsmzxAgYHj/PQvl0sW7mMnq44bqVKazaNJKCzO0upXKWndxF9vUuplqr09XbhxOPEMynmioVGsosQFKdL+G6NuVMn8N0aRncXS5dmaXc0zMG9lA+Okd83jhYLqMwcYsWGM8h1r+SFnTsJu+PkhUQnR1irIKXE80OEVNTCCoFfoz48hCUjzqgVWbT/GNkzVjG3ZyctFUk9P0bfVZdy3Xdu4fjREd75g+tYsmQZejbN87t2UsuXsdD44bXfoRYFfPJvPo+vQiLpoSLJuZvXYRk6tpWkq2OAf/vqt1g2cD5nbT6XhQOnk041USjWCL0qs4UisVgMUVREUUQyncTzPepujbaOVhJGDFvXG0M5Xg03rDObz+O7HosW9+FGGnP5Ir5XRlMWtWKduGnz13/7Bd75xktZlUpSlwUsT4Bp0tSUJT81h+XE0R2T43sOk0nEUSfzXLJ1G91dCzh4cpD9+w4Tb81w4uRxlGky0LeQQr5MS1sbCxcuREYRE6MTnDh4jFecdz69XT0IIWhp7iSbamNyosDQiSOsP/s87rvrLsrVEr+6406kBNetUq4HHN41ztzsGA//8mscm+7kV9sfoRQpLtSyvOMDH8CdKrPrxh/x6S9+kS9++GqG5l7gpjtv5+vf38e2rR/jk6+/BDu1i3O2vpr7n93Jgd17WHvaapqampBhxMLeLiZny0zNzPCe972f0Pc59PxTfPQzn+Yb//xl3vKWN3HHHXfw+Wu+wD333MPmC85k6NQg3d2LeNNb38HJse8z0LeQsYlpvnvLLczmJwgqAULX8COXmGMQBR71WpnDB0+wYPNK/EihGzF8r4qtx5GWj9Jg+eJ+CqFkRtRxWpu54s1n8bF3b0VFgoeeOMa3v3kLixZ0MHh8ihUbBlBankRbiO8VaGltxxD96LpBenoMw7Y4fmSWI4fGiNQkjt1LU1MnX/jiF7j+pq8AQ+zcfQ9jI/eSH9Zoy2ZxYg4y8lFhCLrCMARoIaE7jdBjaJrEr9URmiIKQlSoIazqPBB56CYEYYhhCJRU/L/C7t+lVBpJNo2kJ9u2CeX/RQiCEOJ64DJgSim1ev5aE/AToB84CbxZKZUXje3p68ClQA14t1Jq53/3HJomqFarpNNJNm3axHPPPYeTTODWG9reTDyOZVns3bsf13WxLItXXbKNp59+mqmpKcqVUkPlYUha2powTI2hoYaPrmVZBPk63d0LGBsbpl4u8vTTL3DmprPJpTPsOjTMww8/yp+8913s33+Qr3/zWnbv2YVXd4kZGo5p4HplhKGTciw0BcOnTtDa3IRuwM6dL3Di2CC20Fm5aKAx/RXUmZieIZDwrqvez4qly0gkHA4fPsLOvQeIJRLcfvvtBH7E1778D2i2yboz1xJpESeHRumslXjx5v/FisI4ibjNGW94PZRnCX99EDlxktBMEKvMkjIU5nxD00di6gIlNKQWzh/xInShcEyD6Q6HJr+Hk64iH0SMCDgmMnzt7Z+m//RNXPvok0RZg3q5gi8jnFSCTRs2cWrJSbacs4UgCEinUvjKR9fj6IbWUDHEcmTTzWw443R27drNmZvfRKlUxXMVk/UZQEdoPnZcQ0Y+cTOBkbApVeZI57L4vs/U1ASJRIKUE8eyHGpuGSVCUqkEs26dwtwc6WyWfL6EZVp4HsgoQOka5arkvvuepu+is0hn23D0ObA0dCfFXCRJJJKU6lXQFFMjE1y6+gyu2HYJzzz3PNs2n4elGzz4/BPUS1WMTIK5mVkqdQ80gVutYpk2MV1n+fLl9HR20drcghJgpdNYvsS2Hfr7+xkaPoVp6oyNTjM8MkZPTxupVJp9z47wgQ98nG/8xde44qoFLDr7Qpyf/pxP/PPfc91f/TM/uu4f+Jvv/5ypvQe477HH0SdnuPvXc3zuc3/G1vMX89PtN/O2Szdy09feyczwUa5881toasrygx98n/e9733oQsMQgn17D7Bq7RoSiQQfu+YavvO1f+Xqq69m384XuPrqqykUClxzzdUcPnyYSy65hNt++mPe9ra3MTY1zWlnrGegr5cwDNl74CDt7Sn8qoeiwbEaWkMSaFkWtVKVKIwwDBNQWIZBpENC6hiEeEgShoYXGVSKBwhCD6OtHyRsO38F287/B4JI8uwzJ7jv0Zs4vLfO7T+7hzBy0TlGRAUNgaQNW+/iY5++nHe+2+aM1a/j3C29KGUiREi18gzSq9KdzpDMJkk0dTF6cIh4JcRIJyAmkKraSIqJQLedhoJDNfpfuq5jaDYYOpghoSYA2Yhn+x3A/J/w2v/dasgGf5fn/n1YyMs9uj+0/ieV9o3AN4Gbf+va1cCDSqkvCyGunv/6s8AlwJL5j43At+c//5dLKUEilUMzdJLpHNW6T8Jpor2zl/xcjZ6+XkqVIitXn0YqlcI0HOp1l+HREVKpFDHDmB/qsPA8l117d5FLtbB75yGkDEk6CbramnnbR97KO96xldJsjRUrz6Grbyl9vZ089eTj7N61n0VLlnHX3XeTSDpMjE1im2BbGumEhmnoKF9DRbLBFXplOls6SDpJtEjQ1pZmenqcnv4BxsfznHzmOIauMZ3fz69uv4vLX/tqTD2NsJs4a/P5nLl+G7f/+GacuEE5P8iq9jPpXraQX9xzFysXNTNTLnFauYr0PcJTY0TZELsSUVBzZBYYtPsRBd/DSlkoP8LUQoIgQgUakYyQEjRh4pg6KctEeDA2PUbnxATdIoHRl+aMbDfvSjdT2boZqpN85eEnmDk8xEBPN7W5ItGkS3M6y8jQcdKtaXbtNxBmgImFE3Npa27hw5/8KLf+6Kecs+U1rFidY3x0DM8LyGZyeIFPFIUNo3ctREqNUEpC6ZJIpKmWaighUFKnOFelQgld12nv7CFSkiNHD2OncuSLeQLPI5ZMEIQKU9fwLahEEWZ6AaMll6dO1ThtaT9L+z2m8kUCzWbhmj68fIm5YIYXnx1kxUALb93yFoyFazlHz7HuglfwuY9/iMLQNHpXByeGTzE2NkcqmURDp6enh1QszqXbttHR0k5Q8xk5eZJkOkPCyiE0nQULFjD42CD9SxciTZPz1y9l7aIMnpFB+s38/d+9ljM39LPnqTtwKwWOP7+L7vMuBpngrf/8j8iYzYivMedATTeIL+vj8nM/TX5kmqPHqlx4TjeL123j6z8aBP0Af/13X8Cr+Lz+jZczODrMlrM2sHvvSex0krGpSd71nvdw6PABTt+0nh/96FY+8rGPs2/PXt5wxRu5+6572HDWmdy5/U5WrljD8OgkXhjyigtegRWzWLd+GQv6Wnj44UcRhgGRxBURCSUp+xWQimNHD+G/6kwUIbrnY+oCTUIkbcrVed2zEPi+S3tuOZ4X0OwkCJVHIKIGiBqwYXMf68/6S3RD8JNb//V3AAHQAjwZMTmjKFUlUpgcPlJh4eIspjBIyAg3kOgW1GslamUfoSI0M4NUAZrU0KLGhKIMGtZMAS5CCCzbAS2C0AJNoZSPDkSyhkBHN32UMoEQJTUUkpd4EyUav6Dg/4xCEUp7Wdo3f5P5O4bzGBghNIEgpLW1lYnS4T94r/8WtJVSjwkh+n/n8uXAlvnHNwGP0ADty4GbVaP2f0YIkRVCdCqlxv+b58B1PSDG5MQ0qWSGeDzFwoGlPPHUkyx2Q1w3pFYPkKpG4BURQlAqlSgUCuRSCequTaWqgaFIp5N4bg2pAtKZJKah0dnewaIFfex5/lniTo5yXhJ0ePQu7+Dyy1/D08/s4HOf/yTbf30PQsVJp5NEsoY274BGGDE3XSDhNLS7lm4wPjZCKHTGp4o0dWTwlCDSLArFaR597D5OX7+ae++7g5nCCc7edBZPP7ObXLyVwLNobWkFPUFMBIwOTfLQ9OP80+VvYGTCZeU/fYyY23DKk7qDaekYFZsoiKGTQqzoxZyVWHqcyFfo0sTSwdAlrh4RCEk18qi5JZJCkq9VMCs+SaeJ2PIMQjfJRwXq7hx+qUxfUwdB7xKuyiYJXxWjI5li6MgxFi1eQRSELFq9CqHRGAxQqgG0SiMIQm794Z0sXrKJweMTKM1DKB1NV3i+O68w0PF9D9PSkaFEsxq+234giTtJgiAi1CSWpRHUa9RrHrP5Esl0mv6FS5idnQZTQOijIoVl2HiuD5oDmqIeBtR8ybHxPKtXrqYj0fCOPjQ2jefXMeIGrZkMnZkYa5ctozZXobr9SboWd7HltHW0tLThOTZuvohuxwENIp1qyaVUrjPQ08+igcUY6IzNDaObFpZuUK9U0dAIvIC+vj5Gx6dZvGIJleJevLKga9FFfP5vruHDn/goo5NHWb7+XB594HFePD5LXG/nljse5/DIUXp6ejhjwxpO1WpM3/co69Yvg6altPYuxh+Zxq84vPeqt3LfPTs5dmqGgweOc/6G05meGGHVaadz820/44zNFxFNjDMxOcfFF10GKsCxfcr5GqeOHSJpdZBMpjk1NMa5m88FcRaaaXDo6BCtHZ1U3QhNV0gZ0dSUww8i4olMw+hfSYTWkK0FgUehWKFUr5NzHIQRw9Ab6NPc1EYi4UDUKF6TsTo6JtK2KM7WMS1BTTVOzmreZwSh8H2fiXyBcrWObccpl33i8QS12jQyDOnMdBMFAR1tCTQrjpB1lNKRfsM9UgYKiSKVS2CkdaTy0DTRSIsxGrCoKwlCwxQvVbASZISUHsIXSCtEGDaoRpUrpYESgsaLvgHYYh5oG7grYH6o5n8M3EL9x8fqpYnJ3zaHasgAE4kEFK0/eKv/r5x2+28B8QTwUjZONzD8Wz83Mn/tvwRtoQkSiQR+vU5/bx9HDh3G82p0D3RRuG+OlnQat1gk7tjYVgxdA8+r092RJfBdpIIo9JBhwwugt6WJ8fEpWnJpXLdCvhThyQ5ePLSTd121hXvvupve/hytbVkef/xedu3YzbYL3s4PrvspU4UJli1bhiZDbMDQDfRkgkh4NDVbhKFHIV+gzbIY6G9jZmKUzvVpNAJWn7mWVDrBQDtsO/9CvnvD13nPVZ/lrW97I8WKSzKTZqYySGxCJ5tZgU6NB3Y8T6lcpH/RRnaP1qGa5/PdHVxxZhNuJ9jlMrLrXdCuKP3sEWTYQn54AU/NVAmXtRNvbaNnuEYsnaRUD6gX6o1j+vQ4FTNGLJkgPzFOaHg09zXzygcPM2lALDRwEaQJeO83vkfxxtvZG6YpTEyQTsUwDIOS65FtaaWlPc2DD/8K4XWCtKl7dc654HT2793JwOKlRKqI79cw9AS6HUPTNUIZYJg2rh8gNA1h2jiWhgwj6l6AphkoKTF1A4IAIkWmqY0oihgfH6cwWyQKPDKZFNm2Lvbv201TroWmliSF4hSJRCPUAinIZjrZcXickbn7uO4vXos9NUWnk8BOZYliA4yNHGfh5ix9rc0suOgVPP2rX/CTp37NK990GQcGj9BsN5FIJBmvFZmanUFldbo7ejhjxTp6exZQm6mTSSSxiWHZNlZgYVgJrEBn3Rln0zY5zPZH7+VX22/n3LO3UqsU+Pb3f8CbXven6Ph0tS2m7lVYddZpDM/cx+vecxU7n32K/eOH+d6/X8sH9x3iny9/NX/1d39L78J+Ltq0jfsefJ5Lr3gzu3c8ReR7/OAv/oWvvOsynvvJTwi2vgZLJZnIjxO3BDsevY1MKksimebgrscIQkUQRHiRT0yTEARMzOQpVGpM7HyBbCZJS1srqaZWRiamSWWbcUwbgYUQirpbJgx1IhmhZAQGWJaB67rseHEnSeeDyNBF01yqpSJOKg2qxuhYFa/iYqCIhIamSZxEEst0MI04MdMEwDIkStpIqaFrGv09nfieRGh6Q6Ndr+LWOiiXK6TiCUqlCp5r4sQNZqfrdLQ0I6OAmCFw2hsj8l7oYltxItdrcNWRhqa0hpQv1jBlQmqgwoa5nibRjIjIDAmVRehJdN3DZAxd6KB0BCYoG4kGwp8HWx2U0SiTxW8q8N9eL4+p/zbGid9ovdVLlbYIQDZ+f7Q6L0WSZVt8opOJ/3SPl9b/dSNSKaWEEP/HjI8Q4v3A+wGS6RSFQp6Y2bDffIm3rgUeScfh5OBxSvkSe/bswbYcOjrbMAwNQ0SYukbdjzAMq6GXDkKEaIQq+IFHU0s3McegVCriRh66YVIp12nvyNHft5DjY5PomsnQyb2ctWkjppMg8GdwLBtNhQhd4XoBkRKE0kcoH8uymJ2bpq01h/Ln6B1Ik4wt4NWvfg27dj/H7Gyd717/Ja588ycwbPj0Zz7HO9/5XlA2MdukraOHm266npmJca7/+g8595Lz2HngCP/yqrN559KlUPEZHpxFArGkRp87SXO2n6P5Agte+TqideejDc+w/dY7mPRs9MkKBXeKMIyYnioiw4ip6TmCSKJ7Lnok+evVAwyc1ofgMCKdxK2ZCKFT9WZ4x9vfzPpPfRAhLCLRkHnpLzFw8y/OKPo6uqYjRYDC5PvfeZivTo7j1WZBSBxHQ6gkShgYhkEQSkIlMWMmOjpRFBFqCkNrdOujMCAMG29sTdOwLAvNFFi2TXtHKzqCyfEJ3JqHF7fZcMYmdjz9LJV6QFtHB8W5aTLJhhmR79axYzEmJ2dQ8WY6Fzi0teSoeIoJXyeKIESxor+L+793E48fepYPvvt9PH58Jx1NTZy1bgMHp4dRU9Ms7R3ATsbpaGunOZXB1iySdgIV0fDHzk+CGacpElitnfgIkulmUukcp/X28tnPf51ydYLjg3V+cP2N3PLDvySbWMbyVedy9rY1BPUs773q/Rw7PMimMzZw6tiBRi2XjfO16/4dtzKNH0maMgbl0Tyf+vAHwAhojifI793FuvYUE+NT9DQ1U5ir8I3rvopfqdDX2cXades4OTSD0OPYsTRz1RlyiTjZZIrOjm6aWlsxbIswalg5TM9V0QyTuqtob29lanqCrp5OpBJYsQZo6LoOCmzLaoBLqCiWXXIJE1tTeLqOUhG2ZZC0kiQ6EshAovDnwUujVnUJ3Rpz+XLD16cuMf43c+8dHFl1531/zrmps7pbcSSNNEGTM2FIJg5gMMbgiAPrxDqs85pde52w12mNcV6vA+uMjbGxiUMwYBswMMAMk7NmRqORNIqtzt03nvv8cTV4n33s2vd93nqrfKtUXXV1q0vquv2953x/3yC1uSyayISmaSFChkih4zgOLR1dIA3sOvhBHKEEjutH+fU+SF2iCyJ1iFJYVhJCHdcP0KVCkwJEVDKgXJMgCjgBFCqMg4iiVgPpIjQdTbPQtQQoDRFa/HkCqV5MvQaQIRCKyPkYyiiF8/84/jIn/efh43+NZzWAgFA0ITQQUiOZ0lGB8Vex8/8WtCdP0R5CiHnA1Nz5MWD+f7mud+7cX/oHbgVuBWjv6gg9VxHTJIcPDNKabaNSrLJi1Uq++Y1vs2bFchItaVLJLErA5PQEJ4aH+P1D95JIxBF4NBs+vudgGCGOq4jFE0hN45FHHsWUGf7lY+/F8i0+85GvMTXWoFY2eW7LAU5fcxamoePYDUaGdrNo2RrmL+gnoEkzKKOCOnGRIq610PCnEKGLX2syO1OjXiohlUOz4ROqIr/e/ACBEgxN2kw7BW5/w/U0qi4zMzOcPDzEstXLqSod2xZ88z9+yvM797GkexFrejt4SWMn71tmsmSgwocC2Ne7lheaRV69rJfMcz+CEwYTfW0Ue9q5WDvK+dpxNq5fwP55K2naXfgZG2GaVCYKKOXTCJpUq0W04hRx38d8/HkmiwIhY6Rkg6qrSGd1HBf2zuxj7fABbvnVrzhw4DC/+FmUPoeEvv4OHv7jbzEMjYGeC8i25ChVpumZvwS0DgLXRBN5Amyk2cSQ0UojDBWWYSJ0I0o/m2voiB6qAtM0saxY9HCuR+FSoYiMHEiBYSXoXTKAlBpDR45yZHic015yKRMTEzSdGhgWpVqD1lwH1XIVzYwTVwG/vPsPvPWayyhUpwl1KI4cxsLG8jUGTnsJy5ZswP95kq6rN7HhUY+T5WnkyCyucLj49HNob29nweKFJKwYlUoFXdOoNitYukGxOktLW05JCAAAIABJREFUwuLYyDFE2zyClEHenMd73/Ve7nj4QXx0tLn0ui/d8nM6+hP801m3U5qe4NixI7ilJO/+h+t54J7fMjE2zI0f+ySPPfokmgpJhxne9Lrraevq5guf+yf2DY1w/bvewvmXn8s3vvtzevoWE8Nnw7o2atk4s9UCqZYkKxauxhA22bZ25vctYX7fOgqlIgcO7sKpVtl3LEp1PHToEPVyVEl34aYLuPUHP8SM59mz/xALF3TQ1tXOiaMn+cbXvk/f4l4acyIAYURhSNlsJho8axmKJZvZSo1WXdHT2YbvCZTfpG57VAuzJNMZQsA0LUxTn6sT0whUDKmBE0SyvkwmiwI0wwWl0DWTwHdoyYX4gcCtSxp1B00XaIbAtwNcbYo9h8dZ2N6O5/mYmShbPgziWFYH8bjEbjYx4uZcDohOGAQYuiDij0NCZRIKew6AIdQinj0MNZxAoBMD4SBkVMQr5zJIBICMqBWEHwG/+Ovg+t+PU8+BUytxISQIO/qqzQVmhSF0zssQqr8Ozf+3oH0f8BbgS3Ov9/6X8+8TQtxBNIAs/098NoDnuFSmC2R647znPe9h8cJFLFu9ktZcOxKYLEwyM13i5GQRpMDzHDTdJN8eOdcCp0EQ+MQMiWnpZLMteH7AO955A6+/Llp5e57HxMxJzMQCepdI+lecTcP1KGKDqzBLdRw/5Lktu9n2/CFKjRlsVUKFTZxqHbfpYjszOI0mfj0kbsVwajaL+2Jcf8NLGRobYcnSHkKlc/5LLuTBx59nXu8SGpio4WFecc5prNywkuFGyF0/v507N9ewC2OcefEqLj/nYvwvvplc3iCY7mRUA0+rYxWHmDo4gTE/SyhNVi1bjh0UEAe2MLznD1Rj5zLqpaiKgNmxKUIsDM+JvhhOg1hMUpktUK7X6LQUw4VJQmHjlAy0UMeedZEC2h0NzTC55g1/x8f7VnDg4CK2bxvizDPO4Pnnd7Ks7xyefOYh9JjGppddxPZde+ls7+PkWBVhKQzdJ/Cj95BoCI0oF3lOGxwIgWWYSMBREddt1+vU63USiQTJZKT8teem9nbTJRQ6VixFo27Tv2gl42PjjIxN0pJOkIjFmS1OY8YsQs1Aswy8SpVEqp09e0YYP7fOPD0kplnETB+UzpGR4xx+fgfL050YJtR37EYpyBgpejfMZ95EJzOzJZbM7ydwXJq2Q0eulTAMsBsu0oxhJiyMWo2+1k72Do/QGmpc8873s+vAwYh2DwWXv+wSHnrgj5x/4XnIQOe2X9zK5Zuu4KH7HuHIkYNks20Eocul4irGpya5+atfoeYEfOcH3wM32rrfcce9FGbL3PTpfwTggnPO5JmvPonnCcaHJjEbBfpbeplyXI4NHeHs9acxr62TqZMT/P7xZ2lJW9x77/3IALJ9iyiMHUELJEidbM8Aa9asIdfeRnn4JP093WRiKdIpnZZ8BzPlJqsyOXAqqMBD1zVCqZNOJmg4DSzTpt5USLtMJWXRg4ZSDpZlYVk6cd2g2bTxkXhupHt2fQ9pSAxNRPdFMoYXBNSdCr7v43reXD9r5Dp1XZeEJQkCA90QdHe30Wg61FURM5ajvztNPJaO0lHnjIZB4DE0NMGBA/u56uWXYTcVuiUgFITCxMXHwItyabQQ5YcIEenQle+hRPTQ0AgQ0ptTdxhIESdQDgQySiUMBGGo0C0HMFBKoUmNkD9z3Gru9ZRaJCREIv63a06dJxqBRr8XAiEUMc1Aav8nxXLq+H8i+fsl0dCxTQgxCnx6Dqx/LYS4ARgGXjd3+YNEcr8jRJK/t/1P7w+Qz+W5+eabSSQS0TYGmCkUGRudJN/WChqUanVacnlc3yeVypBOp7n99tspl8uYMiL1dQMMw8CaixZdtGAR5UoDMx5DTyTIJTIk4ll03SQwdJpBjbSZx4srVCbDou5uljdCTM3E0AIS8RDXaVCvlzFiBi2WSaU8TS4Zx7EbiMChUBrGcxyuvOQirrnmJlKpNJddcQ1bnt1DT08X8wYWIJWGE8SZOFnmG9/6JosXLiKR7aBtyWp+dvfD+CMTvPs17+AEcYaNAdbN3EWiNMSZTsiA51DPeiS7++i47Wnk3ir2579A+sxXc3yszOzhGeyOOpptQSXEtHQCz0OTCs9zCEKXVCYFxSbxwePcd+Yqsm2ttMVznHROUpRt7Dp+Emll2bvlGbSmQzrVQaiGcR3ontdNqSh46vFBFvRcwNanpkim5zM+6uCH9ShIR28ipCIR78BpRgNDhcC3bUwrThj4SKKbNZlMRNZ+IXHdaDVXqVSiG8E08TwPoeuESlAqVognUzQbLp1dvcwWJ5mYLqNJaM93YVo6k5MTtLbP49hUkdCo0SjN8rNfP8zn330tul9j4fxuZsYKVFtaGSuVWJlNkm9vY8eu3czr6aGzI8/sTAG34dLb1ka9UEApRaolQ2FyimaoyGQyVGdLpNu7aTFBhC5G2eORLVu45btf4dDRY/zsh7chYyaGU+XctZvIt7Xiax7zly5mbHyC9RcsIZ5t59ldz3DuutNRKqCzozX6nAKFpmmYpkaIpND0SGQy1EKQIqBi2wTCoFYvU5gep2Vmhpu+9B/c+fBj3PvgZn7z89v4xre+SXtbF6WaQyhcenqiMVPbvB5ueN87+PQ/f4TNmx/nm1/7D5avXs/UdAmBSbE4zdHjkwTaegIVY9NlV9J0pmjJZfGDAPlfEuyCIMB1PCYnRnn5BWujjsOwjmloNF2PIPRp2HXMmIWmvCgjOrAjsBYaejxK8hNzWdSRBkOi/bdcj1M0QuBr7N43RNe8jSxdsZKzzlmDplUYO3mCyZFphodOMDU1Mfe3mXzqE5/la1+7hWp9AmE4IA0EEg0J1IEkliajrGvtz0oOTZ6Kx1bomnoRFiNsjcKeHDuk0Qio1ss8+aff8+Y3v54gcBDSByJ57SmglkTVYioMXkz+C4VAk1rk6TkVAUBE98g5SlKpEE2T6FqCWvX/Q552GIZv+Cu/2vQXrg2B9/5P7/nfD891qVarNB2PVC6H1AxsPwTDJJXNY8UNtFiS3/3uEUzTpFYpM1uY5Prr/47WXI7S7AyGYTBbiTizeCoeGZx8heM3qTlNao6PriWJ6Un8wCPwSqSTIapZJ5vPE8QktelRYraDlkwSj4WUpqtYsQSe42FpOruP7sZ1GmRTSZx6A+V7xGJQLUyzerlBT4dBpVrl8ovP4cYbbyST6WDJym584K1Xv4k7f3UHb3jTOxlYtYxErp1HvYCqqPLqK67BS56kvbuH8c3PYY8dZaRY4Jwb/5W6lcIoWGjDj6BfvR63Iqj8+k4mSkWa1iB93Ss4VjofR+mEegPPDdCkxAsUruuCnsDRNEYadU5W6+i79mPFDDpkimpHC7vKQxhr1uGYIXqzRCoDtfo0Uirq9iydvd30L+2gvb0dx8ljGAblWhXdgNaWfhqOTRAoZCgpFyNnqhACqRsRKPshumlQKpVAhehGVCwR+H/m93RdRwiBY/vEYjE8zyG0QsDEc1xMIxkpBOa4Y8duMF0sUSkXWbRoAbZt0zF/CVOjx0nG5rFt/16M3IeQtTE6NAM6QnquuJzpYoktj/8R1w+QQsP3A5SvmNfeQS6RYs/u7ZTNGD29fVRnK7ywZzcjoxOsPn0dqXQLnRhMBxbSgKaucfq55zA9O87BQ7u4+jUXse25bZyzZh1H9hvM7zDQqVEoTLJ7+AVOW7uSlliTxZ392E6NarWK0Aw0zUDTTWKmRcXXkIZOvVbkZLmGavrUqkP0rNmAryvGG2WoFUnZVaqNCkrB6697I5YJPfN7cRoevu+T7cyTMOKUCg1ODB1n7UUv43Ah4KYv3MLJwRF423UoEUMYEWj0dLYzfHSUefMX8OEPfpgf/uxbNIsN6o6LFteQhCRSaZzKLL6CYmkGAg8l6oS4iBBa0kk8pSJJX+hEwBVhQsSLYxNxvfYcDTCXqCcgUKfS9aJ7Isrrkfi+YM3ahVz58qs5MT7D4SPDBH6JyuwMo8OHueGGN+E6Iffddx920+Pb376ZlSsHiFkGAwtWMjh4nBWrOuntzdPVsZSnn93J4cHDpJMS07Dw/BjIOlY8huPYmKZOMhPDNAPi2hJUoFG3Jzn99NMZPtqgUfNYuLiLLc8/zN9d/3qEtCMaQxMQagSBQuhR41WU1aK/WKAiZXQ+yiSXhIq5pECBQqACheeFGHFFrVZn586dfxUv/yYckZ7n0XQdMvEEQtcIlKJv0SKqpSqDh48yW57i+MgJkokMq1evxtBAipDNd93JjmNHogYMzUCz4oRS4AOGqWOhgQgxdUGSGK4XoGkB8ZjEa3g06zYtiU7KkyX6ertQsQQtLSaEAdte2ELHgn4aNQclDIaPT1CtzLJy+VJQglhHDE1Iuha0cf89t/PTO25nbMrDNDVmCuNsf+F5anaFkz+YwIy1cGR8B7+4+/u89KWvpek00eJxXnHVaZw5sIStex5Dj0vcsZ1ccM4GSvYUqhxw7unncXDn02TffRnuj+8hOdrAbnTS8/Y3093exUZnlN8//jQdvkUlAQ4xLN/EdZogJXosht00sVWIXNOFWNGCrdKUqw7H95/ghfExYukclh8yic7K089D0wWLFy9h2/PH8JRFX/8iXC+D7VTxaSCEJJZIEU9Y1KsNfBWifAPf84glTMLAIQhDlB9t71w32mom44mII5VhVIowtx0+dUSxlBqGjFZiWlQFQhgo3NAmCDxS6RxSSur1Om2tnaQSKRzHw4olaFQbxFJZ4pZG1TMYnynTk0zg2WVmirMsX7YGM9+KCAMsK4VhWgihUanUSLe1ous6iUQC1/XJtbaBoXF88wNkMzke2Pw7zHSCQ1v38OD0EJMv7MKqmQwsH+CZF54hn0nj2jb1eoOqXaNQAhU0CQKX1UuXsqStF+xpZicP4YcxGnVw7CAKRNJFNHwLFaFbw/M1fBFt3cuTE3R1xAkcG186OJoiNKN5QLlaQdMEiwYWUy5NY9s2ruuSTqfxQkgks+DqHBmbIpvJkWzROLx1J739S3nlda/hmae2saCvn3q9ziuuOJeZqsJRkte+5lpMTUcmMjiOhxARRKRSKaYKDlYqTrPZBCmiqiwkSIUiCkrThIhKbCOxNacKAiJAnutDFackc3O51FJGK81T6gpChIpy24UM8AKHWrPAwf0jCDGLXS8SN3S+/vXvEfiC+fP7KZXqNOwyI+OH2HT5abz2tS9hx7YdXPbyM7jgJZehoSHlSl73+muQXjsTExNkMiZhaKBEFLsqNRBCoUKXWsmga34Xw6MFvvmtW+jq6kRgcuutt7P5kZ+A0lEYcxngEk3T0TTw/UgZpWnMGZCYKwHx5xYn0eBWSg2hTISIpH1CC0loAkXA0qVL+MD738NHb3z4L+Ll3wRo247D0888S6Y1R2tXD1Jq9PYtQtM0WtvbyOVTWKbOrt372frcs2QzadJxk3e87a1UKyXqDRvXU9zz0O+YnplFN1MIDUxLA9tH+j6Wb2ApHek20IWLpTfJ5mIcfOEwZyxbyK7ffIWNZyzjD0/+EddVXPu2C0j0JxGpGCcnEzz3dJH3/+MH6erqolmHRDzNvK75gGD7vhdImxnOuvRSLMOia34n52y8CKEnkXYLn7jpc7zwwgl+t/lZ7vrh7znjgvN4ctdO7rj7l6QIibd003PGKpbNO43i6HEG+gfYd+wwh2plcpddwez7r8NgkmSym2JQIpc5Qc3eh7kHNljLuLejTi5uojmSpGVE5obQwcOnPDOLsn1K+Q6UBjOlkLoQuN2z9CYVJ0YP0mobJDWNex9+gquuuoIT42NoMQvTyvHEk3vJtLTi+5JMdh6BigC0WJlGBAHCixOGAboW4jRMND1aNTmug2FYeMqjWW8ShEF008rIxm6aJirgRQdaGIbI0MB3XHxfzXF8ksDzMRIhSgmqlQqhglSihWq9gvIUZlzn5MkJlixewsjocWYmtpOJd/HrO3/Dh65/C8eGd5JIJCmUijiZJHK2hK4lSLVksD2fTCbD8PAwUoIVS9DV10FrTzdauoXxyWl+e+9mbvriv6ELnU998ib+9MR9NEtlDg7u5cjYQVKpDHHD5GMf+RIrV6/gO7t/wsnhXn6UieOENeJaC9nWPHd8+Ufc/8hTPLl9N1MqqmI7tfrShMSXCh2B63vEEgkCx2X04GGSsSp+WxsyJaj5AplK0t7eTv/CBTzzwkH2791He1uGmGmgCxibnEFk04xWC6xYsJzB2RpK6My6PmHocMHFV/Dc7mMkMp0EoU5f/yKSUifXtZJnd20nYVj4ngPCxHYdVGgiEHR0zuPAgSZ6xqBSqUXZOoHAkMZc3rSOLqP2ljBUhJG8Yk73HNEBQTgX/h9GcccylC9qwUOl0GQEcmGgUFoTTdcJCdmw4TTGixXWntbF/t1bSKeSmLrOG950FQ8+dDfDx8dJp7u45YufY//BrbS2Orzh+uu4+KKFdLZdwL9++X10z+vnySeP4PpQKwWY8SyOUyBUPirQcL0QXZegKxQusUScyZlBOnosurryCExCYMsz24hk3yEohQqieZkQEtOy0HWNSrXC7OwssZiFpmmk02l0acy5MbU5laCGEH+mhYSI6BEhNDKZHJdsOu+v4uXfBGgbpsHypSvIZvO0tHWQ72wnkUkyeXKSR+65Cy2pk8u38IqXXYgUOs2ax/joOM888xyZdILujetZYuWZfXorzxcrjGk2rleno2HiixhBLIEtAurKRqkSOQHlp59n08r1NKaOsn51H794epTFrZJrXrOWL315J/G2YVwpibOcS1/2ZsLUszgjBbbs2s/Kc9YQqxd46HO/wKWGnJjk+o98mJ27d/KzX/2Azs5+Bg9OMTs+zbwl59PSnQdZJ9vdwxv/7jymZ6uMPHw/fZ09TB2ZIAxDrjQbaMXnaFm3huTuDg69cIjpo0P4jUMQt2gRKfK5PIsqDWbu/j6KgEees5nuOovh+QOUalMENZtmZZZms061XqFWrxL4Ctu2aRZKBEJyYuIkASGB44MAM2nSev6FtCazbNy4gnxHmv756xkfDaiWqhB6eHY0MCR0CTwfx3EBE00qQk2CYK78QKKLqCNPSrDtWtRX6TXQ0BBa+CJQuY4/t0qJYgzCEBQ+oCM1DaSGFAagkCEEvk8mr9P0PPwwoLO9g4nJaebPX4ShJ6hU6+QzeUonU4SGxr7xaQ5PniQMmmR8HUOFhBUHaRmYiThu6BETUaqghkS5AVagKFVLKF8gazYXXHQhH/jUZ6mdGMHIxvF9xfd/eDvnbBigb0kfBFGFVratk/4Vq0hnM5T0pVg1AwHUfZ+kqXHX93/KV27+AhUHSiG4zKkFVPRl9eYGUr4I0GQcEYDvgaNq5DI5vHoNLW5SKQmKLd3c++CjPPKHRwl1yarTzmKmOI1TrSCUoCOfQwqToldi/sB8wl3P0bu0k5jjglTk5qURusCu2cTa26lKExHCy6+9mmPHZ+kbWEotEMQ0QaMisKSBokI23YHvGdStEkFQBi9E1+NAnUCZ6IFPqCDUojjiUEZ65DCUaEIHFaCLaHIYCjEHgn+u9EOThMgI7IWOEHX8QEOTkpddcR6b795BvM0iYfoEgUPfkiX8acuzFGdh+arFZNNZfnnbz0gm0gwnavz41s184tNfJJnQses+gXyGZatXUq8qOuItePgkU2lcD0rlKtKQSE0gCTGERuiXyOfSDB0e4u//4T30ZhaT7czTHH2Opf1ZCAOk3kKoXPRYEi2U3HPnfeQ72mlt6ybwNbx4gKsUs+MzSNNCES1YQhktVFqSCSbHS0ipUygUaGnJkUhZ/PauR3jwd8/8Vbz8mwDtUIWIQKEpsGt1jlXKjE2e4NjgYa4452ysbBKhwbNPPU46nWHdqrNYtHAhXR2d7N23E7ltK9/66L9wWs1FjE6x7vWvZnrHTi6O5fjdkQl4xUXk++dDrUC2I0VwdISF+xtYL2whPXqQzU9tpysLl/59L/mzy3znql4Obmtl1x91zjz7dPLZ1bz62j7u/tLXKPsNHp0+xNDjj/GRFZvoOHsDo14doXKcdtolFIpj/OJHv+Dh3zxLLB1n6PjPsdrioJJ89ZbP88ufdxKz0jieQ70QUgsE3/7Zvdz7kMfKRa1YLXmeeGKQE02N8x++jaHCOGd1tSJEAItrqFQCeflb2TM9wSe/+mne9o8Xs6qvh1i+D4mOjomu69TqFUzTZHx8jHw+z5GhI4R+QGDPIpVLszSJEPDEs4cwzSwND1Zv3MDzT73AHbf9hiXL16B0yKRzaJpGiKJcK6ACIDRQCnwl8D0XTYdYPEYykcC2bXzfxXXdF12rEc+toYiSDaWUUTP13AobInpE0wWaFqkOHMeZ01pJLKHjhz6u62JoOr6KHJX5fCuHDh0mHo/R3tbGbKkAySzNRkBV2Dy3ew+LrRqBZ6LHM7jKpiUdp243MU2T1nScwFOEto0SPul4mhI+x44P0p5q4zVXv5rRE4cQGUX/ynVsvnszLznvavbue4IP3XgL17/llVx+5UYK02VqZahnbMYP1elsn48EDD9GqMOCpYt58wfeyse//BOUtNiwfgXT05O0pLPU63UGli5hYmKKwBdMTY7zzvdeyaK+jdzz8JPc8J43oXmzTM3MsHNwhMl5Gd533Rsp3vwjpEijdyygVmoShjZh08G2GwgkvZ2d7Ny3C3qWsWMCvIoJgcZpa5Yi8bHiFlIaVMoOoVSsXL8WF5tkNoUb6OhCUSpXUUESNEk214njCoQmaTabSCPEUTamJtCFHzllCUFoqFMGFmEShooAQKi5gWNEowgRFW9HFvEXVdAIOTcEpBVNAEHIulXL+PIXP8tVV1/LogGDNevO5cln99CW76ElHTI8NER6lYlyoG9hPzf96wfYvmcXv/rZXSR0ndHSBIlMC+nWPPfedx/D+wZpzXTQnCjQ1D3ae7qJp5IUqxWq9RpmALXeHJoZ55WO4oZcG0u8EzA5yn1LOxk7ephAg8CewYjlOHP5q7CkSUePw4UXrOWDn/pcJGWEuWWIejHz5H9PeHXond+KEBpCLH7x7GRhNQcOH2Xrs38ZL/8mQNvzXE4cH6ZSqtK/dBloGrWay+RkAV8JzNDAdhxs18NyfKYLM8RjaWp2DSNmIR/cxRrHpzFVpVmss+D4JMs9i+Hnn2FvWCe5Pc2ZG5bRNn8t4ewMvpnB6FvEjOPz6NBumq7LU8A5W3yuPu8Sdu5+BrvZD/k26kaWw/uPUS0PUjJ99g8dJNdWZ8OFS/n5n+5n06o27nxqM69+/+fwRImjk01Gp6agXqIz1Yrb3sr61Wu4Z2Qz1XIdlyJVFxaefSmmVmNqRpHMtrD0Zefym82PUa9XyQWgC8EfRxvIQoPRk2UGxxy+sziNljW58Nob6Fh7Ft3ZFuaZcUac/bQWuogHFrPNEr7vI4WG7TTxPIfhE0eol+t4noeGgwrqWEaApptMV4u0+BXihuQtb3sXd/7mPjacfibVsks8Hm3vZgrThGGIG7gYuoVAolQ0LAqUj9v0CJTEM4IIkGXURC1lpBDR54YzijCqw1IQj+svbp2FEHN5FW5kthEWuq4TouOrYG77GVmfQ7RoMCkjzrO9vZN6vc5ssULXvG4KxVFqY1O4ZsjIxATze1OEQpt7QIjoJ1BoQuJ6NsJXpBIJwjDE1A3aQ0FGpMnmctjKZ35nP8PjQ8RUyCe+/iU6V23gsivXs+nSs+ho62BmahanqROEikAJ2rJtpIwMKMjHUwglGSoWuffJZ9nYsRAvn2BkdoZA+cyWZwgVbN26lc6O+RSLJeIJybvecx379w3h+Z0RPSQylJohAh0RKIwwINAEWuCzetkSTuzfTaVWQnNsOnv7mGo6WOlW2traiBVn8I2Q7NIQwhbaW7oJlIFSAl/5hCpSKXR19kQuVj2ibaTmYzdcxJxdO5VKo1T0+TWbDkr5yFMNWiKiRDQjhiKcG0b6gJqzf5+aXRhz7sKIwUa4QPCiQ1CIUxq+/8KFazMY5JmcHEJoNu3tS3EcQVu2j+JMmYmpffR0rSFUJqlsAy1e4PCRPXgiYHRihISEUqPG5NgwvjCg2mBpew+VZhU7LmiJt5CIxak06rS2tuLKECUDSvUC0rYoDh/Ez6eZ2r+HZE8XtVyMol9FKtB0C3DYcMZ8/IZk8tg2Htx8Px/81E04to0UjWj3gEDo0YcVBUdJwjAkECEExos9qiBIp1ro6epkcuL4X8XLvwnQdtwor/rLt3yV7/zop8zr70cpRb3ZJJdtRSTS2JVZBofGmNcF3fMFM+MTxDIGj/7pUf7w8Y9zab6Tc97+Kq4bWMB9j2/FL2hc+8F38O2vfIrZYpk3/8PbiOspOpf3EZMet7/wBxwnoNqTwJtscvM3PsMFl17E0QNxBpa+l73797K4U5Dp6eHpk9O4QRdPBCnGpMbnL1nA8Pa7GXi9xVT8AX5199ux9D/RkpR89MZraIw8zM4njnF0rMh8rcolq15FS9vF7Hx8K5arUVQu17/mIq563eu58vyrKcxM8NPbHqAtlabP8CmYSSollx8fGeSM1Ut4ZGyQYeBHVi+14zNcWm/jqecOcfrpK9ix7znWv/JamqWAGg2k5mBq0NnRyooV53DP3fexbu0KJqYmWdjXz6E922nJJBkaPEjgC17x0stoeCYXX3wxu/efYPGi03BsnVg8QalUilrUfTU30dfx/RBDl5imThgKNN3EthXVSg3TapBIJNF1nXQmCaFE12NRK5GhI3VJo1khHo/junYkvVQBYCClRiyWwvd9CBW+76JQJBIpGs0mlmkiDYllJQiVwFeSUERfiPbOHianJ9i5ex/zu3sYmq5RrM8yXarh9GbBilFzXVQo8QtFEqkUpmFgV+vE43Fmi0Wy2SyZZIZaxadl6VKoNZmdHiYoTdE1sJbjDYfndo2wZ+QwH/4qosmzAAAgAElEQVSXv2d20mbv/vu5+JLVtOV6mJg8RLOZIKQXX7UhRUC5VGfwwF4+9KEP09IKg3WfRFBh9arF9PT0sH37TlLJNK2trRwePBQNZoXPjp3P8/GPfoc//H6QoRNVWrpyBFYeaRXQ0ha+VyOTTlEplVm/cgE7HzMxaeHkUImTR48R5jJUq3F0qaO1ZFmeFxyeFWTWraOtq4sRpxy1tigD1wlBGbS3tpHtyGNoJmWnQeDbzMzOosQifCXJt6ZBWVjSpDxbBhXRHMgYoBOoAIGBE/jEDRMtPIXoIVGRLSgR1cuFGKAEIozNqUvmrgzDqAQXIjdjGKITJ5AOX/3GzXR0d9LwQpK2ydSJYzSbMzy0+U6effoEv/zVI9SC51mYaOU/bv9PAmWQjxmUJqdoSWXQZEDD1ZAqRHcCinadot2kxYf+ti76O3o4fCDK4LcDSXco0SzJvq55fGJmCt3U0QpVbBVQaAQoqeOpJDRDOmQ/v3/6QTZdvpqtzz6EUAaa8LF0AyU1pNAJQh8pBCJUL2b4+K7AMrRISPHiQiekWpvlgYduIxW74y/i5d8EaOuaRixmsnDBAur1OpVKhUSmBdf3+Oo3vkm+dwFd8zsZOn6CffsP0qi4dHV1kUqbLFmyjBvDBlpoQiBwvRIfecdHQHoQGrzyu/9M6YktvGLFSpadfhaf/sa32Pb4brpzbQjlMNC1ggNj27n22mvZsedxTDuP52Qh6OOpF55G7TqJb6ykZNdInXYVlWMz3PGLn3Ll6QbtrU1ODO9l2+MOKzaOMjWiIex5GJbJKy68lPHRkO/eczcnv/o91l12EbtP1Pjxxz/Nli07+LevfA/f72JkYgbfVhBE3FrdMsnFPDzAteHk8RO0BJK4pmG7deLLeuhZVeLhb93Bk9uf4o4776T6wD5Wr1mHHvdoNiLr8Vdv+TZbt+4kmYzTbDgEPuhINM1nYGAhg4NDOEqCUFx+2aVse2EHHd1raTTsKMTfbRAEUe9jFKDvRtIk5dNszkammEQLvi8QQsM0Y2iaT6VSxjRNUimJmJuu+15AEIQILbo5T5WlKhVpXH0/UlK4tQaapkWuSARSSILAI2ZFK37b8VGhjaHHUCrAMhM4jkOIIBFPkc/PI5HQkaaFF2h4nsAOAuqOSyAjI5ulApCRCcs0dbTAp7Wrg3S6hWY92gUUZwpUh8eY/9Kz8KYLiJrNxOgItpnjS1/4HoOHJ3jLW1/Fw/c9xmOP/on1a9dHOSpCYBsevlFFoFGqTjGvM8WChZ1s2baVZKqfdCZOYWaKUqlEa74N27YZHRshl81zaGKY3p52RkeqHNhdoL01SVe+BU/Ayakhav5JJmZznBgfo6O9i0q5zOjwCYSh45SqxIUk2zWPpmWg6YJFK/vZu+04OaFQs7OkTEi3pomVHExXxzAkuq5jxGK05JORxVwFuK6NkCGO56LQCUONRMJE103KhSKyvw/DsFA4BIEkDDV0PU6gwDIsgqCOJs2oafxFOkDMrahPvZ4qziVK0pur44oyOiItvKaHOK7ENFPs2ruL8y+8gFq1wExhkqmZw/zudw+w6dLLufQyj69+7RcsWB7HrrnYsy4poRFONWjVMzilkDBhMV0skcll8XyfdFsnZy8dIBsatIkYHck8jdEy01NNQt3Fr9dwYwalZI7Drg1GhlAJupuSpq3h2wEVu0xHKs/StQv53m3bucIe4MCRAggP31dYRhqJRIXRwkQQWevDINrdxK0YvhdgGCZh0CREECqDY0fHOfOM0/86Xv7/BcT/bw4hBM8+8wzHBo9g6VakJEAjrqVZv2qAeT3L6Oxup1aYgkCxduVqVABt2Rx333UnN73v3fzzh97PK17+Nj5782f55ve+z6Zzz+Gu3/2Rjc8eR6vCU5/9EU+o/6R100rWnD2AOQUXdS9nqFDgaCjYce+fKKtBunvamJo0aVncz7GHaqxcv56BRRs5Oenw9O4p/OYGBvoaeMGz+P4Yi/vaGdkdp2RVOOuia9DMTdx69CiPHdhLsxGw8awN7DhyAje+iO6elXz/vj/wqle9Bm/3XoZGahgJDcOx6V3TxwXnnsUTm39PZyrHc6Uhvv6ZD3PmmpV88p/fy+tetoaYYdPYuoUj03D++S/lYLPCstYE2TGTI4MHWbFuHadtWEbgw3vfewNTJwvU60WWLV3N8uVrWXf6afzj+97Pww8/xCtf9WqufcWrue+Bh9m6cz+53EI0oZB6gkKhSLPZxLIsgiBEapHWVkoNFUCz2aRWqxGLxZDSQIqQWCzE8yMzgeO4+F6FRCJFiBc13ghBs+6gGZGLzA8c/MBFkxaJeA7HcSJKJAxfpEOkIag3GuhGHEOPARJJSIDC0CNu1YzFmS4UaWvPk0xnGR05xMLlZ3J424NMFMsU6u0YhoPZcIjF4njKIRCCpmOTz+dpND3a5+WYKNXpyM2DeJ0b/+mDPLTrBR556EHWLB+gkUtz949v45Hd3wSRZt3aVSzsXUjCStDUNEqFCYSUTBWbtPbMZ2DVxXzvx09SnN7PxNhJDu2fYcXiBUgtx+CxQTqXL2RmtkAQBDiOh930UJ5Ne74ViYXFKnL5+Sxd8k403adYH2bVktPZtn2KPc/t5JlFvZx55hqOHjnM8N7tBM0KqBCZSFGemCEdM6lmW/nDUztYt3Q5v/32vQwf2s8VV7wEPSYJfQ3T9Km6dUZGh8m05ujsaOP4WIlKrcx5G9dwaOgo5WGdQAr80Mc081RmRjlv47n86uc/4dZ//zIoH12TpFOt1Bse515yGSvPOI9vf/aDFOwq8bAZhUXh4uOjG1kITQLKBMrG0FMIfBwb/KBJKtFBw52JlEVeFABnWe089OBONm26GMMwSMXSPPfcI4TKw/Uqc8YUjXPPPhvbO8D0WIORfcPE3ZCkYZFJxBkvFanpIVOlEtnuXjw3INW0OXzPH+jMt/HJT32c86+6itv+9Dgf+dq/8/YPfIAde3aQTiZZ0JcnVi/Tlsmi7BARZijbLp7lk5N5JiqzbDx7Je+94YMMLNT42MCb8VSIlYwThERWG6UhBXjCR6KhBSFVr4imG8SNDlzXxjQj/6RnF3n961/G2Hj1r+Ll3wRo+77P+9//fq5++Ss566yzGJo4SSIVp7O7k4mJcax4K57fIJPJYtdsdu/dz1VXXMVPfvxjTDPO1277Frm2Loz+Ds7ddD6f+ewHiLXN5/v/+kXE4CFm9u/nHJFA9nTw8HSDdF8HHckMDz29hSP1Aq4u6emusTjbxi/vfRjfWEf1+HbqjoHnm4wd2sr2PTtJLzoNPW0xPjNFKubQKePUA5NQV2TzBlufPMCCZQvREz6uElxx5cv5+n/ejDQSPHDPnSCn+LvXfYZ9R48TiG4ee3gPMxMT9OXzHDqqc3j3nYQS9IVdWHGdL3z9a2hhjCtP8zi6dxdKtJDoWML04a2IlGTFKg3LgLJn89Y338Azj/2RL3z+S1x33XX8/tHNbNu6j87OVmq1Bj/+4a30LVzAeS95CfWGzZ2/vZ/hE7Ns3bqLJSvWkEiClDqnsr/i8fjcQNFBSPC9AKQ5B94S3/ep1Wq0t81DBVGYj6YZaFqAazfxBcRiiYhGmbMmB2FkwvE8D0OP4fk2KnQQIsTQLVQoUcp7casYhuGcMcGYW6GLOU4wOkIR4iuFaZoEYYDygkhCGEYDTN2Ioxk6CI2JqZPk83n0wAFdkjBjBFqIpltMFgu0t3WxZ2wI2XT46BdvYv5tv+XcK6/gx1/8MivOPY3W7hy3f/LHfOzGm1m9IYdlSBr1MrqucOpVDKVYuijBjJ3nvI2X8vwjh3CDKkcPj4HTxfTJIqtXrmFENfACxYIFizh08DCrV69l1859VOt1euZ1EIQQyjhCxnGdGfxGDV1vcOjQToRqAorp6WmWLluFYVhoQpLJZDh06ABoOgsXLqJaLNCWy9LS3cV0pcix/VupjhWQTpqmq1DU8ZwQM9ZGsVjEa9YZHCkSNxIoNCZPClQzTrlWRXoGyoDCyTHMWAt33flLLMukp3spupDoMiAej1PX4Ok/PckHP/p5PvqFf+PLn/gY+Alcw4FAEMgEod/E0EN8x8CKxVEqwHENDD3E0PMEYRXTiOO5HmGgIaRJEOj84Hv3kExZjI+NUiqdZHqyRK1WRkgbqYdUKxrXvnoDd/78KCPHh/jlr3+Filk8+Nv7eO2VVzF6dIjCZIFkZwdOAP/2sZtYv2gpl61bjasLJoYneNe7/oG663H46DFuePfbMT/0Ee677x62bX8AJ1Gn5lfJZFpx1SzoOoawuP2OB3njmy9Gts3j/vt/z8c/9ibeecOb+Lcv3kKx0qSzsx3DivGO972TR//4B666ZBM44PgCK4wj9DY8H3w3jWE6kRHHimjFHdsP/FW8/JsAbdMwuPu3d5FtaeORRx4h3dFGqOlkcx3sOXSYA3tOsHT5Es45bz179+4lHUtz/NgwC/oGqNUq/OZfvsldz+xkvFlDS7Vy0TkX8sY3vJXJE1Ns3bKHBWg8QJV5Yz6Z/HI+/oYP01Qh1Wur7J84wXf+8+t8+qs/Y+PZZ/OS87/HhNfKCycGCcefprd7MS/buI53vHMBP3l0im17PZ7dv4d4W5mzkwaGCzNGAUfMsGrjSxmZfor8igqZkTr//tMvsWjRezFji6jObGVs6o987bvfpu7EWHPRv1NzXGLt05yY+iO6PIaVTlGvNXGMJlXXA18iTUlL7gx6V+jsPFKlO9nKReuWcWbzMBdeOY9jQxZf/N1Ontr6GDKXYPFAH9+/9St8+9tfYuWK9SxcsJaWTI6BRV0s+MEi3vjG69l3aDcXXXIZg0MnyHb1EGDSdOqYhku91oiUG/BiHoRpWJiGJBQGQRCQTqcjWeHsNLpmks220Ww28XxBIp4lEc9SLBYpF2ZIt2Qw42Y09ArBcVykFuIHdXTdpFGzMTSXTDpLo+mj6yaua6PpMmre0bQoV1yFCF3D8xWmJvFV5CZUBPjKx3Yk6WSaznn9lEs10JIozWJwaJgJM6AtH6fUrJNPmNRsm1AIxqeq6EaMbFsnX/n3n5BJpkgNpGipjvK5O37CylXr+fTPbuXtvIVCbZb9O5/m0UfvZ3i4g+vf9FrKpVl6O0NSFngIBvq6KW67i+9+/n5CzacmNdLJFL4WEkuUmahVyPV47NoxjZAwsGgJf3pyC4lEmsX9/eSzvThehd/+9hYMbYKpiQJ+0ESFNQzRTqgahAKOHjvBq171epYvX8rg0SNUqkXiyRyBLzk6OoWeiJF0NbQ6tOodbD9+kKFjo1zT/TJSgUT4koJXJRFUaVRKmPEMa+ZnGByxaTZr7D24jXw2h1ON6K2ZUpXR8jHKk3uxEiG5jEFPbwzf9UiYSXo78pyY9pG9Nq+8dAW+H9B/5iYGt/4e4cSwzSKx0EARFV6YMQmY7No2QqU2y+DBYY4N2pSKTVIZ6OgSGGnItVr8y40/IpWKkeo8SVxYnLnmEvbs2IoQLoUZFzOmiMUEf/+O13L7d+4jq+V51StfysL+AdKByfa77qPUqFLH538x955hlpVl2va58lp77VRVu3J1VXV1dXUkdEuTJAehEZQgoyLoq6KCMmIYdcY86oyjzugYRkygtKKgIMkGyTl2N51zqqquHHde+Vnvj1Uw3/F9+vtj/6mj/lTcz73u576v67z2TY6hKipL2vt5efoYowcl7MYUV5x5BaesXkzF8bnzwXu4947foaVaEbHHyt4GauUUvqwTFw0yWZgIZXSgvaMHI7UcUT3En597kqcev4srr/sEF737Wlq6eviv79zGtFfiG9/ZSGOLyfvHv8bVl5/D2uUtWFmZ6ZGIf/rM9bz4+HYO7DvGutNOZLI8yPMvvMTPfvaLv1sv3xRFO45jFnW0s2TpKrqWrWC2XmO2lCzBCoVG1p69jliCsbFRKqUS7f3tNDfkaW8r8MgjD/PVL/8bX2lfzvBEnd6Bk7jifR/i+q9+kUf++ASXLesn7FvKxyIHe8kSHv7jg1zwvveQ5FJAjErKTiOLs4jCXp589gma+k9iYmIMIQmsTJ1N2zeSKXSxY4/Azrax+vSrOHtdkZmxW2nWY3ZtmuCVJ3IsPf0YJ57dh62voe7sIogEIpAZHN2LkhmDuE49KnHy2Vfx6qtPIGUbkUozpLMWTrWOX0k0w0o0Rk97mqGJCpJT5/CBg+za4mAuW84NH/0iH1p0J1MPj9P97AgnmB38dyVieddKXnltB4Ev47sqX/j0v2FaGoNHp2lsyFGq1jg8uJm3vvV83nn5lXz9m9+loambfGMjsgRWymB+dgKQ37DfqqqKoihUKpUEfaskC0LDVFAUGUnXcetVhJ0FQFN1fD/RX6fTacrlECFCJEnDMBSQNKrVOqZuECOIRZgYM6RkzpnMxtWkAxcCVdcT84maAPpVSUGSknGavHAjUBUlGePEYgGsrxKGAivbgGEZVN0itXKJxsYeHM/FbMxipUyGBodoaGqmo7OJVDbDf/34h0zFDu/5h4u57LLLkJC56qor2bLjVbbv3c3SgV6uvPJqvvKVn+K4U8yXymiGiqpniCQNVYa9B4dpK4DwInIdjQxNzmKn8jiej5VSqJQEptFIT6+xoMhIc9xxx7Fr116mpmZpau4jpdvUaoMgewRhgKrFiBBE7CAIACiXKnieRzprUy6XyeVyjIzOoyoGZspETdnMzc3QkilQLFY4dHgavU1mdGScasmnvbMFv65gxgZ1P2RmbIj9h4/y7LYDrFl9FmraYufzT1HxZgklmb58jm988tPIeCzuXoGqxFRLNWIixoaPcfigRHNnH5ViKSHnEfKdr38JEYPve2RVGV/y0CULZJkXnjnMvh3zvPDsYZYuXcqvbrubW375TTJZnf0HdhFFEV/95veoeyOcdvJ6UrbOzoOvsWf/BL+65R5UDebmqjS3NhOFDroeQywzV5xG0wLuvOV/aFRSvPzkSwwNDTI6N83esSG6ly9hxvdRlvXQ19bB4kIHmgVKQ5Y7fvJT9u7Yxcz0HH2FxZipHJqpMDE+Qs2Vaenop+bUSUkOcewhiYALzl/F9Z/+IKGs0bE05kP917Hm5H5Wr3kLTzy2j+de+TXjE0c4NpTnyJjD7MwI+/e+ys2f+mdkNeT++29n9+6jZAtpNNvhZ7/8LnaDRmdXDxddehZ/vOOuv1kv3xxFm5hj48fwwpj5uoOaSaNaMvm8ybioYWcUOhZ1sX84xjkUoKsSTr2MJln09i/m5l//hI/8nw9xUvMqyuNTPPriq/T+4S66u5ayJ+hgoLWVv776HC3VKq8O7yaS4R1vv4S/PPQoH/3IF3ny+Xupmy+yZLlFXBuhMTNPbVErgztdOhtWsm/zNnzRw7vWr+b5zU9wz20/ZbE5wBVrV9LR18uf7tvIWy+M6HvLnbiex6r29fxxLmTt8hY6ujeyzmxib9HlyJYy1GDLU/cjSyGiBr0tWYYny/zqbWlWNUms7GnCdpqYn5zingdrHH+iRS3vsNJyaWwLGbzvJ+Q7T6Pl7A+gDFikXAfv2R9y3yMP0JBuZHZ2mrVr17J/5yFyuTTpXIlcwWDJ8iWEoc7df3yW2ZkyTfnjUCWVwI1A93GqFRRJw/P9ZDmlGWhaArexrEzS7UrJcuh1hoKmaTi1IuPCp72zm6GhY2iqhmElUKi2jnYmjg1Sq1dIZdOYVgohBKX5CrqpEsdVBD5B4OF6CaMhihLLLwgkNU4Kl64ncrNIgkhBkiMMQyEGRBjhBQLdtHBcQWdHF4aeQQ1LzMweoRpP0JYz2XPkKCetWYudsZkeGuTdl13KouYOXt68jc9+/it89BOf5IVtr7Jp21427z2IJMu89uK93HjTp3jqmc089+ouHnn8FRzvCD/9yY9Zf/Gl/PmeO7Hz7ciSgS+mOFLKs+aE1czOvsLExCwpJUNHS4bBoYOEJYN8UwohamTSNvl8nmPDY6QzDfT199PY2sNMbZ5FnV3MHTGYnxNvgLUQIKTa6yo4inMV/MBhSd8i7r7nL/T0LSIOXDzPJZYEdtxIbOoM1Y9RckP+ev/DfO8HP2TL3s04xixH981TUGSsJV1UQx3ZXMzPbtuIlKtSqsBAaxejczXCSoRKyK13voiuT2AXCuzbtx0dA0WNyTRmmJpNUsOb+1pYtaKTI8Zuvv/b5/in687ka9+/ly9/6h3EkkV1coZHNr5EtR5w/SfexlvP8vngx0/DD+CGz65l6+5HSBW6aXFC5KiZs85byp13Pcd/3/JBXnlhM5mH38u/fOpUvvFvXyRtN+MHNSR89u3Zy8ixacYmD3DBuVdy9PAx/uOOh5F0A9UyiHINkGmk0DlAp2UixXDowH4GD7/GtvLj+GHAk20P0d7WxnHLVlFfVKdWKhLEZeq1AMWQaW1IUavtQTZUZis+yCCExsFKxGF5KQ/u9jljlc7E4DSHKnle+P2T/PmOO3lm/WNYLStoaG5idvwwSjTLqaf3sW9kjqztc/uv7uSO3f+DZZtU5o9x/jmnYRoZ9uwfZMnq00hieP+/rzdF0Y6iZC6WSpnk83m6ly5lujzLoo5eNj/7LDt37GFkbJITzjyZYrFIqVSiWq7Ss6yfrt5eTj5+DWnD4L77/8yl77yKueFBZiaLPPrwzzn9tLMYHR6ip6WTQ4f3Up2c5j++8nkefOwpRBSSWWTSv3I5Lz1yL0dO2Mcl7+qmsVkjGFrJpr+2kQozWJZOptnk6NhelvUvpmHdxZysWOz61oM8N7eH3VsDVnUexj1BJZ1pItWs42s287UKpd0FzGwnUX6WrkUnMHNoF63NLTT09eP6IFdKRFP7sEOFJmHhIjFRPETJjZmXBJFl0pPWIA3DroJpNbJn+34WqSFTT+5gRKhUgM5UM0eOHCHwIgaPbmXVsmUUWvPs3n+Uq/5hPbf+8nZQDNadeCa+H2JlTOLAIBB1JmfHEEGyJIlR8P0QCBdm3K9PkGXiOFyYZ0dvYDR1y8R3qmQyNg2NeeYnp4klyDXk0XUd07JwPZdQBCAl3WXohwRhPQlQDcX/wxkpU6s5RFGApilv6LeFSGD6YgFIJC3wjUUYEksqmqajygqBquA4CeDf7O5mPC4yObaH4uAk5518EhPTMzSaUFjch5bLE6gqrT2L2XpwP8++upl//K/vgKogeQncfrYyxWVXfIDGnEq2pcD6C88llzO5ZP0VNDU1EAmfk9adjKQYSLJE1jTxnUm8So18PksUhuhWmmy+mXJlnkAEaJrJ+Pg4MzOzTE7M0tIaEaKip3K0t7dTmitSKc6QtkzmPT9xriKjqIIwXKjbcYIn7l3cvbDM9IgjGdO0MEwVVRj4soYSxwS1GoeGj3BgzzCZWKGzo42MrnNkfIahyRquJ4gjiedfeJrpvY/ywc/9Ar+lhZpbRlEE37zlfn7yna8TazaykkLBRFM0Ci1p5iqzrDphDaEnc3jXTuTlq0jnG3niiT/x/uvO5YH7/8CXPn4Fn/7Sl+nuaOH5Zx7j+o/czJoTzyCXtXAdg5FjyU0hkPdy7Qeu5etf+je+/C8/QaeHpsYmbv35BtYcdwYbfv9fPPxEG80t3ezavpOWtjS1aoAkDDLpRhb3LGfPru20dzRRnJmipaOdrG5iqSmOjo4h6wbOVAlVVTnllHWETpVAj5kcnuDAvv1UiuXE4qPI6FYWqBNIMXJdwXcFqpYijgQGCW5WUh3KZZc1qwcozUyw6eUqbzt1JcV5j+JRjYob8oVf3cZAdyvt+SXU5ka49KJlqETse22CT33nW5x3wXrecdnV/OnuDcgRnHHy+TzyxNNcd93HuO2Pf5s7Am+Soi0rCi9v3kJP1wxPvrIFT0iU/YBD+/fgzsxw7rnnk8pneX7nNp5/+hnWrjyOlGHSPDhIS0cbkRfT27OY7//4Fv77R7dx7TXv54JzzqU4OU1HoYFcYwORBMKps+Q978WyLD732c9SvsHli1/6Gv2rViPL3cThP3L/HR3Yrc30rutnqv4S23ccoqvQQ4sSk1rdQFbR+L1IE/ReyZJffIFcewOvvv3tzAdbcOcVqpWIyalpQiVmpjJD4AHzdZTREmFpklVLjyOba2DRwFJqjs+jDz0EsWB0MCQfaPQpBnMjaQLVJqo7uEE76YYemu0mDr10gMWr+klftYh9c0WOf/un+eEnP03YmefoxCiNnW3IXpElA2tYuaKfa665hkcfe5bH/voUi3r7KbR2MzY5iyQktCDGd0tUq1UkPyQWAl+RQfgIkRhjdFVJnI9hmBRMRUVEAhFLiChGUXSQVPRYYc/OXbR3dTCvCEK3RHHaQWpqIddUQCrWcCoV5qpF7FwjmqZSq1Yh9ECSUQwTRdGoVOdw6lVSaTvhHksKkhBJ7FQ6t0CGA8erowQ2MRKOV8ckxrIztOWzjM3MIpGmUqqQbWohkzmBXVtf5tlNO1jZ38f2A0dZt3oJ7X3LeMu7L6FT1zjurWfy7ndcxQfefx2KphKFDgcP7Oba917FRz9sMDEzw/Yde5DFdpAirn73lbR3tC3oiuHIoSGyGZvmQganHlEo5HHcGiKCrs4W2lob2bbtNQLfZ3R4mtbWdnzfZ2DpSkQsMzwywdZXX+bKD36YlG0zNWjiR2VkWUVVdTyvQhSCsjC2ymWz/OvX/jNJFFc0KnN1VEOnXq/h+hJhXCYlN2EqNqqpUq3M4/mjlKsu6066kKkDzyLHGr5wUayPsWNwFx945xV89frncEtHmPDaeOLJjbzz4rfx75+9kcitoWkSfjFE1QVR7DNdnMPzA3ZvPUhjoZlL3/Ee/nTXreRyGvunhrj7t2ewbuXxPP70Jpb3r+LGj1/L3fdu4LY7/o0l/Y3k0wPYTYMcX1eYOKbT0noem17dSGu7wbe+/XF+8/sncZRD/OoXT1Gc/T0XvO10Htz4EMsWr2DpkgyOk0MYFXTdAFw0LcXQ9AHSaWhq6kIWCZMhAQcAACAASURBVKO65jp4NY/JwUH27t3xN6qPimmY1N36G0Q+RVHIZXLkLIO65IMsMT8/gyYp2E02jEEQ6LSmTX70g9v44Vc+SahGfO6bP2B6dJ7T3nIKbZ1pAm2OnQeL7Jt/mdgt8fPvPIRfm8eOZHr6F7Nj/1Z+8+tfcNON13PF+rN57tknaO9ZzY9uu5vhivV36+WbomhLkoSdSdHQ1MRJK0+gpbub7v6lbN+6lbs3/Jbz3nYRzW2trHzLiWzd8hp6GJNLZ7DzWdL5HDd9+Fru/P0GOrt7kGKZr3ztG3z1a9/AlCUe+stGbMtG0nTm0hlq9Qo/u+VXPL/pNSRZ5pwLLsPO55guj7Pp8DYW9XVwZHqWucE8Stcs1cImsl09hM4A7alGLEtnWnE4+/K3k6iMNSDg+xcvI93YgW51sGLtu7j3YY/+cDWhmyGf76ajBRrSWX77259gSToH9+5HxB6/+91vePalF2iqHaJxxSJG7ZizrvtnIhr4/PE2Y+0NTKtZyCmc/NRtzI2EfObmD1CtS+z76M2UynU+dOaFVPIFJr3kBpJvbCbfkGHFihUEQczE5DTLjz+ZuVKFppZWZqdniWUJy7KoVEtoikwY+sSyQiwEsqy9wU8W0f+mTkuSRBjGyLKyoKtN3I/oBr5bY3JqnEKhwMzkKFEYUKvM0NzSRy6nIiNwvAQdqsgCXVMJQhkUA1lWCUIPw1AolTy0QCWKQZE19IxJZWoKz/MwTYWYCElScd06sqJjWVmCIBmpSJJEGCSGnIN7ZzjrrasZ6FtOf087zzz9BPmWAtOuy9DMPEdGJ9lw113c+fs/cGz/Ie740130LFvJ0NHDnHP26bz//R9gbOQo6YyFosK5553BulNOoqmxkZmZMiMjIzj1Ovfd+wDT07Ocd/6FdLZ38bs7NmCaOnY60ZBv3LiRxsZGhBBkMjZtbRaVSp221g6Gh0fp7llMY2MjvUvXsahjEYcPHiDyI6QYMnYW16smYGc5GQXFEtSqDo2NBTRNY2x0lMCPUHUdy7aJIp9sNsdcqUqsKSi6xqUXnsvLTz3OwSOjKCLLyguu54VH/8xD+2d45Kn9rBo4hY0b7uLtl/0DG//6MP983lm0tacpTk0ROeVEfmsqEAsKLU2MjozQXmhFMVKMjFWoVT0e/Mu9iDhA0w023P5Lnn5yE5defAaXXPgWZPWtqLrCK6++yP69g/R2rmWqWmLXixup13zS2mJefF5w+tlLsPVOXtt0N6ef/y7e+4Ez+T8ffBcHd0/zl4d/xNq1J/Lkkxv53Gc+z7Y9h5AkHU03EjehFLNq5QqkWCAJgevUGBo5RuQHpFIZWpqbaCucTyqTxrZtTE3n4MH9NLe1MzIywth4ktVSrVYxUxa1Wm3BTyARxYJU2sYpVRfOAYgoIvQDorFBfnHLj5k6tJ3TVq1k07ZjRIGgrbOX8vg0y7qW8MKLz3J0z3Zu+sA7qZbGSasmh4YOsXvkCLIUoCoBr776EoWGVnbvO8j23fvZfKT69+vl/+aW/f/3yuWz8arjlnPxRevRUzka29pQdYs4jHhs48Nc/a53o5gqmm1RrVSozMyzfKCf1o52gijkhWeeYsWSJXR1ddHV0cnuvbvo7uqhIZ1m57Zt5BsayBUaEb5HvrWF3/zmdj704etZ0PMjqSpKZHHKhafSsLiZvlVrKc11cuetP0eShzlrzWIa9XaOTu8jDH0O7jhMV34RQSwhzJhQBHiVmEjUUf2I8dI0ViaV6I6jOmEocOsJX6G1NU9MQNUNOOGEU3jp+eeQAdWw8T2XpoxJWHUwrDRRNocXQldvM37RZWhoH6ovKKQa0LtbOP20ixidnsayY2LXxatWacwrKKpER0cbN3zsJpYvO511J5/J8OgsdjZDHIFtpZmdmybyPcLAJwocNNOg7IZJtl6svME7liSFOBLI6oIVXAJFSizorzODQeB7VXynRsq2aMg1MjpyCIgxrUZSdhY71cDsfJkw9omFQ+CWIdaw0gUKbX24XsDc/LHERSZiBDI9vf14jsd8qUilXKanpz+xUdc9DDuDopqgmgnqwLCwUzlSuSaUWLDpledpalCZHXmGsDaDospEYYiaLhDWZpHikO72VtIpk0PD40imiUAj8gMIXHLZDKou4Qd1dF0hl7dZs2YNEhqzcyVmp+fQNOMNXXksJQEcpflyMtqRIyRJcMKJq1ixYjm/vu13SJJEEAgmxucSA5Kdo+54lEo12nt6+NCN/8jE+CgPbvhvZDlFuRIhKVD3isRxuGAPV2jv6ECImGw2y8ED+wFQNZ0w8JE0Gc3QMTNNKLKOkba4+Pyz2LF9F8JoYejQNOvOXMemPSP86Lk7OFaM+dKpbyfjBsR5cA8/zvf+cDcP/vFPHD1whJyiceDALmqOg6JKmLaJCP0kkSiUaWpewtz8BJoU4ftVmpsKzPshTz36EA9tfAEFh29/66t09/RxwprjOees9Tzwl7sYHt2BbaXJ2l3s3LqH5pY8V/7DOXz7W/9DZ/sAXSubuPTSi3nhmWfxHIeD+4Zx3CJf/sJH2L3ZoRKN89zzL5PJN1Or1ZKHoqVTnp/h1JNPoVoNmStXyGXTOPWAlG3SVGhBURTq9Trbt28nCkKKtQUGfyr1BgcbWSL0A3KZHEEQEMUQxSFpM0W6weDAvoPUqzUmSyG9Axfx5R/8K/NDe3jkwY1Mzs7x4Q9/mPrYEPtmpomKNU5ctJh6WGb44CZkA2bnZ9i++yjXXn8DTYUsubSGFFQ4enQIM9/HvX99mpMveh8P/PiftsRxfNL/u16+KYp2NpeOTzt9LW2tHdi5PIZlJfbimRmeeeJJYiFTDzzaWjsoFoscOrAPEicosppc1V9P7pEiiF/H+b5xkQjpX9pLQ2OBubk52tpaaO/qpKmpiTAA21SwqODJBhOTVcZmRqiXxtGiHE2NzZTrDumsRF2W8YMIpzQNcoQaa0iRzL7RCdoae/D8mBWrl+EUp8lYeUwTRGhhmlB35nDDeWRDQZd1NEUnmyugqFXSqQz1qiBrZzEiqEgSpXCG5lw7uVSeJquR6eIM2waHyNQUlHqAG/soBEx5RVqWrEKVqyBFdLW2Mzc3hyxraFqaX99+H6Zhk8rmiCVBFAjqVYdIeNTrNSRZQ0QBLKB7VFVBIlGNRFGEEMnOQZIkxAIX+XVeSLI4jJA1FV1KLMKl+QmQIyzLxPM8ROgAOq2tfYhYp1ibI/SKEFaQzRZy+S6MVDNe6FAvD+E5PoZuo5smqpZB13V000h+J0nFtjMEfoyda0AgIak2mmERI2EYNkLL0NvVya4dW5mdHuTiC5chvBKaoVGcHSeVzVGeGaGvpwfCKl7VpVjzcUSU4DllBUkkhzaJbasRRz5h4LBiVR+uK5idm0kMMQtxgSIOF2z5Mojk4aZqMX5QpbOrhZUrV3LL/2xgYGCA+fkiTj152MmSAZKCYSW3xh///Nf869e/yv6XHqGjs489e4+CFOH4JSRFgABZMWloaEBVNSzLwnWqjI+PwkL8rKxKCAFaqgE71Yilx5x03hrm5oq8smmEsBjz+N6nObazyJ+2P8+F77qML5z2fqJwinfd/H7+/NMNZNM1WrMZpqammJmZRFUUwigJsFVUOeFOo+B7AZl0lmq9zP0P/BLDNMlZ7YxNBDz26KOMjg/xzLNPcd55q3j0ry/w/e//kP6+47jynTdRdo8Qxy6qbPOL277BddddR7U6xT9+4Uy++NWP8O9fuo+De2DbtgNcfvUpPPbQLmIh2Ll5E7f+8lY2vfYKYxPTzCx0v5qh05AyWbVsKVs2byWTbUZZYMpk0nnqToV9+/YwMzOz0IzEmJZOGCpkM5k35K1iIfJOURQq5Sq5XA4hoOJUkIIIu9FkdnqOmYlxioHKyeddz/LjV3P3r77E7b+7h8mRIxTR2bFpB5dffDGbn9vE7PQ4xckxrr3mHdQlH0lXecvakwhdCaEZvPbaZjSpTHdnG6NjU+QaWxmbcfnuv37qbxbtN8V4JAYGBwd54YUX0HQTVTeTENFMirNPO42XXtyEE3hsHhomFqCpCpouY9s2s/NFstkUmmoQqzJ5O8PI2DiqrCBilbVr15LJpDCMmJb2bhy3hmnqjI+P4fseWkqnWIpJBzrlYBYvdFACFVttQ7MCau4kekqiXAZkG6HqNHcuJhIOlVKdQJU4e/GlSXLOZJWZWQfhBbS1S3QvaqE0H2KndCJHR7EWI8wIJRYogUXKyqJZESMzcxgdOmEcI5VVzLkY20ozOjPLUXcYlAacUoWXDmwnV8qQr1eI5YC8rlHXA/bP1ZDFPLXyLG7JIwgCensGqFQ8dN1Et1Louo7j1/D9IElXjwWKplJ3ArJpm1q1TCptJ4YHN3ijUMex9MabWdXURIKnJJ14GIaJ9TkM0VQVz/UXFmUCO5NKknNIsvUcx8G0dHRVQ5E0/JqEomjIsvpGKremafiuh1urIasqSIlhxzRNWltbmZyYTr6fHKBoMkQSuXweL4io1R0kScP1qtRrLoqsIpCoegIplBibGyObNhibHsOSYoI4wFAU3LqDW3aJzARSFYYhqqwhKTKqpiOrMZpkE4UGmqah6RqRCJn25zAMHd8LkRWNVEonDEMcx0u+hpYAsBKWNHhexOxs8uApFot0d/cyMT6Nqlm0d/awes0JPPbYY5RKJWZmZ6k6AlXScHz/f8/JAqL29QdnEAQoirIwvooxDBPXc5E1jaBWo+hJNHQ20VTIk2/IYejdrHvrldz+kztZ/67rePhrN/DQhieQxStc/vFvocxXMFuamTu0jV7zFLJ2llptHtcJkKQIRdIJwyghNsYRhqFRqRZBFjQ1pHjq+WcJKyaf/tx3eenVlzmj60zOOu1UPv+Vz5BJp/joR24ASWL/gW3sPbiVzS/OcMnlq1m5qp3/+v5/cO6Z7+KMs07lf37238jxEkIvwvNg/95hgqjKFz7zLYYHZ/jEzR/i3PPupVSsEMqJuUgQk8vlqJRrhGHyHq7VZ2loaMDxXKq1GuvWnU0+n8fzHKyUgQgj/NBFURQefughNE3D87w36JSZdBbHcajXXZpbCygxtPe24LuJicu2beYmJnhx8hhvWfwA4+VdICQ+9s0f8Npzj9O9qJOqX2Lo6EHylsnk5DTFoIydzvHOS9cDaWSzEV1X8eqTXHrR+Zxz+lsY6F7EHb/53t+tl2+Koo0is3xZP0s629ALNmW3Rn97N4Hj0trcgWmdztDwMGdecDaKgL7ORfQv7kexLKJYMDE5jeM4uG5IpVbn/vs2opsW9ZpHHMdMzs0wsKwHEYekrRSaplFoaCKWJQxDZ36mSGCb4IWIMETXIoQTJykisoUbR3hSFadUxTZzjE4Ok8maVEolTCNDOZhDUitIQiJvGjiKx9HhI2zbsT2RDSkaVtpG0mLkdDIfzqmNZFIZJBGj2wbhpErgC1LpBpozKWQlT6gKVLuJ1lQTamuNruOWJRFIgYeelcjMTRNXXVypiZRVwzQ1DK0ZEcn8+d5HiaijKjKqHFMrJfS/eq2G67qk8w2oik4chzhuonKoVMoYhkE6nU64EwKIEjqeomhEC91ItJBKo6gKuq6jxTGEMbKmkjVb8Nwas9Nz2LaNq8hEQUSlMo4f1ND0DK7nI2LIpGzslEnN85FlmUoU09bbz9ihQerzZQqL8mimxNjoMKgKfhDgODVq1QAUkyCIKJYcJEWlo6ublJ1leHSO6dkp+pYOMDk5hK4ZZPIWRkYlDiNSuoxtqqSsNLYGoCKlHFTdYL7s4Dol0g0Wvheg6TqqkiIKqqiWgmKYxH6I53kLhz9A15PkERF7KIGCqSfvSYRD5GsU5yqkjDymqaEqOmHss3zlMkaGx2loTDNbKlN2PW7/xQbWX3M5F15wKvue20hrU4GZkkPo15IzshAqgCTheR6ZtIWIwE6naGouUK0WF3TqEiIIILYgrHF0sI57z8MsXraMYtXkP//j2yxpU3nfNVeTbljH4gaHQ2EPT937G6j4tHX1Mi7a2HX4NVBtvChcaOIVwoUU8eSGEROFIRKCtKkwOzlBUCrx4AP3Y9nthEGFZSvfyl1/2MB7rr6aO++6l2XLcnz+a9/ijNOy3PvYvfz59gN87qv7IAXf/pdPouQivvi15/n49dez/ej9DKw4hX17a2zbMspHbriKf/zEJ2gsZFh7Ugt5u4t9+wYJpICJyTFEDB2FAj29S7nvkUeJGcFM5zhwaB+xUMnkc+zYsRtVlZGVCNd1yaWbE1rhggM38j1MVUKKFHQ7uzC3dpARhJGEJ/lMzs5QiRxkU+XY6ATUy5yw/kL2b3mB1o7T6exfQSZTACvDscH9eF7Ax2/+DPfcdyvPbH6OXDZLd/8qfn/nRqaGHf7lq1/GUHTOuPBU3veBaxg+sINHHn6UZQN9bNry9N8sl2+Koh1JEnYqjWGlCPIKbbkOlBmHrpYujs5MUaxMkW+0mJ0YJPB9iuPDHNy/m3ItIIgE5WqFUrlKGIIXhNRdn2K5lCSnBIlNevfu3ShCwneSWCbN0BFxjBP6mIqBFMu4vpOk3QC2ZROTJFjHanI4rLyGJmvkM51IUkxrSxfFepn2tkYULUMcRXgiIisyNDTlUVWV3s7FIGLcyKMa1HFkD81QUQIZXdLIKwpRGGLEKWLdZFqJaAw1dFlmNKxSjwIUN8KXNUzXw/E9LMdDqQgiWVDzA6rlSTzbp+Y7LOrMMTY6RT0QKIaBIkmk0ymmp2eJFyDsYSwol0pYqTSmmaJarS50xTFOtfbGzDqKIuIoCWCVFRU3qGOa+hudnqIoRGFMvBALlnSVKjEKcSRRr3uYpobnR0Sxg+sEb/BFJHSECAl8hyBQQdMQjkS54qJkMxBHzIwfg9BFzzdSaGqjrobIkkxrS4EQOYFU6TY1x2VsbAwrVWKgbzWHhgdp7mgjVhLru6aoSEIkqdiyip3O0lhoYmpsGM/3EbKCL2IsO0UUC0zTfMOuHwTOwgI0GT04tTrEAVEkSPIfkhmpbiSLOj8MMAwDVdEQgUFLew5Z8vC8gHLFwfMdAk9GV1KYpkVXLsfBo8NgZGlrb8bzKpgZmXpQRbUM5GrMwo19IaoqfuPvrKo6QeAzPz/PcauX0dnZxeRkkbpTJZtuxc7kaci3oeousgr3PfAwJ6w6jr0HZ7jpxk9gGiPMzYQ4o4NYTb34mg6qwDVkBCa93d0MDw8S+i66ZoCI8ePgDf24Kitoqk697tHZPsDKa07ljLeeSy7fzx1//B3vuHINinGEmz/xE2JCDh6q8JH338wzz97OjVd/mB99+wparA5ma1PseHofKwa28ru7XuSqSz7I4rYuZmaP8M4rLmdmapq+znPZsXs/ze1NnHrKxWzbvIULLzwdK9NJS0sLff2LaczlqFXrZLUcSiqkVK6wdNFqolBByCE1XUI3IqK4SiZKITydUDioig4iORsSErLqEwQRpqWDKtFcaOfYsXHMVIGZsTL4Pg8+/TT5RScCGexcHjkUdC1fzQmrV+PLCm3r1nLOWSezc/chnt/2GmvXvY2xkd3UarM0FWy2bH6WU9adTFOhzNT0GI2ZbnZtfZyqbCO3NjH7etj133i9KYp2KpaRM4nNOFMXGJbKtAm+7pNOpxidi8g3FqiUHHK5HHrKoqmjjWXN7aTtRD3geC5jEzMEvkDVjKQbECEhIY7jICLQFImskUZEEaVqDWQZT5IhCjFERBgKwmjhUBgKnucgayqSrOOHyUY/Fj5SpCRp4sKjUe9GBD4KJrIUkTZNynUHN5JRUBg8NoVKTE4kcUyaJhHLIUHkI2QYs2w8FXKBj1rzMDUoBwtztTAkJ8tIQYSuatSkGE2WUFIKoRDEnoJkp2lQIoJApre3l5df2cLRwRFqVVBVnc7mZkrzJeZmkpRxM2Vh6QZhKCjNjJNpKJC2bcJQI4pUZFulUqlgGImqQyCIIwgjH8PQ8AMXXTMRQiEKQqJowZmoqqhqEpelWymEBIFXp16tJCnjQTJzdZ15EAJV0SjOlShXQ8x0AUPX6Ohqx63XiCKfwHORZUG2UMANYqan5jFNm1j46LJLpBgoqka9WsW0bOx0FjfwGT12jPbWNnKFPNl8hra2FhRRJZYSgE9OzZDP2uRSaZxMBsuykGuJa9NxPZqbC2gqBJ6P67oYtonvlvEDF6dWRYhoAScqEQQRsiKTsk0UOU5cmrKErEhIIiKdMinkWpBiNYkUiwUt7S2MDk3S2bKYI4d3k21I09G6nE9/+ivc9cfvc9zSdpTYIAgiYtNExDKKJCfBAkQggeNWWFpYTq3m0NzSzuDgQbZv282O7XsX0nAEcbwXJIGZyeLWy1x62SXUi+P0dJ/Ftm1DZBSFw/M6cTjF0uVrOHjgJc694Gp27DpKZ5OOMwbvOOdCxqZGeOAvD+AGDkiQskyECHE9nyiU8QIBErznuhtRJMGpp63gfe/9GGFlhvPPOZvBsUMcPlIDOeDeP9/P8L49tHQfR1/3cWy49Wf8/Jtf4tUf/pxFSxYjLzsd3exl1cpzqIshBgZW0dhkMz17lLvu/R5/+IOPV5pFiUOGR2coBBrV4SninRIvvKiz/pJL6O1dwsAJq1i1Js03v/FDhoYPc/nbb6S1pUB1rIBuNFAsz2BaMYGYJRYZIqBWLy3E4Gn4YUTKSlPxAmrVgPnyKH39ixgYOJWHNt6OhKAeJ8hVJRplZO9+gukJcobP8NBRvnfTDQh3hk1/fYRscy+7Nr9MvGIZe/fvRJZCbrrpJh568CHSDVkuuOAC0qbB/ffcjV+PWL5qLT09Pbzywua/Wy/fFEVbFoKGQhPNdhcT2/ehYZAu6ESyIJ0ykWQLz49Z0tOPLMu4Xh0rlaXuOMzOzSEE1BwX1w3x/BBVSYq2F3rICkRhTChiamHArFtcSEkxCWOBUDU06XVUqEDRdWzTZK5cQlITuL0iyeimju/4RCKJ11IUCV2ziFHIN+XImCmmpqaIBGiqiaIpCCRk3ULTFOJQQpYEGkGSyKKbyVXNNNFFhOVE6LJETfKZ12IiCVQhMMKIjGbhK4IYFTNWUVAQQsONQqKwTjplkpIymEaWY8OjaIqK51ZI5W0cx2N+Lhl7QMIuj0Vi/5ZVmUp5nqaCjm1ZVGoC3w9QVR3X9bFtDeSY0PcwNZMoilFkbWGurSHk/824SzrA5PocRCGqljwEhFDwAx9iCVmCMHQSFYSqks6kcPwk4smplJgbHkVRJKI4WYymUnlEIEDWsG2bMJDQdZMoTn6OBCtqIZDwoxDTtJgv1bECj7mpKdpaC/heHTmsIAgIggg3hGLo4DtVdFVbYH0rSCjIKYNUKoWIPCJDo721mbn5aZq6WnDdGh2dLXi1KoVCBc8NMAwrmZ96HrKcdPFCJCMMEdbw6hWWDPSSSTegqlIyTrOSIzc+Ps6ijk7c0GPsyEF+v2ED9do0nWecgCaZhLFGc1ML1eI8Xq2OxIJ9X5WIQsHk1Dj1movrldANjdBP/vaNjY0UizO0tLRSrbmYZnrBcRpiGGm2vrgd3TaoOCVMTUe1fA7u2g6qz+x8me4l3Rx46hWOy61ky2PPUXHLLG5sJdPSgKwqyIaEaqj4QdLceFFILFyuveZali7tAuFzwQXrOffcczlu+UrWrl7FPXfdwlXvvoEr3nEVvxUBo/umOHj0SfoaO3hu3zGOfva97C3Psep7G1huNDIxvIeG7jbGJ0Zoawt55xXncf/dgqljx1i9qpfTTx/gpS07eenlLSSmqyQYxnNj5Fhiz+4d/OeP3s+2nY+zdedOZqZHmZkeT3T9QY5qtYhUhVgIJCX5yIKSLHQdJAkqFYc4jrnoovXceMNNvPPyS5L/WxGmiwFKtk5nLkssNVKrVQjw6O7u4vjVp/Glf7mZ1558ms62TjKSoKEhx9ZNm3HDErahcWx0mH37d/Dnm3cxdGyIml+npyED0/PkbBsR+mSz2b9bL98U6pG2tub4yuuupOYHaJJMRtXo7++n7s4yNzrMzkNzpLNZWttzTE9O0WjnWLZ8AEWDWBJIikEUw9xsBRFBGMQoukalWkLVtAX5mkIYgKIkn4uApAipBsQhIvYQxIjYJ45CUnbDQsFO0I9eBIHvErgBqpIsIUQko6V0hocH+dPtt/HxT38BFHmBThYhAC8IUFUFo2AjAp+ckNEkBS8IkGSZtKaihxGHVY9AlViRbaKhkCNyfQxJRTIMthw7hqjXsesBkp5s8A1fxiUgDJOlYUtLP3+68x6mZ6q4rotp2siyjFP38DyPKPDwPYeUYSTqD1WhVK6gqDLIMqZpoyopVE2nVq3gui6KEqObGo5bhljCNNMYhkW1Wk7UD7KKLCXjkkgEhKGfKErixOUowgDfqRKHNWQpSoh+iiCOZCBDcmIkWjr6Ma00E8e2Evj+AndYRbUaUTQdoWjouommpgi9GN3Ko2gqZsomli1iScEwLTTFpBwIjl9zPA/f+QfWnrIKXZ7ALY0j5AB0jdLYMPVykSAIaGjKAxAuuDJFxBvqATuV4vDhwwTugl5Whta2DHIco+k6+XwDURSjawnI37DTDA8OMjEyDZJET3c7rW1N9PV24vsRD/7lSYLkScyi1iXUawGeXyaTyzCwYg09i5azdfP9rFjcxY7XhnCEwI0tJsaHkSUHEftJLJWSaIQXLeqjubkFz3PZs2dXkhQjAbGCqskgkv9/JtdIrV5EU2Iq5Xlyja2UqgotHVnmJqaIvHlEFPKV797Cj7/9S+SC4D8/93X27tzLK1tfYXZuDMs2OTZyhIydJmUoFAqNKJKOiCV03aBe8/na1z9NNpPnc5/9KFOjUyxZOcDQ4QlOPfU4zHQdP6ry2Zu/jlPx2HD/88zMTnHwqY1cUOjl+lOX09W9iI2vHeaD9zxF38AJTIdzCKFzx4ZfMz50kObCHPuP7OXlh/bR0pbjy9/9D2aKZSrVFMVSvtJSfQAAIABJREFUmWxTA7YpoUsKqiIQvkLattAMHcuKQBhs3b2F73z337nx49dz5mnnIJMYWCSSMGFJkpL8SkkQIeNFUHIiAiFTqQakUjp1AW4VUoUi3ak8zfJZZLoipiYPYCo+drqJelBD1kyWLe4npRnsPDCCWytyzvknctJxK1i8YoDJ4UkO//YB9o8cxg8Dzl6/ns379pPr7eL4dSfz6z/dy8je197E6hFZplAoYJQdpl2HyPNJzVXRoxgasyiGxzOPPcFnPv853DrMlecJJQkNGUXVKFUjMhmbKKyQy2WZmq6hRJCy0kiSgusFCEA3dUQYEAJGysT3HKYnJmltbcZzQ9Jpm3S6OUmhlkGLY+Zn5zDSWUrVMks6Ovnlrb/gLaecytJ8C0QulYpHR2sXmXwbnUsGOHLoMEYcoKUNIk8g4oCuRd3M+bO4NZ9y3afJTFPDJ29lGHXLFFQLK4AuI8fhA3sZf3gMz6vx0qbNVEolbvnt71HcCrlUnloQsGfvVrRsntJ0CcOwiOKQV17ZxIGDI+hyMqpIGTq1moPnOKTTacYm6okkToaaUyNjmVgZE99xkURIFEhk8jkkoVGJwTAtPL+O67rouo4EuLUy6gK53vMCdFUGLcT3QkxLRZIUAgSKqhCIAGIBsoysWIioioQCC7NwFIEIDWLFpzxfRFU0Ar9CcoQMVN1E1TVELKOhJyaHQCTAeDkiiqTECGHraIaObWeo1mtoVgZTykDpCM50Ay19KRSrGcWUaWpu5ddPPQ5SyLJVyznr7LOJZQldVhZSYxQQSRPzetbl4f37aGrJ8e5/uJK21gJuEFCaL1KtVtF1jSgSSSK7ZfGY6zE9VSQMAt793sspF6fo6uikZ3EvD/zlMeIYcnaWsfFxujsWU3c9IuER+DH5XAv7d+/lFz/6ATde80l8VUOSDFTDJvKSTluRBSKOkSWZ4tw8uXQztZoDUph0ijGomoxiCJQ4QFFisrZL3atiN+SpVAVe4NLS3Etlvk4610RxyuXbP93AU489TSanMjKyhaYVfRSHBwnyFlPTLpkI8u0tRKHPfM1jZniIgmyi2Taen4Q0n7/+MgCWtrWzevVaNm99hf/L3JtH2VHW67+ft6Zde949T+lOZ+4MJCEJCUgIEOZJkEkRRUARRVBE9BzxeBAZRGQ4KKIIiAoyBZA5BMIMGck8T51Oep73vHeN7/2jGo7rXj3e9Vv3rnVqrV6rd3V1rdVdVd963/f7PJ/H8zweeuwxvnbZmezcs5pSrsSBzm52r13FjHlH0HT+V1n38fOsemU7Z55+GlNOXIK2/G127NzClLnHcqDjLeYtaMVcMJVnn3uK8U0nkJ/l0tO/MxhUKCaqrtHa2orlWPiyTNFzietJfN2iPz+Kn1HxPRV8QTzRyqOPPIfr2qzfuo+KSpOy5ZHPFwkZkTFsgxoocpQIviqJJ8MIoRJLavQOjJIre8QiMUJCpQyU8FCsNMK2sEQ+4MLrMWZOnIQqFFQ9yuTx4xjqg/xohvWfbEUjQmNLM/0XHEtidxWDPX08v3UV06fP5Jhjj2doaJjzTzqFX+/a+A/r5b8s2kKIPwJnAwNSyllj+34GXAUMjh12k5Ty9bGf/Rj4OkHG0HellCv+ZdXWNEwjSd4tUBMVNFVXcPDjdbz7zkrGf/l0GhL1TF00m7PPv5A1a1bx3gfvMjqUI9ncSEm6JBJR+vt7yaSLIA1M3cBXNDy/hCZ0dFWg+BLXlfgINEVgWSWQPoc6drJ7V4nhoVEymSB1ZXBwkG9+5xrMWBQjFsXK50ipKrHKFNVNDWQHhjHnhgmlwiSKDvf98nZy2QKrPviAKZNbwYNJzfVs37GDQilH3wGLGeOrOeH0U6mprKMoXW7+64PU11WitRfYsXUdXZ1DuJ7A6e7m9rO+Qmf7YY464wJ+//LTXPu1q/CcAolULfnMANde/xPK2RHQdLKjRWrrq3nxb89Q39BIX08PEdNA4uH5ULBchG7Q0FTP0PAo+aJNPJoiPZohHDPQdZ1yqYDrugz195JMVZFIJMhm84TN2JhcL42qaai6SaFsIRRtzEASWNxDoRC2XUIIiaZqMGbKQYxFUgn4NNFUykD3rWgExcZ30HWLUqEPCWiqjmpEEYqO4wbMbDNsomk60lfxZLC6pBkamhFBCoHjBYqOqJmi4EHBKaDioGoec4+YjG/lKLseTc0tqKokHKngkosuZSQ3TEVlEqdYHiMHgo8kk84S0gUaHsggtScaDeOUSxzu7ELXdTRNDeSjoQi9vd3U19ej62OpK0AuPYrrulilIuvXraWmppLe/jSeJ4nHInQc7iAcl/iKZNuuPWzffAjXh76uw9RPqGP/hu2Eaxqoqo7T3z0QNIZ9iRQQiYRxPY1URXWgT9crscojCAS+6+DZoFLEF5JcRoCox80Z1CVa0I0obdMaiMTDaGaI6toqega7ufa7N1Jf4VFZ0cAnm/pYcuRJXHHmKWgxA1XR0KWHGVKJhkxcAoa5qigkoykUk4DAqMDlX76a637wY+6693Z2bfqQb1x1LW+t3ELngMfA4c185bofcv+d93HCSaewfvUzWE6B+pZa0sMFrv7xbfSODKPGIxzs38TU6cehYfDcy2uobBrHuGqVnevjvPjiTm57MMloz3DQSC9lUXQlCJkWKunsaNDwHpuZIEpYVolcuUDfzu3MmjEHWxY5tHeQinHVpKpSfEq3RCpoioIrwZUShAOqR8lxqauvIO7Y5LMFXD/wNaCoFAo5wCViakyePIvDPf1s3rKeeQsXYXkujueQzvYQHoa5c45gX/s+BkZG2HpwD4cPd7B48WJu/tKllAolEpEIK1Ys59e/veefl8t/WVDhT8ADwF/+b/vvk1Le/fc7hBAzgC8BM4FGYKUQYqqUY1qhf7IpQqWIQAkbVEuflAUr161jyrxZhKprkSMaCirxUIIFi5dwYF87RVnGVRRyI1kkGq2T2/jipUtQFIU/PPQYkUgUIxoiFo5QLlqEhAj+wX4ZVQg0TaF5XCMP3X8P5ZIFBBFXX//6lTz66CNMnToVUwmSu5PTYmSzWUaHBhkeGcKsVxkZ6qWpupG849A0ZQoPPf4kazeuY80H71IRT/DEk28xsXUCf370URTfo2wNYI8W2LFpB3XNzTRUVPCHX99PvmOQzGgJqYRoXDSLhnCM440WUksWcOJDP4RkFN1K4ws49Yzzef6ph1mzYRu97XsIJRLYrkWqMkRDYxOaahKOhEjEopQLaRTNQBGSQiFHVW0D46IpDu4/QCaTIxQLshalCAJ+fd/Hs8qkR4dpbJyErocYGhpCVQXhMZMCY0ySYi6HCIXGbp//NiR4nocnPVSp/3d8lKKgSAVfqCDdT++TQP7m+Ujfw/dKWK5EoCJ9gecGxUwxFAwzDIggOEFXEL4yxuAIZhSoIcrW32mZfYEaMvCQ6LEwvl3Gd4NlGV3z8TyPQiFHLp+htqaKfD6HoSu4toNhGkghCJkaqqqTTMWCk/oe2WwGP6zTNK6BwcFBhob7Ap/ASD+JRIpsNkM4EigspITBkVEipkJNTQ09/X3Ytk3EDJPP54mHVXRVJxQRSA1Ge0dJVtXjC4GqR5je2sDy1R/i5ePEIuanfxgCUBQoFQpMGj+LieNn8MTHD+JTIlVRxdz5c3nzjTdwbQuhaki/hK6baDI4h6OB8D00RQTRcWMvUk36uLaCr0M+6zJryngU6eALHfIS6fnkij6er1EqlMh7JexkBEXodIx6+LZB59A2xlXU8Jdn/sAfn3qIPz3+MC1N1Rzq76N3sIimqrz71gece/LFLD35LC7/6vn88U+/Y8uGtVzxte+wf8sunnn0eYi6xKpqaapuYHLbdH798BOccdYlfOtrF3PyyUs5+9QzGDelEuEYTGqcxKH+EWqqKkkXMmghFacczMY838ZxXDypoipRwuFKyOuks6NUmlMJR2yu/bfv8v3v/4DR0Uxw/9qBi9VTVYTQUJFIP8hTj4Qi2I5keHCEsG4CEtf10ENJHCtPSA9mnz3dHUyeMh0pFDQ9jl1W6e4cApmkWCzS1z/C6lXvEg5Vk9I1evceYNmudl5f9jey2Sy/fuBhXEcQiyXI50b/Yb38l0VbSvmBEKL1Xx03tp0LPC2ltICDQoj9wEJg9f/0S5oDnqajV0R5//6HSToaEz83m0kL5nHjzXczcUorejhKc0MNt9/1S846/yL27drFujXvke7pIe0UOCUeZ/Mn64nGK3j37fcolPKUrCKtLROIhmP0dhzGKucpmi4mKq0Tx5NMxhnf3MLevfsDSzuCmoYGahubePbxJ6msr8dUg6ZNNBGntW0yb772JqlUiu7hPla9+TZSV9m9eT2r1n7EuOZG5s6ZieZY1ITmc+vNP2XLplVUNFUwUhphfHMLP7z3p5RHbA60H6YhmeJMP8ZNV36VX7z+Mc+v3kzprPlMefh60h7MuXIppXV7qOryGAZeeu1pwGPO7HlccO4F6EmVxvoGvnT+WUxsnY9V9ggbIYYGBzF1DaeYx5UKoNDb20vITDBt9mxcu8j+/ftRVRcpJCghpG+jqEW8siQ9Okw0lsAwNEqlItGoTqFQQFEUIpHIWKNN4gmPiGlQLJaIxSLkixmEGpABBWPyNCnwpAKKjiLlGENbYpcKY80fn2JhdMyPGSyHSDdQ72hGsP6uGBJNCmzXBqFjhkJkMmXCUdA1HSwbz/PQIlAaLRMK6YBHQ0MtuZFBBBaWlHT7h/mUVrhu3SqmTm+jtbUV4Tk4dpnh0SEURcMMxcjn86iqSjxuUFNTQX/vIJt7uylZNqlkJbZTRlHSDAwMUFdXh+crDA2NMHnqJHq6utm6ZQeKAtu37cXxHSqrqhhNF4jGI2RHSyRTKQZHBpC+SyjeyJxZR9G+N0+xXOIH132P1z5ezbBjMjw8RGD/HSuyXvCCNCMmC4+exwO/7yUei+P5kq1bNrBp9RqQBlnPwpAVZIfThGPRINkHD+HraHqUWEWUtlnjKFkO2Qw0tyiEJehCYccAWKqO9EGmBJoByVod34JiKEKMCGQ8PFXFcbPk870YqsILb73JzFkLWXrqVSiKQqqxmVhlI8te/ZDujgHyRYtbf3Un0vcolEe4+rqz+cb3fszKLSs5bfEXiKYixPuzOANlUi1xnnvqMQZ7vshDD6wgXxjhg5u+y8pjT+Lr3/gKN93yPYYGcjz80JOAwsBABj2koIXGko58HVda6IqHUDLYrku8JkpVcwRbdpIvFvG8BI7n4tl59LHel6IoaEJF+gqKUJC2ix7ScEp2QDlUDEKhKK6bxoiquH4PQgnj2CUamlO4VpjO7i4EJn1dO2iZ2MaRC45koK+P+QsmU7Yslp5+JrFwinV79jOzsZ5ELEoiEubggXZWLH+ZzkOHKeT//5H8XSuEuAz4BPiBlHIUaALW/N0xXWP7/h+bEOKbwDcB4okE04wKdn2yg1AY5p11NPEZ83h9xSoifpjkQA+bR21uuPFq/uOH/4b3gx9R1lUO7NrBplVrWXTyHNpmjCMSbsLQK5m/ZCFFr8TsWTPYvWU3I0Npvnj5pbjDfdTPnoxu+7y+fAWb1m1koKeXsG5guxCNxSnmC+RzWY45/hgqtShR1aBYYaLUJGguevQc3sVobSsFe4AVzzyH5+nc+8CTdCtlNvc8zeHBTipyE6jIDJEZ6SaqSUzHZ0rFQpySS0dfnr7dhxECOnIDTKypYZyW5dTJk3imbz+1Vh07PQVDqGx68iP8so3QYhhqI3c88AC54W76851k9CFmjp/OiuVvgK2iyECWp2gGkWgS27YRuk7MMMhmsxSHeyjqWSqrYpimSUvLRDIjWcpOCU9KFFxcewDwyOezoAhiiTi2Ww7SYkLhgKFieRjheOBgVA2K+SJmJEK5HIympCeDxGmpIITElyAVgYKGHEOsCgSSQCGCVEAEEWJBcrsL2phO3LED7X65hOXYRBMVlB0XIcE0TQzdpFAsEjGDMIDKqhqEtHCyBcZPbOGck4+jMPAxrq0xlHOZO3smN/37NbQf6qVYKjP7iHmsW7eOmqokkbBJfd04wqEIQ/3DxMIpfnHH3dx37128tvx12tu7Ao+JYKyR6iNE8N7JZW0c12V4KM3UaVPI5vKETI2hwTR6COrqKvE9BVUVlEolotEoA8N9VNfXkc3lsbJpPnj/BRafcha33fEb7vzJtTTU1dHbYSG0KFg5fOGAFLQceRbfvf4qLrj4HKySwh+WvRE0f20HQ9UQtoqUOiQq6VddjohWk80PQSxGvyWo1xL4lo3Sn2bvvk4UT1BhxPjwtU5cJc7IyABVNYLM6DBV0mdoxxZkoQy5AvlsjoF8ibB0Geo/RFa4iKKDWyrRPOEo2lUHbdGRRIdGmVBfj5qcQ9PUVi7/7lUUDnUgnRLfv+JqzrlgCa+88C733fc+v3/oDm66/k7qp9xORbwG1XRxrAKqU40sKFTEVSYcO5NHntxKyJxGVf04DnZ2cemlX6ent5P77rmF2bPnctqpZ7LncAehsEm5nEEKHW0sj1TKwAQmy5JiPsO2vgI6Op7Xi6oqaLqOqmkggmZk2XXQFQNNVfGFh6KCa/lYdhFhuLhKES0cyIDD8QLFEQdFJPCVEMnaOK5tIn3B+MkKM2aNp7mpleamNsY319HY3EQmN0IqFqaxrp6RkTTbtm2jprqOYTNCd+coUsbQRCWOHPxHpfP/nXpkbKT96t+tadcBQ8FTx61Ag5TySiHEA8AaKeUTY8c9CiyXUj73P52/vqlRijycsugYFh6TJKsU2J/Tefyev+KqBreOr2XrQC99rQ2cfe3V3PKf93Phtddwxckn0rV2K7lnX6Qnl+fMn93GcEjj4FAfBzo2c/9tvyIiDHzX584bbmLizBauuPMnDHf1I8oCKSTzFy7gyOlt+CETsyLB9T+6luUr3uTmn93KkZOmUbTKrH1nFcJXOPGW8zjvhvP52D6AU6Hzt+k3sWvtbvb1lFFFkfc6HmP7pk56VqvE03m+feXFTF20kEh9nCpXI1FTQ/2EZjLdOXCSaIaOa48icJGKACGZPOcoHrj9vzj1tM8x3NVH995D9Czv4GsP3s7yfVtZ+eozVCc82tOdDHcP8MeHHqM51Ub74X1BQywSR9dC4KuATywaZPS4bhAflknn8TxJJBIhVZVCUWKUsnlsp8RocRSnZAWOOqCueQLRZIqOPe34dpFwTSywZrsyCFCwC0TMCKVSCRQB+Chjo2wh1DFeiTemyPHBt8DNBnpjxow4UiIJzBrS19GMMEKLoqghFN1ESkE0HCKk62QLLiEzTrKilpHRAtU19RSKLoYZIpsbpWXqNIjU4AwP0LP/z0wdP4XJTbVcfuXFdB/O0N7eQSxV5vG/vsTMmUdQVdvM0qVLufALZ6MocMIJS5g3bwFnn/V5UqkUN954HQMDvcQScYaHRzDUcCCBdH0830IRPrl8kWg0Sskq0tc7SDyaoljME46EKJfL1NTUYIYiOG4Z0wzTebgbq+TieQ4ogdQwFq8klx3h8utvYfCjt7hnSox2tYrTn/gzmipwcblq3iyOnjufN59eRzZ/iFR0PA11NfQ5BWrqKklVxxE1taQaG4g2RBh4+AFqfJ1CaQAloVCjJpjkJKgJpVglD1OdShLzFCpiKaKGCo5HrlxEi8VomLaA/ft7UMMeZa8USFlrq7FCBj/7y/MM+iq/vPgcKtI2FVaJrO1Rl5pO1gtTXHAcL7Y/x9oNqzjz4muoDCV57pXniJkaa99fSUNVG3PmtzGS72HV6rVUJidR8h2OO34eb77yMuDQOn4aHYf3EIuF0CIm2bTLWadcwNyFl/Hc049wqHMNxeLhwJopYdLEZm74wbWcdPrnaWyewnA6jytdHNdFKBIhFRzXHWs2+4wpU1GF9t88nbFQ6k/NX8YY492VNuFwFNQIjqsxUOglVhXFdXSakmHqtToMrx4HBymGENJAEgVipCKtZIv9qEoW1Gq6Dr/Ch+u28N761bzzyqMM9NqEQxqGoTFp0hRiiRTr13xCLpdB1yWDQ13/36lHpJT9f1fQHwZeHfvYDTT/3aHjxvb9z+dDcMW3rmFqbS09/e/QesRU/vCLF3CFQTxSRSEWZqKXYO2Ofta/9So/uPpq7v7NPfz5pzfx5ugwveUiTU3N9Moc/WmPUETQVtUAElzNxZE+Ly97ipn7ZqLkymg21IUrGF9Xw4yCy+yDPURVMGMxVl34PXbt2Mn4oTTv7vkAQ/pEIiZOyea0Gy7hYGQUXYNMPsucSxax8u3XWDT7RIpmnF1rtnFgbxdLZ59LjRKE45ZFFZqs4WB/DG9wlPKAiuaouFoaYpXMOWo+P7/+RyS1SkRlhPnz5tG9dhcntC3AFBqjUYN9Ikx4fCUD5TRFv8yhkRGm1rdy2x+ewBnNEaoLgePi2Ra2YuAqDg21DSiKwkB/F45rkcvlcN1ANgZQyNlkRqJE4pU01tYh1BiRVJJyNk9fTw++dLEKFobqkEpVMZqBUqGMGTZwXAspPVRdpewUAga1PzZyRhtbzx4bDIjANSjxx6SX/pgbWwSjcYLkouBYDU01EJoGQkHX9aBAOi4l10NRDIQWuDBVVQ3WtBUP3/ewyxau4+OUcuxv30r33gNY2Rx3/fQWhgYKHHfciVjWm2ihIqeefAbhSJRIvJqOg5089NCjJBMxdu/eRWV1NfligZmzpmNZRXp6uxjenmfGtAlUV8TYsW8PpmGSTMVQURg/cxqW5bBp82aOX3Icb6/8gFQqxejIKFOnTqWj4zCKyOL51hh8S6IKf2xEWMYwAwmlxOCP9/+MVMjkmgOCvWmPSeOmIjWPVGaYCyYewcCeTk49fyENp36XqZNmgRmhpWYieq2BVCIg3GCVWgreeu1dGh2F0BFLOGgP4HaNEClH6M6VOOXSr6AIyXsvr6ArO4zqBNfDci0Kg70saZnMoaFOjJRBNBXlcGYQIxUm7xTI+sG6uJnJUFkQ6GGBn7GoajQwyib701lmz7+WA9kK/uu2n/Obe24lPJpm6Wkn8erTz3LtDZey9pP1VMQbiUYqyRS70WSSNR9sBBRSNUlyZQekQsEDMlmiyQm88saTvPH+SnQBn1t0MqvXvIjvF4mFYhxu7+SMU07nqWef58IvfpWh0RIVVZWgqnhucN8ZRphPB6i6rgDg2W4A+QJQPw3cGGPFOB4BkVihWLKoqI7hWj6hUBRTDZMKSxLY3PKLn3L0rKNRNIErbUJamFi0As0wiEaT2HaZt998m+eWddPQ0ICkRLwyyYTxi7ji6lMZGOji1Vde5M23loOmUJ2op2yV0LTQP62X/0dFWwjRIKXsHfv4BWD72PcvA08KIe4laEROAdb9q/M5ns+QA5mD7dTXJqlsmE73rp3osekUcofoaqnE3e0REg7Pv7iW020df6jIz++9mdZZbTT/27lkeofoz+3FyUmevPU+7KE8Ny09l8c+eJX6ZIpy535e6NzHYFiBaIK2E5bgWFn2dXcyr76JUGaQsutQiobpUwbpl8Gaq61quLYFFQbvP/k+o1VhlrYu5EdHLOZLq18h+YXxvLnjI3a0lxlXN4Xm+qksTDZg5Ud4/5PVOL1hHn76Me5/8UF822Hh5V9jdsN4dn68nmltR/DC/Tfz8xVfZJ5waVYiPOBrvKzkkbpOKlnDqXOXsmvLRpTKCvqGdnPSGcdT6DzEe2+upGNXBzW1LZRsB03XcewyuhrGcl12bt9M4AICPC+41CKEqgrwXTwUXKdEeuQg6ZGDgIaqJtEiESa0TcA0TXbt3E96JE1ty0TqojEKhVFy2TR6yAxgRWMBBo5to4zd8B5uMNIea1p6rhtMO/3AwDR2/yDlGI0REGgoQkPqEcquR9gYIwg6DqqiYFnBKCkUTSBRUHWNspVF1XVcLxusM6pQlYizZs1qrrx8MY//+UHG1VUybvxUNm7u5vePfoMFC6fzwD0PcN/9D6DqBqFIEiFU9u3bg6YM4Ps6+ZLP+2tW89qbL1NRGecbV15GWNEZ6O0iHDeoGVdFNBSimM0QCoWoq6nHCJnMmNbGihVvccmXLiSdzXCoo5NYLEE6PcLQ0BCRaEA9jEQCkFapVELXVTy3HOi8zQgNtVPoGR1kdShPUUq+cNSJJMbFaejcTanzMI2tdbReeTYtU45GkQUOtnfx7v4X2bB5B6eefTIvvf4yN/zsJhBVbD80SGtdI0plNYMdfSTLGkKGsRWfTH+R3u5OwmoFtiwF18xXaUpNYDSTZvf2gxTLDnLQJTLiM8WqQtnpoEejfPDF75NzslgH96OWfUaSPramo4cryZYtqi44jkPOPn5+8U1o+67mRz+4DSVscbhzK2s2r+bxJ1/GB1RKOJ7KNd++hUcevh87n2Tm3Dns3LER6Tu89EyeZ5e9w1vv30PG3kh1sySkqXTvK3KwczuFgsVvHniU1sYk9/zqLp599mVOO+NsPM+HSJThQiGY9QkROFgt57N779MvfYwLHwDRPCQBXtfUwTAMbNtG1QMTV72mUNbgw40dqHGFCsNj0fTZXH/dlXgFl2QqFBj7NB/FC1N27MDQphjMnHUR37quyJsr2/DLCs0TJrL7gEnGOsjzL72BGatnQlslnm9TymZJGAlCmg7D/6T+/qvlESHEU8AJQDXQD9w89nkuY4A+4OpPi7gQ4ifAlQS5uddLKZf/q6KdqqmV537pcnoPtxONpHnlpbcRShuul+Cb3zyFB7/3ef781yd57td/5t2RLLNPmcBZS8/liR/fS4+EG+/4Ei0t1Zj9kE5nWbmjF7uyitceW4YqfdpSlUyrThANV/P4lvVUp+rZ/8EGvGKa7x2ziEWN1UzOlJl3/ClsMA3eXL+BYts4fvPyMoTQOXR4N3OPnsNTd/yWohmhd2IjTbWV3H/Dj0jHCgzOSXDzWVfyn3dcT+7pXu575AnG1RpsPLiHSZ8wtp77AAAgAElEQVRro9Nfz8btd1EZP4oXH8+R72ngkf96h/2H1vPGtd/g7IZKklXV2CGNp9/5G+ukh8BHRSVphhkp5zn5mstZdN6JXH3KhdQT4qKLLmLr5nZcBCMjZQqZHnRdw3X1oKmiBIhQ3TACGI6vIKWC0MCXNqZuULBsQqpCKZ8NdHROFkXy2YhEM1IIRUeEk0QjMRRhgqLgjpHmioUsjhuAlZxSHpAIxUP64rOpq4IbmJfwQJYQsoyUIniJjI0ZVFUACr4aDx4mIzCsKCKQlaGEggfASCCFRjyepFhwqKiooFgskstlqa5IYZgh/nT3zUycZOAr/QyNDLBlywi5nIOtZZh/VBuXXfw1Vr7zLvfe+1/s2LmbIxccxXnnns/o0DCqquFjsGX7WsaNq+aTVe/jlH1ioQSKYhONCyrrpiClx/YtG5k0YQLzj5yHqqqsWb2R9o6DSBXiiShHzp3P3r376erspbm5Gd1Q2LNn11iR0NG1EOFoDFVVicVihCIJfKdEsipFIqJSb1axcWAPBzIDtO3r5NSeDIXSAMcvexQaj8YVZVQlPvYQu+BrWEoOu3Mfm5e/y/Bfn6QpnETqPmVdoBcDldCo46BVm3ieQ2koT01FFW5ZpWSXEKqC9HyMiEKumMcNqShS4FkerqfiIkmXPVRNx8bH0iSqW6ZerWXapMXszsKlT/+EP7y6k7+89ALT2z7PZRfNopAboH3nIN/58qm0VJ5C99BBhPARSobWuulMPmIBwsjy+qu/QZBj956tVNU1URFLsG9PGs9K8+jvh3julTvoGn6FkBnlwd8+x5cvPZ2QZjB15kyOO34xy9/9gJt/fjtIlUI2hy5AKMFIOpvJYNtBw7pQLOK5Lq7r4Loe+XyeYqmEN4awcF03QDe4bpC5GY3zlW9+n3iqitrmKNGUSS49iC5GmJasIywEniwGz0eg8cHzLHw/gqpHOfroS3jv7afoy1sMlQrc9J9fJZPu4dCuBKlkDMcqgFdE1wSTJ0wlm83SMq6Rp5/4/f/Z8oiU8pJ/sPvR/+H424Hb/9V5/35TJOzetomKVJzqqnqqKyoYyZbA9hg/uY0DHTlqWydRH9GZOuyz4Z0D7H7r18yXCpMNgwM/fpoGI8wWu4SvaPQkY5Qb65nWMoXJ9Y00JiJsfm8FI7KbxvHjiCVqeGTDSl549klKEyJMWzyHTE0dL3qC2554nM5MkWTpINE7fkzLpBY2v/4RpWGPQVGiUM7x+w+fxrN9nAOfMJQvMXnK51mxcS2XnH0Zu+t6eeH5v9LcFKGrUKJqZgVa3KW1ZT6z2k5kzXOv0+m2c+O/L6G6tpLBwlY683Uk91WgmSGmVDVzwhXnsCczyIw5iznnhKW8/8kqdo/uIzfUg5vP8OCfnuXVF16lum4ysYokUpYwdQPPd9FUBVVREFrAF5Fj7kRPkUhfQWgGqghRslyEHqRjqzEdVXg4JQ+/XERVBJ7v4dgFUAywHaRjI7Qohh7AlDQhiEajFAoFNKGjxuLYdhnFd/EBiYv0grR1pAc4QYMS+PTGBoGqqEjpf2aB10PGZ+hXTQnitQJ0q8RQVQKBd7C5rosqFLLpNPV1VQwM9nDu5z9HZY1B6+QaRtODHOzIU11Tz28fe4Dde3bTNrONW2+/jcbGRq67/jqeeeYZnn/hGc499wsc6uji6aeeo7o2ygUX3sBfH/8dM6bMJ5aoZc7sNoywTSav8srrrxANmTi+wm8feoSOjg7mHbkgoCgWi6imxhNPP0s4HCWVSrCvYz9GSNDU2kgoFKJckuTzRapqahkYGCJXKjNaLJLO5RGZbmqSMfqMQd7/8GO6RkYZH28gEpuAaiYoHCgwZPYR+2Qdub4RNq5ZR/ZgB70H+rCHu8m5grrW8UyaMY+DWgFNVxgu5REJhaKpMSR8MuVRUBXMumo82yGc0rDdoAeioGFLBz0RQwnplF2HZCxJ0Q4QtEVNw0YyaufQVUksl2TTUJbDbRFO/+oVnH3LI+R6ilx+yWWcc3IdGWBnh0tO9FEo9qKrPrqmEMz1HAb7ylRUh1m27E1eX/4bpKfz5ydXcsvNnydnxZnWVo0U1Zx6foSZR/+Kb39ngEsvu4A9Xe384r4/8Pizz7Jnz27e/eg97vzlr9i0bQfZXInqVAWVsRiW62CaJrF4BbqpEwoFqIIgvFrFNCOYphkwaJRAq62qEDZMhAKO5+H7kmRFnIKl0t2fplhwiEQieEUXNRULejWE8f1ooPdHoqFQcBwU3eHCLy9h5/bt5Iwkhzs9nKEjyQ1N5ZijVFyvyNBQP4Vi0JDfvnMb8Xic2trqf1ov/1c4IvFsjpl7BFdcdRE7dq7iC2eex2B7FWa8holzHV7+YB2hYoFSWeeua29k5aqP6fbLfOu67/DQXfcQ3t1Nr2Ny43XX0TOQ441nf0c6neOIJWfwxvuv0jqulmojiVZKM9IzSLqji1d/+XvMZIQ9B0Z44ODLDPvgKpKwb6IB/nAO+2A3okKjeUEr1UMz2NT5MRPG1bMgFMNpjFBatIDmSAu1tUdwwmlfJe6M8tTOR3EnDlM5VcfoqcRKV1DyqtlbUUfZGGRv7W5mHDWFSUe2EKmM87E6DTV8BPdv3EXOsxjes5/qJ/5Ijd7A6L48hQOd7OvZSUVDjEptEolYlOuv+wGpZA1DuSJ520a1gyKrqwraGA/Dk4AiECo4vgWYqGoI/CCdxvVUdGWMoSJMpMhjRmsxoj6ZoX4MXcHBI1FRhUUEu5TDT3fgouBpEYxwBDMSJ5GI4bo2TlkQVuO4iocmJdIt4WIhfQfpO+AVArONFICKqpgEhTtYI1UAQjqqEcJ3A5KcrgjKtkfIjCOFhmqoeFIj7ziEowq6FmZoqBOET2fnPsY1T2TFpo18snojeijM2ytfpaX3MLu27+CKiy/jcGc34ye34Gkab773NuGGWtZs2sKcI3XWbtzK+No69u09THrI4ZP17/PhmvVMm7qADXv2kfWhdXKCM0/5OvMXLeXOu2/DDcWpqG1kf/sh9vV2oWsatuUSileRzkLZBcM0CWlR+gf7cBkhEY0xMDxEyIiyYes7VFZWUsiV8KVDbV0DigWFksnk6RNJRPqZ6JQoN87kP/p2MiJUFrzwJMoyi0hI4HgeWpVJzohQmDkBR7Yi8y52PMqu/GFQBPFoDAaLxFSTgcF+nHg4SFqybOyA+UDIDeN4ZcpuAc9XcMw6HEejMGQT0nWiGYeIKxDCRUYUpG/T6oXxSgXCiSi106bSt6WL+LEO//nNb9CZGSLnhnltrUpmtExr3TjCZZuFC5cyZ9Yklj/fQXNrHTNmzSUaK1BR38rbby8H4VLbMp67fnYDN//H94lpGTzhgxXl/dUv8Oqrb1E7CZ5f8RI33vgN6lMV/Pu//whdUzj1pKX89jcPsvDYEzl+8SmBpV0JZoxCU3BdiaryWSC17/tjAC4HXwpKZeczgiL4RCMpSqUill3A0CPYRPBdBU8V+IqH40gUdCQ+npJGwcDHxfcVpBhBUeKEIxHefmcr13/329x91/s8/NiDxFMqzS05aqsMItEEqhplysS5FItF9uzZx9QJU3Edn0y+9E/L5f+Koi2EQkf7ATra22mbNhnhRjn9xBPYujXH6ysfYM36dvr27WTm/OlsETna3SwfdO7mwJP3k+vfj1/XzPJlr9N83BRCa9bTvHsVd37lKh5++VXufvIRzph/NN8++Sxqaiu49MsXE9IjnHrmOWQ8ixMXHsW4WJiTUs00NdZyfNvRjKp5Hlv2KHaLx+vd6+gs5Bno3UmFfTrRngR/ueY2lGSUictOYMXqP/Hdf7+FhuoUB1dtxc+WOXRohEOlAYYLLUxZpBD1dE6q8ZGjWfQ+lyxZBmpGEJZLNjfIS289x5VTT8WsSrJxch09+7vJZn2MiE7PcB8XH3cOz7/3F356z+/o7B9G4uDrPr7jYppxCsXSGF0OHKuA64OqCXwpQFGQKEgh0fFQ1cDhZxohdC0wCJi6ie8rFC0b18uC0ALIkxDkMgXM+lpwXdSQgm+XUdwyTm4U3AREaoNptR6MSBSpgCdxpYcQEjQBjkAikNLnU2ek7weuOsdxQAQ8Y1U1QEo0zUAIie25eEgMVQSNTI9ALujbCD2Fqgk8rwBFi3CqjrZZMzjvWz+k73AHExrGMdTVyeQWg0x6mLpkI07ZIxTX2b57P1bZZ1xjM4cO7KexqR4FCz0co5DN4bi97D+wjZAepme0QLyiieG8RWb3PvYe/AOqX6Kru5eIGaJsWYQTMRoaa8lkcniehmX7RJIhPM9CaiYYCmVPMDCUJV8oMDKawydPTVMTjuMQramkqb6Cjbu2EPOhZLvM/1wbW4b3U52o4kCxk2hVBM+yMBIV2MUijuaTLhcwbAPVrEXLFwiZGiQlsuSSlDVYik3JjKA2JSh6KpFQkpzv0xKNETFCFKSLFtbJOTZSemhqYEwJlVRk0cavDFjhwpGorsD1PQq6RUmpQPXiqCWbTgq4pTShPRbtq7bQlZ9DlzhM0ohRLSZz1OIQt954N8ueuJPZbY08texdlixeyKJjW7jrjh+Cr/G9m+5ED/VS2zIRK5ehbcZSDAVwouS8IcKKSVXlJLZtupWmKadRyh5g84dr6evt4s5b70DXVFaueIP3l7/IJ9s6sKVAUWzwgyg4wzTAD/T5vi/xvMDFiwiCJD4NPvg0CxUYizDziMZj+J7KaDaDphqUbBvhQyhqIvyAj65KgVQYW/oSCC8CUkVoCjt2bOK4pfO48UfHc9Tx49mxYx+ONYwiXPbu2k65XORQxwFM06QiFaejvZumpiZWfbjmH1TKYPtfUbRtp8zgyAEe/O1vMaiktrqV5tZdzFtwFIuXfJ7RzHoiRjV5x2awcjyVi2OMX5vgiPGzOGRX0TxhMokptSBdahctYijr8l8vPUtTTQ0P33Q3q+bNxykU6O8+TPvGzfQ4gudfehE9piOFzuIpizhWpMgkDd7q2UHvYB/bsrD1iRc46ltLmNA2hb6DWdb+9Sla3SIP//lhwhPmcL4Zp//4UxneB4/e/jSNLdUcHErTvnE/1573BdZ07sDPFMj6zRxa7RGPxNHdOuxhyB/ei56vh8pq+ow0dxx4C3eDSlgJ8d5vbqFSNamNz2LU1PnkF7+kb8fHvPrGq1x15XdIVNSSy+VoazuRctmiWBjFdyS5QhpEYILRFB9V6EgZ+0xa5zplsDV0zRxTc6g4RQsRCdI0inYOYRjoIoRruUinjLR8wqN9JM04OXM6TggsexTVEDjuKPbw/uAiqhDSU0jVBEWgaj7SD14sAp//XhgZeziEj+3ZY6xuA6FrKBJ8V+J4ZXzfRTNCCFXHkxIpJKoXRtdiOKUuGiZPZjRbRHUS4A9S3xSjr28Pvm8ysHYTF/3kTGoWzufICfV8NG4Vuzo76UiPECok0Z0iXQe76W3PMaF5Adt2jZCobOeab19HQ9M0mhqn0d1nMWtaE1s+epOWlrlk8/0U3CGu+uY91NXVUC5BZ1cXuRGbHbt6qalqJZvx6BoapHfYI6ZNYtGC45g8GSIRj3ff72HPtgxz500npQyQzlgopRC9h4axHZfN726jtr6GoiHYsHM3J5ztE+rtpGfvTm781d2EpEY+k+XQaA+6EiVfLJBM1VBdXRsAwurChJQQw6MjGFUqprDYtnot4sAolDwGSw4NbVMRmTLb8gewPAurZBPRQ1QmkihGiFiyGlX62KpLMhmn85MewmYcTQ3hCQPN0FFQ0Ap5UjEfYai0yCiqpTLtjBlkBjvIvLKDCactYTCd4zvXH0e6bzV4KWJmkp2bt6MI2LHjAL6icu55p7Fz+y42rnmRdR+vJ5Go4vOXfolvffPHCLUB5DB33XcPF37hLL533Ulcf107HiH6+nNcdsVXmTB5Kl39XZx44omMPzyBE045hQsvuITjlpyKqunooaCZ6DoWuqZTdOxgICEkdrmIhweej2VZOLb9WS9HRWI5MhgEuS6RSAy7HLDgCzaBuSyVRBca2XAL9dWNY3gGcABf6HhScGhvEdWczM23/pGwYhCrDFgpdRXjsO0yxy+uCfAIY1mrmqZhRsJ4nseP/+16Fi+c8Q/r5f+Koq2qKpZjk9R0Og/30j+QJ1k3jv7hIfry3QwPb+Hb37mUxYuOQvgue9r3csQR97P5k7VIBLcc+zm+d+3X0dUU89vmsq1jB/Wlevbt30FLvJn1n2wmNTJMja7x+KuvIYXB6eefzesvvQBC5/kNH/BU2AdNY/EJJ9KvSxTV5dKvXI4ajlPIjaD0d7O7YTzxCXO46O5HOPfsb6OmKiiOCpqiLYihJBu2rKOhZgKdoyWeX/EsWc2iSV9KpKmRSfW7aKyM8dHHaSibTGxqwzGjDFeOIGtjHHviUibUz+TJex7l5mWPoHqCRdOXMnXcJDbOjqGN1PP68nfo7x9m/ITpFNN5pG/T19dLqrqW9IgFdglV01Gkj+N7gMTzywjFQKgahqJhhmO4niRfLBOJGviqJJfLI0SYeLgaD4eCU0bRTDzHQSgwmhsm7ElCsRTS85FCxZcWoXgVrhR4dhHp2VheDhQLRVWDuDDfB8/Hly6fSQCBQKMNrueDouELUFDG1CVj4Qu+i6rF0bSxou1LHMdFFRIhBb4ooygquUwOobvccfMtnHfuWRx/4Rc578uX44ki+/Z00b97Ax99vJrhsUgyQx8iZxUg7DE42kFPzw7KvkWFOZcQMH1mG0/++Xa+cs2VqCLGyMhhvvqVk/jdQ/cyfe54pkxr4swliwhHLH5686s0NzRQUxNl5szxdHb14OsKmpoiO5wlltD53nUXISQkovDr3X+ife8uQiEXRQ8T13X0sInl5Zk2ZQIB+cQnEY2xacMGzjvvPP723DJS0RC/uffXnHbKaVxy0ZdQ9cBuv3v3bor5PAMDA/gll7CpIisSpLIu01tmctTRdRSHRjClSq5QIu8LvJiKGZuFxGNoME1VTTW6FsbxPRzbRVd0cnYB2/WYNL2eRLwazwOJgeXYNNRMIJKswU5V4BaLdO3YSn9/L7v3SLTKCuJ1c9n5ySb2dm3hsq+cw4xp32fVRyv4yx//iqFGkUqecrlILj3Klg3biYQNoukcQrXQ9SqWv/wOl172b0SrpiHcPJs37GL5m+uYNbWV6UfMYuPG/bz99iu88PxLXH/Dd/n+92+gpWUcnT3DzJh+DFWVdXTsO4BPicHBfoSq4Hs2ni0/C6fWDRV3LNtUkUqgTNINlLEmuyIktuug6zqlcpmikaNkeahaKODEuy593V1ois/2HRtRZaD1th0XV/pYZYlhGOSyRRYtOobJ04/AVAwC9LiKbZXQDRPbCgidmtCxbZuybZEr5IO0rf7+f1Qqgf8lRduXHsV8jkmLjmbxMZOwbZV5iz5HNBzjYN82isP7ee35x9iw7iOiyQRP//VJlj29jC+cex7lUoFvfeNKLjn/Uh75xV3sGMxSLWBhYwOdhRInnHUOiVQVrz98F07vALPHN1M1eTZVkSgzZ01nx5ZdLJg0k+mfm0pP5wA7N27gcM8ISI3J1eMwmho5kPkQv6pET/s+chfMouqU6Tzwh2X87S8PkTJGeH/Nf9LcOIGzzvk8I/2HmDitnvO/+DWGcg5OaQHtG3K83/4AJyxppb7mS6xZ+yemnD1MPtSNmSqTsUpsff0TtnjrSVSmGPVVLFXyzP4D1NrQML0Fq2sCz/3uaeLxFIcOHsDUDA4e2okZjjI4sg9DJAmFk/huHlUB18kHjHAnC+igR/GERrE0iKLrGEYMu+RTUZUkk4FiuYRS1lDQ8NwIqhZGjySCzrZvY/9f7L1XlCxnebZ9vZWrOs/05Jk9O+egrbiVUAIBEpLIyUYYEJhoosFgggkSNsE/xiKDQCQTJCSiUEA5awdpB+0cJ6fO3ZXr/Q5q0P/9B/Z/qgPXWr3WrDVz0rO633rqfu77voKAsD2Gky/Q9hPARLoJptOPtASR3yZKaogwJAkDkrBN6sCPkKQTTjrJpD7xOI5RVBVV0YiFgq6rRJEPf53ENQ2BRixVpFTRzQyKqWDmLJqhTdzOkjQ7kMyybtkoF23sInR38YqXfpjf3/M9Nl96JfXKcTYtXY6atZndvY8YwWD/ABOHj6EqGssGV3L21hew7/BRWgsKPeUhapVZkDbBvMKD9+5GAF++/uu84Y2v5endT3D1xdswlCzF3l7e+a738PD9DzDauwItLiH9OSpTR/E8D0WW+ONvx7nmqn4qc+PsfPpRrIxCV1cXlq4hRYJMOqxdXqbV1iiWejC0CN1QkGKWvrLKT3/wdbZs2sxPbvo2m09bRZS0uOFzn2dmNi0LazZq/OPHPkR3X5m+wR5MU0cYQEZL38eGJawdPpc4CIgA4WRIkoCqVyeSCRvz5dSfLSVEIZamEcchJgqObhJGEsvJo2g6cQSqUGj6LogE3W8SJAG95y3BTEbxIx9Uk/1HDnLrh/4JWgqV0SF+8q391BoJ/f0FpmdmyeZznLZ5A6WizdTELFLJ0PL7EfERjNEhpnbex09/8wMuuOg8HnrgB8zMjfDSK15KMwjJ9xTIdZU5eWqeP/zuZ2w5fZAf3/xNFEWh1WqQzRTxfZ98rgcZu+SdDFKktG9NNVE1CIKAAAVF01M4t5La/Dptb9GjncJLUBNarQ6OnUeEkBUpAFsIgWFa4CgIEWMqdtrDj8DJ2HhRCJq2WP1r43aqGIpGFLpEUqCqKoatpx03RiYdUKTE+b9cWYZhEIT+f3tePi/6tLNZRy4d6SWKA173mmspdg+TzZaJZZu5VpXp4/cyfqrK/gMLCCGpdBZ4z3v+ni1b1pAvZvn3G24krLT59GvfgxEKXvuPf8fHP/AB3vu1r3Htte+l0mpw4p7bkI0mSy89jz0nWlz9usuZmj/FL793G5vXrMeNpql2Ql58xeVMHJnggYceYvXLR2ijcs6Vm9nz1G5O3TnHu9/0N/zi27dx90M7eP/n/h7fmcVWBjj7zItotVoUbcnXP3w9l17yYm79w1188F+/T9+a5bj5raAIPveh60mSh3jl9YLj1aepnjSZvd3jNZuvZOvK09i18zAzk0+RGRpiYjLijG0X0L+yn0f+dCeHdu3g2PQpDL2LMHaxnb6U3IOPKrtRFIPZyX1Amj7UNA3LzGHoNqqdRSg2XuylJVBWkfmJowRJg5HlG1CFQ6dmIeMGDXeOiDDlQyaLMkkcg27g5LL4QqSLztDC1BOiIEaNBGEyj4IkiUJk4iFEjJQhED3nlwUNRagIxUAmCkdlk6XPiSf/e/3v9b8XwEK+SLlRe/72aQsB49Mn+eCHP8T551+M7RSJIhtN81loz/LUXTdzz4MHuPeBHzE7X+Oal32A7954O1PTB+gpl9EchXe+4jX8/qc/5EXnnEcM7HjiSSSwfO0azLk6tzeanKeoBEHEyeMHWDr6Xh5/+BEADhzcT6ikEeyf/eh2ROyhKCZF08bIG5yYaiFbXSwJdYJDIeeedTUn9rvcc8thelYvY8Po6fzrH//IZz/xISwhGd20iYOHH+N1rz2X11w1xKrVq+kWDiQKr7/j7Xz1W88yVJpgw+pz2FWrs8ea44EnH+OxXdsZKK4nVHWyEi4682LOPfty0DqULnfRrriERqPJRz/2KRCCdaMj7N13CF/G5IppgnBwsEwQ+MwvTBNFLu3Ypy0SlE6RXGEI3++QzRaYPPEIW88+nz8/9Af69H4wyohgBs3MYjgZbMPEsLpTPTNRcdsdWrUabjshV+4mRuLhEskQofsk0gcZIiOei6kjY4SIF1N6qZ6dkIKCkzhE1R2WhgmGswRN0/D9dLpQdCMl40gTmag4uV4MxUY4NomiYJkFskqWOOpQ0k/ys299ndrxx+guZAnNHvSSznynya9u/S9q0w2cQh6JRqJqhLGCjOI0TSmStD87SV0DhpZWv2pmgtAkkJAEEk03UdRUxgs8FUURGIZBkkgMLaUkmZqZwiCUGoqmoJAFJKqWvgQ6upZFVXQUXdJu1ekuOOTzFjf/6JtUZitcdOHZPPH4o5TyBer1tDWw0ahjWRambpNxchw7NUYulyOXL1Eo9ZAt9BD4MfPNmCWjyzj/om3s27+Xlav78FxJqVBEA1y/hVAkKBqOmcX3/RSGIQRKApqh0/JcMraNV6miCxWhptJBEoPQ0vefiISmqxA7JRrNJqW8CRG0qwssXbqMf/rc5zm+/0kkDm6jjgSufdubUIRLp+HR09/Hj773MzpuyJYzLsG0u1m+7myWr1rOGRdfSRyHLFmr8p8f+38YmzrGY3ffRcYO2HLey/jVrV+nz8qhmyO8+tq3sv2xB6hUWvT393Ps2DGEIhej6iGdTgdFSQhDn3y+CykFYdRZrOBVMZ0MCDV1QekGuqoRRRGGYWBqeirZKUoK+lAULFvDNGx0PU0qNtwmqqGTdTIEUZwCR1wX20x16yiUJOip9GIauJ0ITbUwDOO5OL0imkRR9P9ZgoZhGqe/47+e7zR2oJjLMzk+QalUQigOGzZuorJQoXVwFt9tEfkRH/zAhykVexFKxKWXbeAzn7yLVasG+PevfZHbvvUteufg2suuRNMEIupg520O7T9AQ8DfXHg+ex96hBV9Q6xa63HLLbew/rTNHDs4Q2X2FLpwkLGGpB+TADc5wrm5FzCydgmrL9rArfof+NGvfsgb1l7Fjf/yn7zmunfwzg+/m+3PPEXSrqFM7qHUZ/PDG2+kOVfh6pdexamJU/z+1tvI5+8lUrLkynm+d9O3mJ4+Rd/4etSCyam9dWoH57nyJZfgz3Twpc7hQ8fJFBx+fMtPuf/J7Xzww28nVlVuvulmntq+gzf97Vu5+54/seOZxxHoCCK8WkArjlAUiP+qIatq2l4oJaqS4LoLCC2iWXchhsOHjzJ12ASlA3GMxCfyI6KwA0JDt3xsJ49UTWzbIQlTDmMSC56YVSEAACAASURBVBIpSZIIRLqBEUmEjERKnZGStE598SlOpr0qf/05PdSVRTdJ6iTx/ZAkSQ8Gw7AWI+4qqm4ihCCSEZHrYmXzeG5EV9EmiFuctmkrWVshMrIkUUwsG4TzCavWLOcrN1zPd7/zAxozFVZsOYtWEhKEHjnHxvM8SsW0LtPS0kCSZqQ3CUVLPcuxkqCjIZTFwEWipL+TEanHXEdVTaIgRCQyDZ6qgjCKFmPTUUpCkZIoFESRJIpjVC1BUSJOHtnLw/c/iqNLyst6mZk4Rs7SmJ4cw/U7jOZG6e3pptFsMj45RjFfwtRiDD2m3V5AEtFoerSaHqMrtmJqOtPjc1x+6TV8+vP/QilfwLYdms1G6n1PAoIoJA5TCHPgegAIQqIowgt8YgliUaNtul66JDMMOp6blpBJyDkFUC38JK2IaMxPowUhbqfN4OoVtFsSZBtQGVm+lR17DqJaES/atpWH795JZKpkVIeVGzfxu1v/wrs+9AW8EJr1Bt2FHF5FY82atTz+xKMEwXEyuWWMzx6jZBpAQLGnxK7te3jBRRfxl3ufYKB/CYV8GUPXkAIM20j3I2p681VVnTCSKCLCtu1FtqcOQll0J2lp8tZNgR+QyndCTfcr6YdUpindOP37RF+sVIDU5qpplMpdeJ5HEIdYjkXLbSETgdcOMC0VL/TwQ+050AZ+8v9aEBc7UMQi9vB/up4n8ogtV68cJJPLU2/DwOAyBgf7UaTFfQ/eydJsk/41FmdftBzL7ubmHz7A4w9NkKY4FFQStgwMs0lmKYUG91V3s6BoTJPQO7wey7JIFo5S9lzGFA0fm2xXAU0VzExOsWRoK93rX4VeWobWezqGItj160+xem3IJ294Pyt7svzgZ1/l+o9+n3d/9O3s23GQnQ/s5e8+eR3f+OqXsFcMMjxyBu//wDtpTMzwqbdcR3awm1XLl7Lr/qf49Ge/wOXv/ABdZZ9PX389f7lrB+vO/Qj9Gzdx+21fw7/7FlYWPRw1R6Xu0lFrnHXeaTj5dWzYcBaFrphnnt7JG179esZOjrN/z9MsG13JxPFDTE6c4Lbb7sCTEkVLYQ8xEpmkIIJEJoCCBAq5MvXWwmIlaogQsHvHCTadsY5s9wZa4TSqHxK7f+2nXuzERqZl+3YB3c4SxKAZJkEcoQlAxIjYw3cTkjAAApDN5/qz03DN//1BVAADy8njdmbR7D5AQYgUkaWoavoeSN09lpmjkO+m40YoqoUUOcrlLg4//SiP3Pld5k8eJRO3KFkmMqdg5HIkoYehqOTNIgNb1/Gh932Ab9z8I7rLQ7RaLaIkRlUVMpkMgZ/yAKUUWLqJjJzF6IdAmDoqIUKqJAHEahXTyD4XAvrrS8h0jRgl6YSm6+rigksniRUcO0ciY8IkxFQlSdjm7E1LkFGbmYmD2IbJ/v376enpQwqDbD5Du1XHsm1m5mYx7TyaatFqVMhkbISmYjt51m86m2qtSd/gClrNDiEafizoHR6kd3CIm3/+S1gsQbJUFVNNKHaXabfbeF4nbWvU0l4O3VAJ3A7moo9ZkUl6SFkmQbjYhS7BNrOYuRwdr4lqJrSaHrLRYbC7m3m3wvkXXMLJSpu+4jLuvOPXbFo/gBpV+fnPbiPr5Bge2MjwmjXc9bvv89Hrf8JCzeWss88jbCtsPXsNeVvhwMEZTk4e4Cc3fpNndvyedZvP5+ln7sDRVvL6N72Fvzz6S5asWM2TDz/FxRdfhu+llbxSxiSKiqaZBIGGoelEUUjGNgljBd93n5t2dV0nSmJM3cBQDZIoJkpiZJykThlFodPppE9lUYiq66gCLMNEqiqu7+HGIVIRCJHq5aauk0RpU2Ymn35GXD/EMgyCxak6iqIUbi1TTfuvTzxJkmDZOaIo4v7f/QcCns/yiEAqkiAK2Hr6WRw/PsmxIzP0dJd58UsuZeedP8d3VXbt3M7AwCg9PTbnXbiauD1IvmDz+D13MDjYxZbMCHkE9z9ygLO3jiI2beM9b/84A/3DLDVnuWjVOv58551ky0v46W9+wbZt2/jTr+/gm9/5FT0XXEZLt5ibVFD8BtXKBPtOHOBfb9hNdz84sQ8OtMOAV7znvew68Bn+8zNfoauvSG16koPPTLHkm/+GXLKMMEmojs/z5NQcmirY8dQTrNu2g3afSjlu0iPrzB6+h0PH/sQ7rrqUY1YNb/YYpqazuVTiyPiz7N+/gxVLSuxr7eDd73s599/7EJe98HK++MX/YOXK1ThWjpMnD2Dogje/+UJ+94dH8H1B3QuJI9Jvl0gnWiQYmk69OUs2Z1Aolunu6mNmdoI3vvGNkOjIMIKkhGmaRLRIIh+SGnHiAR6qouG7HkHQQDXKRDFIqRErAkSUdg+ToKh6GqiRqf9eyiS1WfFXTTsN1ChCPDfFJCmVDN2w0vRjirFFaCqWYRMGESjp3xu6SrHch+9X0Qs2zaDFyYlxBlSBdBwMRTCzME/RcTDtLEnsc/yex/nKTd/lxa98DW9+2/u48ooXsbCwgGrqZDI2fuRjGAY6CX7HRTPzxOhgGKBIhEy9uYZSxA/aJDL9vKqqQpTEiJTAhq5rCMUkSSIS0QAS4kQljgRJLAhlkLI1PZdycZgoqDB58ihuq0q+v4fRoUHCMKbc20MQ+Uw367Q6TTKZDNV6HddbQMUkk7PRNINy9wBhGBLHIYWszsz0HCPLVuD6CuPHjnLWOedjG6lso2uC7ryD50eETY84iHAbHYSMkbqLUFXiUBL7Hjqgo+Av+ueJQCRpSZcap/DbTKmEUE2EKtBNidll0Gi3GJs8yRc+/XF03SGOhjlty2rmZus8+ejdFLpyJHGWlRvP4pHH7uRFr/kYn/ynv+Vt7/ky+YyOmu8i6njs2BNDJqK/dykf/sj7+eznx8kUejGkhtldItDTZsgTB4/T1zNIrVLDtB08P8SxTZIoIYoDwtCHSEdGgk4ksLMmTa9NEi1KQxJ0QyVRVDpx2jrp+X7aWaIoi0nc1MlkGBaKAp7bJmOlXFLDsWi02jTcJgC6mtr2craFCGF+PJVQotilmkQYhpaCxuM4fZJUfJAyneoXJRI/qvP/N0g/LyZt23bkFVe8mOMnT3BqfJowgG/c+F28VkSid3j4d19i9+EDrFozRKPZodrwMIxezjvnQhRFYfpYCyvXzT9/6kOUMjlU0+KTH/8EP/7OjUhVR4+hMGCxrjzCH/Y+SxQr5HMGGc0g31PGULKsvfD1WIU83QMDvObqy7jpKx9ldJ1BJpC84to3cteD9/Grn95DcaSfehJw/vmX8fCBXZzY9QSD+UGMnE5nrsbU7AzbNmymu6uXZn2eylidaqWBiBPaYZ23vP06ZCfk29+5kVoQksvlqIxNkCn24klJtVpFdnxGhoZptWsErsfbrnsrIjNIX/8KntrxMK+96nIevv93TBx8ir6+An6tiduJCJOImYlx2n5IgEMQJUzONEhiQZRR+NGPf8LHP/FJYmkwMLiak5Mn6MkpHDroE7emkOYA5cEi9XoTy7QJOh2QksgPSGKXKJpO3SBCAwSa1Y+m5YkTBYGBUCKI6sSRiwwbSILFG0cKR0YuNqqJtG9bYiFpolpLU61Rz4NUUFTSQ1oq6QGJRr7YTc4uMT1VpXd4PRmtwVmbV7NtnYmttMgEeTqxQqE3QlcdbFXgWA6GomAYGk23guZkGD3jQtas2sKGzZsYXr6cRrOJnwSYtkVISD6jEbWb5JwczXoD09QZn55DUQ1K3X147Q4KKoqpgxREaWE4iRcjRZhyOJOAXFEShSADiefGGLZDQpy6FwKXgbJNfWIvkdugkLWxHYcTY+Noqg6qhmnpHNo/weBwD+OTc2RzOaQUrF65iiiKKJW6sS2HRqtJrphndNlaTMdmvrKAqedZvXodM5OzjKxcx3v/8ZP0Dg7hRyHFbIk4TBBxgi4lMo5QLQ9FUfD8ML1pL1YfmEmbZruDZTpoloPr+thOloYb07tiHR3fIwlcIs/HbVYRQUDW0Xn80TspdA3yile+jHvvf5jpyePkyiXKVhcjGzZyz29+xrYXvY2PfvZTHDt+ijt+9wcsCvzmvz7G297yOZ55ah/XXHgu0XCGbI9Da0Hj/Eu3seWMIbYMnc1pK1bRKkR05U0ev+dp1q7fyMbTT+fOu/7IWVtPozI/T73RRugWQeziZKHValAqlkkETE/NYxsOpmKk1lKR6tmmlZZ5dToelmVgWRbz8/MkSUImaxLHEUnsI6MY3bJxvYByTz8zCzU0zUBG6dNa7EXEiY8UMULTUVQrtbYGLjIOkIoERVANUmlEV1Qs06RQKHDs2DEcx6F+/N7n96RtWiZ/uusveK02hmkSBBH333U3H/nY+9n/7GGmqz6KkqfT6cJxhjlt6xY0TSOIEyKhYpRydPX2MbYwy8mZOX7x05/Rnp7lRRdeTAYfNB3PyRLrcOVAL64fEsZJ2rbWTlCMmBPP3ESn6WFkTG65cQrP11j4QQMi+MjHvolEIdNToH3XI+CH3Ped32AoKhgGM+IIKIJ2q0PWsfnT3hnaizqiqqf/Yq+TLtn+6ye3cPjwYaoLFWQC08whgIX6GKCgSImqWYxNTBLHaW+C7RTp6hvgzr/cyVmnbcB1W8xWZugt9xHFPiO9I+w5eYhAhgQAUUTiV0kS6MootKKEQM3yzn94G5s3Xs3Q8tOpT46hOcOcddb51OSvkdUexk88Q70hkapBEIVomolAJfZ0FMUEdQ4pVZB+euj6C4RxQEwWTUmIOjMoclFaESClSP3XQkESgbAgiTFVh4wlcMMs+E0UaSGSiFD1EKqKqZpoioKWaCk8wCkQawaekEReSL5YYChXojtv0KycpBV1CJ1ehGIxfcqlu6+MqmvYpkUoBH6rjikEnekFBod6ecfrX8e3f/YT6qHHUP8QmqETJjGV+TmON5vU56cJmk2yiYolVAqrhlDb8MzUAqevW0ljrkUQQRBE2E6ByAuIvYQux2B6roKVd6idHCMJE7qKZaQ0cb2AanMW08gTe3WcIZstF5zOkQP78Jo+MYJEJIRKhAa02z7Zko6dtVP6uWaltPgwob+3H9M0yeYLuGFEnKh0fI9sqcDa9RuYn6/QaC6QydrYjsG3v/8N/uXzN1DOlPBbHkkZjHqCo2l0/ICq28DSc1gZgehoVKIWWUslCjwKGRupmdTcmHYrJNYadEKP+alxMlmDnGZQ77RxNA0/8tGlQMqIhtuiWvMwFEFiZBkcHqWYG6Y1Pcvqsy7nb97xTupNj6MnJpmeqPGd736Ixx8eY8EbZ7QrQ2NiPyOldSw5YxMHnSbd/aP840e/h9/y2Hd0J7NxiB5JgnqNsUMZnnj4CUbP3sLtv74NbANJF05BT3FhIkToWeY7dWxTZaEaULYdTvlzlHQbQ1XwPA+huQjdRFUz+L5PICWKXsaxLISSkGgJlipoNeroVoZiVwapmzihg6E7JHHax21YWVzfw7IDOm6Ip0gcTcMyS4gozS2YigEFBxKBSFJalILglddcSL3ehOP3/rfn5fNi0hZCSAGMLOll/bqNdPeU6esfYmZqnoHBQdqRDorK/Gwd1bARBhQLvRSK3RRyvWSLOr19ef7w2x9Typs05ufYv2s3x48fx2vX0RUVP0z9j7FMiBb9mEmSoCSSMFTxYgXwEagoqoVRyDLQX6a3rxvhhYRtl0QNiIjwlRjHcWg22yh+hJ3JkQAdLyAOQrKWnepgpCEXKYBELDoW0qIlb5GS7rpu+liUaIQRCKmkFBhFZWhogA3r1rFz53ZKuRzf/+FN9HeV+OINn2Ht6n6mjuzgmX27mDk1y/HZNlrio6CSBD6xANdLcANJqMT4oU3o61x81T/yrjefz9YXXUK3CQTQu+wlXHz6Bfz2zi9BpIKSgcRANXPEJDiWhZTpAktKn8ivI5MOQkQIDBTbJk5AVRSimHTPIKx0MafkEcJE0R1yRUlt4WnwaqgSYiwkHYRSAhKwe1FVHdu0yNg2jlkgTiSzUw10zaZnxUqmJhos3bwFrXmSrN5k40iEKWKSUGPNmnXUZmdpt5usWbESx7GxtPRA6xnoQZcS27Yp5HtYff6ZzC1UOPn0Phpug0iHrnyOVSs3UOrrB9+HMODEvsPsP3yUru4e1qzdyPLzzseNQ849+xyyXUW8TpOW20DTNBqVCu1IRzVsBsu92KZNy5vCcxvUKy1y+R78MKSnKCllYGz/o6xbtZLKXINI0UhUSSIlYSLxOx6qbhJHgmqtzcDAEIZuMT03i6ZprFi6nHJfL4kUZDI5GvUWA0OD5HJ5xk9NMDE2jttyMUvdXPWGv+Xqq66hO5djuGeIdywPqdc85oXJjB+y4sWX4RsmzcRk47KN1BsGP7n5x5yxZSVF28a0C7heSBD4bFi/kmZ9iunpaVTNolJ1ma+7CEVj3+5dlEdXcHLfXWgiYduFL2S+3kGLVbp6hnjwL79k7eazuOE/b6bSrFKbnmZqqsrpp6+nu6uHr37u00i1TU93GWMOBkp53v6ud7FrYpy5rh5yXV1ETZ+5hVlWrFzH7NQky8r9fP273+d9//AO/nj/w2y78Fx8N6JeWaB2cpr5uSp9w+uo1juceHY/lmUx22ghZJXVawYIvZCpyVOoagriQNNTVGGnjYwS8tk+spkiExPTKEKjq1RKE5SmSqgAsYKmASrUmhWESIlPItHpVGUKN3Ey5K0CkzMHiQMfw1QJvTaKF6PrOiqS0O0wNDSEaRo06nXuv+XD/+2k/bw4tIeHh+Qb/uYNhGHMxPQCYSwQpkneKpLrzpIpn06+WKDc1Y0feriuihv4RKEkil3ixCNjx+x58k/knQBLBqiKTc1PkKpG6HaQLQ838NEMnY7vYRs6hqYjBYSxQsbpo+O5VOYXUFUdRcTUqhOU+7vR/JCsMHEJUE2NhUYFgIKTJ/B9FGHQarvpI3OcoAiZFjWFIeGieb5QKFGtVp+z9jSbTRQlDTNIsZg48/10MWJoVObm2bRxA+Pj4wgRMzcxQ29fF1rk05yZZt3qHnpLGfbsPEHeFOR6HDxPohhgqg7NxMfMqLSbEX6oMRO2mJ6O8GLJs3MV6s2QfUclV56X5z++8DW+9uWvI+I2tpkFs5sEk0TqREmIUDrEoY+hD0ISIKRHLBtEbiVFcLE4XauZVNyVGppVwsh0odhDCD1PkBTQ9QVaR+9DkU1U6SEMGz+oodkDKc5Ms4kjiRLGxH4EkYqqmmhmHtt0MJeuwra7kYnP66+5gL58zHe+/H5OnDjF5s0b6C6UWd7di2EZ6EKh2Wxy5tbTqLsuQz196KbGQN6i6TbIZ7I8s2cnUiSsW7MyXQgFku5iP5lsCc00EJpOn52nXfXRhMKhgwcprN/CmvUbeeipR/jaf3yZ3zx5Nzkjj9GdZenoKlYt6aav3M0vv3cfmrCR8V62nb+M/t5ujh+LsMw8l1x9IT+/+VsMdpm0Gg1KuT4iVKqtBmEUMTk7TyaTQUqB7eQRGKi6iWla5MtlhoeHIYbx8XFMw0YVClknrXn1XZeM7XD11VczNjHGjd//AVa+yIXbLuCy07dx/Rdv5PrmdhaEwiOux+5Zl/XvehcLQOyUGOjr4rIXvIbP3XA9eQSmEnDoyEEazSl8t06pVMKt+awdvYBIhJyamuP008/klddezvBIgf3H8/z86x/jgYfvYMXqM+jvG0LNFXnwL/fy3o98gtPPORdL0wiDCtlsL/1Lytx71wPs3fsgYezyutddw/mbT+Nfv/ZD/MosmyqCy1efwZrXvo4H5mc5lc/SqUWE7SkaCw1U1ePEsROcOjrGzr1Pc9XLXs3KLeuZpcOpg0fQ7UGefXQ/swsVTDuHWuhFbdbpKgnalSaxiBns7yaJPBRdQSgaCBXXm8M0NVrNJhpm6l4KIVisb+0tlgnckEzWptVppsNN3kHTFDTDWgReWAglwHUX8L0aJdsh8BVUrQfNKFFrNVFVFcswiQOXVrVK7FfI5zLcf+snnt/ySNv1OXSigmk75MvLyWSLFMt9lEpdlLpLeFHatXDy1DiGrjM6spqTY2PMTE7S1V3ANmz6Sjl2eT7HTh2mO2tTq9Vo+pJ6GOF7HXKK8ZwPMwgCojjA1HTm52pkHIfjx0+iKhqImCQOkeisWr2C8fEjJG6EEqskMiCUCRERuq4ThiGKkJiKhpSCIE63w2bGWCST/5WUodNqhnjtNigatuNQLpdRVJVOu42qK8gYNKGQK2QxdZU6PstH+xgZ7OLw4cOYesgZp53D5lWj1E7t5gN//3c0Zo9zy00/YftDJ7jnUIduVbJ2YwGTmC6jm9lKg047oRbW0VQVLYH5OSiXuljZ7eErJt1ah0jOMto/yvjUk3ihAtJEURMgRihi0dqX1kgSJ6hqmEbV9QwiDhCJBCGQcYxCAkREXoVYJjhGBnSIZIwmElAsRBygaSFCTW9gIkpIiIjDGEXTsbI51JyClCZhLMBLqDXqyP3HKQ4LugZsDh/Zx9MLx+gbGmbb+edx74MPcfj4GJ2RZRS7ShRzWUxNZ8fefRQKBQpODtUHz62hAPO1Bn3FPhpuk0alTdEwMQs5dFWgKgmOaaCaFtXIo1pfIJAxMzMzNMMdVPc9w/kvfTEX3vl7rnv1G/jB3b+l7Hex45FnOLCzztK+fkhshka6aLaKFEvdBIFHu+kReDHjxw5jaRqe31k8nCWItHi/3NODZjnECUxMTNFqzSMwcXI5esoObsdnYb5KpVLDcRx6e3s58Ox+BjcNks/nWb50KYHnMzU1RRiGrFm7ikiqZByLmZlZhvJFdmhdVF2fE7ksT86ewggC6mGM3Za0alUU/062btqEGjWII4WzLn4JTj7PyNAQVlRlz64d7N69lxOnjoM1yx/v/ha33v51dGICFfpKIwgFWl4Vnx6m9++DYJ7uweXUWm1GerIsTFdxMgUUCbuefJx6o0KrNsGZ2zZSdPr42ze9iltuvpnTN69leWkY974HuLB7hDvDiBnbYX5ilnaUEAZNYhnjBQu89OIX8/tbf8j7Vn2B/QeO88juBiu7clilYV7+gnMY6VdYmxV854HDnDo5jdNVQo9cvHYHpE/cicjl83SCKp6boEsdJbIwDRM1EcSJi+PoZLMZsrpOO44QSkQ24xDFMaGfQKygylR+9UUabc/qg+jdWwndmHYCCzNNyj1lSqWE+bkqqipYmJvB0gTnnLuNZn3+fzwvnxeT9uiK9fITX/oFqqITJJJGq0ngQqC0cduCoukRByG5bhuTbt731hfw6jd9nJE1vVjaMLpu0FMoMX7sDvKmxBYwV5lDN3KcXKgQixi/7RPLCBEnREGIokCz3SJbLHHqyDFGB/uoVCoU8t1U5qr0D/Vx+Ng+dF1lod4gmyuSJKmBXrfTO+rxk8fI5HMUVEHouSRJRKvTpjw4CIqCYRhkMjl6enpZMriUfD7/XGy11kwfqW3bpNVqkTR98k6GgeEems0m2YzJ2MljdPf0cv0N/0GmbPHCSy9iz2P38aUPvJUeM+Hp++6gNldjVe8ZiJFuNEPn+PQk23cc5u69U0gF1o6WURQ4FepMT8zw6a/+lE+87w3ESmrCq01N88b3fZ6xZydZ2zPO03sOcbLqg1HAdnoJohiiOO1usCKSWEUIF5moqVUsbKImaXk+ik+UeCREizZBBXAQSgGZtRGiC+rjKLQZzYcEsWCsXSVDhgSFECv1zRopfFgxCiRSQdG6SHSFwSWbsJwSew8/xLlbBqnPHEP1KlSqNdAt3nzdW3nsz3fz9J6n0YWgmM2xamQIw7LQREyppxsblaHBfuI4pDo9ztKhEUpdBTqtNiKOKJe7GRoaIJ8vUigO0G60OXDyGP/++S+jFjKcVS6wbu16iv3DTFUrnPHiK9hw+WUopqBnaCvzcydJwg5Xv/79XHb5ZZx9/hqeefoJ/vEf3snf/+0/cPFF5/Pvn34rti3wWzNks3lkbBAkgvGpSRIBsVRQNYM4FoRBQk/fMLaVQdHS74cQCn39g8g4wWt3CAMPx8kShiHNeoPR0VHmZ6cZHRjk8mtexpe/+U0W5pt88VP/xiMPPs6Oww9zdP9h3vix99ERRS669NXUF5q8/dLTcewMkVrHyGbBDWk2m0ipY2QzBM0G3T0m1XaNcv9SqrUZckYB122zak0ZAoUlAz2sWLeVP/7hd8zPSmIpeMsHP8VFl1xBozHD1rPO5K7f38WyZX1oicEvbvoR80Gd4zOH+cNvfs3kwgkGl/XQTnRWO/1oT+9g7M8PsmZfExJB54orqa0dZZ+RpRkHvOrlr2TzpVdg4fDITe/g/dc/xKUXjrBvLGFh6jCqlmfHEw/z4F13oJaHiU8dQMlluOod76J2bB5kRDFvIReTwpValVjGDA2sIvQjVMK0K6VTx7Es/CjAKmaYarrEERR7Bmk2PAzDolgqU6nU2Lt9PwUzYNP6LMNDS3jzW17LxuVZukiQUiECFqoRT02qfOITX2Cgf5jEb9NVsHj0L7+hXZ+mOrHr+T1pR3HCQtsjajTwkgSZKEjNS/WhrIbvpcXp7VZIsQwkCRmjQyk/QkAH1VOoVecZHx9neuwIDhIMm2arzroNazk5MY4bRjiq+dymGKFiqTZjY5MYGZuHH3qS+YVZJCZ21iJ68mHyPUNccMFmugYFGU3DRaKpBl1dXSiayrqNqxlaMkRzbpacaWJaFjGCoWXLGB0ZJZPJYKomMknYf/gQQ0NDHD10GF3XEZOnkEBlvgrAylUrmZ2cYPfu3YShT8Z2cL0mBw4dxTBAdTQW5qdJwoQlvT14lXFGh7tZNroUv2Pw4FMPE0QRWzdt47WvupTh1YfZvvcwjx+aR89C3unHj+Gz//xVqnPTLOlTUAyfj/7rPVzzkiuY1ltsOW0TfeURfnD7bcRhDRHaZMwsDRkhNBviKppQiAIFhEIUt5FxynhUlHiRAbmIKEemdHZCkrgFgH5d7AAAIABJREFUgUOxpBBS5LSVq1leSJ0K3PFnXn35S+l0PE7M12g0GoxNjxN0msh2h0ymhOE4uL5genYCpRCxceNGJib2YKkJMtEZGVnDgtth+75DrD37XIbWruahhx7h6JFTdAKfvGVhypjCfAV0wXyzgiZgoFCg3mlRKnXTcUNmKtNEikRGKlbeZ61ZZHjZKl5w5ZWMjIxw9oa1fPfWX7J+114GV49QyhapBBG1ZotbfnILr3rzm/jS975L97KlbFx/DmtLOkKNWL3q1bzghS+nt6QTTs4ggEwmg5Ptp1Fv4bc7uH5CubdENleg1oxotTp4YUDWzuKHPsVSN67rMzdfp6+vDykFUii4kUdffy+xH9NqNFm6eiWhSLX7IIzYs30nw8NLkUaNp44e46vfu4G3XPtBXvPqd3DX9gdohIKrrvk7zEKGBBtsBVPoWHkLy8rykiuvYWp6jN3HKuTyLSJ/mqxdYH6mRRLrZAo9VGsB9XmHWmWW3U+PI+58HBITqfgUe7ayemiEY/sPcuYlWziw9wSKDmOnjvHMkwc5NDXGVa+4kugRn77eLuaDBVCzaJHPrtZJLli7is6D25FyGjCZ2f4kg0lE2D/EkiVDvOCV12GYkmyS45pXfIFHDuzk2185RBKodK1aivDaNNtVaI8xPOQxblT45L/dwNEj4yxoEbLTpN2JkJFPGPqUewbw/CZzcydQNA016eA32yQy5uDkDOdceh6HDs6S7xlheiZGqiaR4tGcaLD98V1ccMGZ7N91AyPAkb0Jh07sY2bHHUw8mQKhLSXgR3c+ziOP7qRTH+CCa17AxOQYA3mHP991J6uGuqiqjf+RrPu8mLSXrtogT03pXPPma1m3cimRIjB1HU1RSaIIXc3SaYfExBQKBdasXUmr7TE1cYhOM6ATujz79HY++J5XcfF5Z+K2qmSd0iLG6q9Xqr4CizDZ1G4TJyG57iU4pWW89a1v4wPXvQQ9UXnsmVne/b7LGKv28dZrLyMOK5QzZRSh0Wq1qNVqbNq8DmyFkYEh3HabZw8cAqHhZAoEbsLAwAilfAmShD3PPojrujj5PMePH2fTxo0cOnSQbD6HbTl05/oZG5vk4OHDFDIOuqHgtips376dV77ylagypjo/xgsv2Mq6ssv4kV0029NIKZiZUXESWLZklEx5gBMTc4TFAb70nz9nsh1QHigxO98g6UTYTher1lyEXcizYvUqkiSm2m5x4JmneOcFq/GRPHV4Lw8+9gRNV0cxiyiyC0XYBGEzDaGIv4ZvAkTSSQ/rxeyMJEZRZEqiUSxICqhaGT1Twmsd4fUvvwLNPcmKgkcYxlx/ywN8+e/fRtbOYtoOpXw3lpkhEXBgbJJT41Pcds925loVlqx7GaWhC+hdU8Wf28ddv/wvlg8vZe3GLWw/coBVq7ewdM1SThwb47RVw9Tm5xBenerMLLu3P0mtUWXzpg20FqbIO1mW9/aSsR1Wji4jiSSPPvooXlDnrPPPxYoM1i7bgKaaXPkvH2D/jj1sPvtMYkNlbf8gQ5kc80ePUcplOW3LFra84BJeftkVHLTy7J44wZYVfUzWJrjg3BeRU8Gtt7EKNn/+xS+4+Zv/Rhg1abnp4srQs3iBj6JDs91BUQsgBXEQ4wUR5Z5Burt7aNRb5AtdDAwMoZkWtVqNqakJKnPzjC4fZah/gFYcUOjpYfb4FAOOQbXWoLRyLYOr13PmhS/kyOwCvbbFs3u284d77qB/yVo+8r4Pc/qwiq6k3xcrayOaMaWCyVTdY9tlb+DJhx4jFj6qXCAO2yxftQ7Tsum0BJaTw/MlJ8eOsXnzZiQNZio1Xn7Z6/EQ/Pi7P8awHLZe8HLWn7mCF567iZ27H2XP9me49q3X0T/Yy8o1wwRGxNjCBMsGhpidnMTq6aEatFip6RRu/zOTt/2RNWIFSbabU0vWsPTSS7jdnWPz5kHWbH0NfXqF+fnd9C9ZxsTBQ0RJB9QQQ9gksYteXEnkugh7JSNbLmTT2euYmq7R6yQkUUDWyjM1PY2KTb6sIaSKESccPb5Ay2vQkx9l39FZ6rUWydxOFFPwtg//E+++7ko8Aj7z+c/y6C230mocBFWBuISd01FlHl04hJqNqWaQvVk0qXHRC1/Mjp0H6cuY5EoWk7ML7L3vW+iGRhC0n9+TtkSieLtpN+cR6mpyjgGKDzImiCQZM9WM+/p6iEKXxx+5hzDQqMyMUZ2vcHD/4xzet5Off/szPLNrL3+683ZOHTsOkBraFQXPSw8ahbRpK4xTSrMmDdrz0zQXZvjGV6Z48E8P8sgjvwUxR3/PeVx37YvpL2Xp7VnO3j3PoKoq/QODSELazQZBS3LTt77Ppk2bKHR1kc8VqSzMsWnj6bgtj317d+JYJgQReSfDfK3BuvWbCWPJug2nUavUqVQqPPbAHbRaLSr1Cps3riJBIV/MEoYehw7tZ2hkCc0g4ps//Dlf+ed3s/7cJeQdCEOXdlLi5N4nCQOXeuQxsnI1z56apFn16BkZxLByRFEVYkl3r8n+Iw8wum4Vrf3TTJ6axskM0pqr0tfXw/jsLKsG++h54UX84vb76HSqGGYubYlDR9Ug+iv1QwJCQxEJUkbPEdZTBLuBpmVQ1CxZy6RSP8ySZUNcdcVWHr1zmv5yjmOH0y7uvGVhmzY9PT0UC9203ITu/n6GV62j2e6wdPVanty5n1/8+SYy8+N88m8+TmOiwJkbt1EudNHyffKr1nHixCmyGZOufA7XdXHDCEPqDC9bxdoN62m323z/u99gy8pRVF2j3nFpdNosXbmKnr4yfctWsO/Q0xw9MUG3VcDKzHDaGaczec/jjAz2s2rNCg4ePMzh8ZMcYjGNXOnw8L13c9aBPRyf3selr3g7m0e6aLUX2DQ4wm9/+isevP9R4khycuxJLt1yNm6rghAJlmZiWBaVaotWq4WZNWk02tiOlTqbhEq+WKDRqNF2O2iKzoYNG1FVBd/voBJjaSq5rEMuY1NvVFmxfj37jxxlyegSluTyNHfvRlVgeLCfHbt2EguF6bjFyi0rMB416C93c2T/DJ/5+C9BDoOYxWvrKJpLZuASpLuXybkJbF2n1TlJoquomsaJY4cQqkoiLGQMQ8vWozsGiUh44aWXMT1TwU88am7E6z/4frY/8Bi7Hv8e07UL/w9z7xkl2VmdbV/PyadiV1dX5+nJWWkUZpSFECAskYMNyCRjgg0YY7AteDGZ1wQDxpgPDBhsMAiRbCFQApRzGKWZ0aSenp7pWN3VFU8Oz/fjtARerwF/6/1++KxVq7pPpbOqT++zn73vfV+sH7D4+U/u5GOfeD8d6bNuyziBiAmSiFKpj8V6g7JdRhUm3cClISRjl13EcJxQ//HjDLYUSvlZFn/8Q0bP28Pk4Vne/cZX89lPvJncyDCWEhAbRfRAEIuAUhwS2xVazjJ95Y284qo385Nb76XTC0jDJaQ1ghMmNNxl1q7fxqHJ/RybdHEaK7RchbixgigM0ll8ijW5kHMvOJ/v/ugfyAOzc0u8+i3v4cEbvpglLKSo2jBDo+up7DqXdcMlOjKhQA5LKSDyBY4fq7N9fBf1aB4VlcmuT/P+h7nqTa9i+egOFk4e+a3x8n9Epj2+frs8/9I3csGVz6e9OEt5sEpjoYlm6HS7bSYPPEbk9njqiX2s1Bs0lx9FkCJROPOMCzjv4h2sWz/Ck08cpK+vj06nQxRmPhY333gT9fryM1NGv3Kby7Ys6wbVhuHh9ew5fw9rJkYY6qtg9uXB7REi6c/XqA7ViKKYIAhQFIVOp43veLQ7LSAlDDMvB8O2OHn8JI7j4PldkiRmZb5Jo9kmIpP2La900U2D0zZsgDhmzcQQnW6T9RtGCeOAO++5G12zaLV6jI+tJ8ZjdmExA+q2HVw3yMg0q855hhJjGuCHGkki0dQE0yrQ83vsOX83jz/yKL4boeVKKEaF0TXbyNn5jH5OwsrCHC/9vdNQgxDb7yHikKm5RZ6cmubAUhehaSja+DP2lCkSIRJIVTKqk4skQqCDsFC0vlVFhoOdS/nRv/+CvnKDW3/6LY7ufZDda9cjpeRPv/IjvvHeP8OyChi6zcDoOFr/KKZtYQCmqjHfbLJm/Ub2z0uOd30wVNRcHqmrmbTR6eJ0uwz2mzz+yx/RaXUx8mVWGj3a3RbjY0O8+EVXUl9a4LmXXMCfvPYPeeD+e0mTECmy4PtMVYdMdgkpF2zZzvnnnoNmGrzyqldzw0+uox60MTWDSl+ZNE5od1toCE7M1lmYmeVEu4PjeKzty9NxPfZPznDF81/K+RedzUrrCJfsPIXPfPRqhkdH6PY8whgSKUkThUim5Epl/CSD566srKCoOo4TsH7jJorFMosn61l5TlFoNpsMDw+Ty+Wo1mrUFxaYX1zg7AvOpzFbp77c4fzde5DAmg3rUEsWub4+0iik2/b5+V2P8fAT+1i/ZYKFI1Psv+tmQnz0POw57xXcessP+MuvP8KX3vd64pWnQEkh1tBVMLUEhIUTGQhLMFRbByLm/N1n01yaIfYCmrrF859/FWeddgqmMcbnPvkx7rr93/j2d29h94Wn8Yt7buGFL3sxk8uTFKolhJMisCBJaQc99DBleGCItuOgqCrbzRzx/Q/y4A/+g0udHO7gMCKoYG3YyXdPyTOnS6794F+xONegl4Q4J+8nFgboFkIT4HaRuRr/ctck05MrnDg8y+D4APWZKUylCKHDFS86i56f57FHfooqVSbvuQchNMJIstJ4hNlWj9mZAH/5kczGmISv3HWQ2ZnDDJ12JX3FGGtI4+F7mlyxQZAzyzx6OGVqOuTLn/oc7eOH+LvvfoZN2wrI5QPsOz7MdT+7Fn/yNp544GFS0UXVbOKo+T8700YKXvOGtxAlPdz5Feonllmcn6Td6nHwiX0cOnA3kb8IBJDqPPtZv8e5556PnYfN60/lsSfv4Kn9hxCaSi/skKgRhqXQXFlh646NjK4ZZGxsDaVimfHxcQzDYGhoCNu2yZeKFAp5euFJZJIjp9q4js+xk5M8sfcRbMOi3Q3wuzA5OUmn00E1dHq9Hp1OhzDIllYySRFKFkMN08wYdFKiaRmcNp8rU8jbJJHLzu1b2fzctfi+j99qUbQtSn0ljDUD5Msm9z18N9U+mwSd7Tt3k89V6HZcWk2HhdlZxmoDFCeK5HM6hUKBopWnF3Xp9Vx0oaIbNrP1Fn3VCg88+CjtxjJJqqAIjSQOSISD7y9zxulb+eWt97Jz4ybqScgD+44iIsmONUNM7juIEzgMr1nHyeXHCaRHkjhoqkDVLWKZkqYKabwK8pVPZ9mAopFEGY1ds22GRyf4+y9+msbCfiZKGiVZyqbyVk2k3F43I8+XayhCw1BUkihGtyxM3aBaLqErJg8+dQtPLjmUioOstFdYbKxgGRqjtRqWaTI3lXLtdTfhNhvsueh5zM8u8ulPfgTP7XHWOWcBKUszx/jjN7+Be++5g4svOR8/9MgXS8gkpT4zT9fzqZ+YRdF17j76FMMDA+zcdToLJ+f5xd13E6YhimbT813CyCfyPXq9HkGQYCgSJ1Up9hW4b98cUgkxLJW77ruds3bv4d77H2Z9/xBRCppuESQeYZIQxgl2LkfkpZycnUMKjXKpgqHaBFFMuTRAGoHT9vDjFDfMfEA6rk85SlDirPUbSLjkkmdx6PgxYj9goFzAc1dwogRtKc/WsXMwhM7jR+9F03V27Jigf8DiyMGjNJemiaSPhkpl7Qj7jz/KF75/L4/dcSPx8lH6rAq9qEEsFGKhEwcOkgA0D+mplGydwaEh/G6L5flFAjVgdGwXS/PHeNX7PwPaU7zwtR9H4HPT7bez5M9x/nPORypQ6qsQBgG6omVDVYqGTC0SSxAnKWpfCRlHPNqe4bznns/uUpn5f/gOSdxmNKmgHDjM+lPPoVdU+OQ1P+bvPvq/+Ye/fx+HDy3ysfe+j4fu/C56GPP4TJ1Qevw/t59kw4YNvP6yNfRkk43uIOmaPDYp01Md/uyVf8z0Y98iTVUEGqmsIlhBCh1DLRDF86hGjZ3bN7DrhX/E7124BaW3mbuFoJJPmZttsmlXzK7yAEHi8IG/uY+bv/0V1p51Ke/52Mf48F98mIKzj92veS3Xf+MW4u4JpHGYjecUmZ0C3/UzBM5v2P5HZNrVwRF52p7nMH1sksWZ4/ieQxr1UFSVnadsZ/v27SwsLNBYbhKGIUcOH37mtYqSEU+elk0Vizb5fA5VVcnn8xw5MoX8L0yzns64xWqyOjAwgGnaPPvS53Le+Rdi6Ar3PXAbSeqjazZxJPA8jzjORnwdp7v6+yogIIqIoiibsvQdPDdCCEm31yaJJYEfICWMDVQ4b/dZWDqUbJ2R2iCBKjh2bI6j08cYGhzH85aYmJjg2z+6kUsvugiha7Rbyxw+sh8pBZXyKEIo2HkbTVg4bhep9OEngpytoxsaUdCl016h013G8VxEDDLNskhFMTAqA3idmIm1o5w4ehhF6Lz8NX/Ek/seZvr4cfKWzU+u/RazJyb5wt99nEarwaETLRTNIE4TFMUCI4cA0jhBUfIk0gNyoNsoSgXLVLnieWfyrGedh2otMlao8qMvfQHF99m9eQOqpfPmL3+Xb77rrWiqSf/YJnKFMkahSr5cRlUkpZyNi0K+NsBNjx2jN1zAb0U4bgSKhqEaNBbrmEJlw/qNlAsJ/UNV1gwPcPipg/hBF0vR2HfgUaqVEuNrx/mrt7yNSl+JmdljzK/UMUyTcqnEjo1bCYKAwHPpdXqIUJKEEZMnT1CpVhCKgm1ZIASu65OmoOl6Nj2XxKsgZR231SZKQh5/4gA/v/Ue7nrwXt7wypfyiY/8BR9855v5+89/Ft1IkcIikiGzs0skQHVgCJlIlFQShCmFUoVSsS+DyKpaplCoVdA0jUIhU9isrKxQq9XodDr02h1CGVMs5rnkvD1MTp1gZHgcPd+HalgYpT6eeOwIQTxNEkbZBKOl4HZaNBpN1g2N011e4ZprfwJCJcRkfO1OIqfJplqObZs2csE5F9NyG6RC56abb2B47XpypTILC3O02ssszM/gtFtYlRyTJ5bZs+fFvPU97+OlLzmb9/7V1/nmv3yLd/zlVfzpO15HK+iRCEmvu0JffwUlVdBiDU01SJUYNVVotXs4aYRR6ycWIdVAoaQI1jSbdH7yIKX9daRRYG7WQX/JC3jUSnnrpz7B/MM/Qgxs4uwLL+dz/3g1HVng6j94Gxsu3cO7XvYiJu+7j1Ofdwkn9CLf/OTfceM/vQ8FyennvJEnH7oBjIjzzziXmaXDLC206B8dZss5Z3DnTx9i9+nP4q57vopKTKKM8e2DM4Sa5E0vv5o3/8kLeMFlmzj+8BHK5wxz7rotjIpsDfr4vnn27lvmi9+6jRe84EWEnRbvu/oMXv3OL/G1d76YLVuGsZQxVNkkJvqfnWl3u01uv/l7ZB7MKQP9FQb6xxkeHmbHjh2sNDooMmZ0pIZt25y561R27NjBBRdcwIkTJ9ANlSgKVx2zYkqlElEUcccdd+A4DisrK2ianp0MaWbYEoZh1ohMkmwoIcxKGbfedjN7H3+Q6WMzxElm8NPr9VaDfPJ/HLuiaJmO+Vd7gBQh1NXfE4RQSKWNUCIS3eDss3ezdGIS1S5z58EjyKCBMrCNq9//t9x+3y95Ym+TmfkFzjpjJ+NjQ9z30MNoClxw3nl0HY/6QhehqjSWW1kQ1nTK/TqB6zEzO4euChSReQl7PQ8FQZpKVE0hjUDKFK/nQBxwYnKZjRvO4OT8HEvN44wOjzM0OM6BAwd53pUvZeumDYwOjnJsbhHTMvD8AFSVNAkzWxFZQklVkqQH0kBYOjLR0YwYt7XIFVd8kMbyUVpLU7SSk3S7bUpaNkhULhUAEKqOadoUi0V008qU3lFElITkTYP8QAVdL/LAffdi1cYoDw0ghZbJsxJJtdLPtk2bEbpCFPrcc8d9XHTeGZx9xjYW60voqcrEmkFUmZIqKosLCywvzKPpKQXTpuu7LLR7LE3PYRfylEoldEUncgJM22b9pi0kaeaWGIYhuqZj2TpSguO7RDLLnAHCMDMB+sqX/on9B/dz7b/fSLPTxFuYZte6DfzDJz9FIgSVchk3jAn8BNu2US2LVqdDzrLJGxa5vEWr0yOOIwr5MrZdyNQ2UYzneoSOS7lcxu/2aCEolUpURgv0D/Zz8PBhjh07jkTgOD1szWZ0cBg/VZmZPYZlBPT1lRgZreFHHmeccgpOx2Hr+CYeeeghEkHGTxSSxfockbPC9g2nsu/oYe7ddwA/7LJcb+AHAWfIBMMwWKjPY9kGnV4X09Dp1tuISPDAvbdx6eUv5vuOx96p/ahlg40b1lKwbXzpkyCxazX8MMC2cnR7PUoli6WlZTRUJtasY66xjKboqJqOpqsESoJfXEvxBRrHj3yHCVtn3aYJHrvx51zykivZPTbBOe98gA9+9K/RKkOUBgo8fHsTbeIUrvvsjbgrOt7MMdpf+wyT8x2C+mOYW15Pf22MR+/5DoIhZHiAOx/8GUJXkJGgO7lEY/JJIgrcfe+/87K3/z2P7z/IbDuiARw8JNj1rGdz888P8OYXXcTYLgEjg2j+Mg1ljoImuPCUtVy6c4Qrn7eNmbrC8y99Gz+9di0Tu07lpl82mKnnKO98Ec++8FT4yrt+Y7z8nZm2EGIN8C1giKzs91Up5ReEEP3AtcA64Djw+1LKpshG/r4AXAG4wBuklHt/x2fILChmNvkAEg2hgHhaiSB/zZJ5NTg+nS0ryq/e62nZWZqmmU/t6sj60/uEUBGrDnOKwjMNNQUTmYJUEnRdJY3lM0FaUdNVVFHmSPf05/DMcchfyd2eeUz5LwJ9ZiN75ZUv43kveSnn7T6dM0/bzpSnEZtww49v469f+Wy2nnsGK3MnMaTGOWdtZfLYCUw7T7PdIgwjUG2iMCWOVJI0pNMJWbdhiCBw6Ha91Vpy5lqWhtmx+ElAEHgINXOcq1SHGZ4YZ2XFR6QJ1aKJ26ojrSKDY9t44sBhcsUcqkyoz04yODyKQhtTN5g+NgNKDKmCppRI0xQzZ5JKjSjJvovzzr+YK19wOXYhoFayuP6n36e3uMiIJrASlY1DAwyvmeDVn/oi//zn7yJn5RlcuwkUhVyxlum0kSRRwM6LLmFmqcEVr3orl112Gc3AIE7btHpdxjeu48TJWV7zqtfQ7nZwlqZBCGZPHmV5YZ6160bZOL6BH1z3HY4ePEylMsrhxx8in7Nwe61nRseRMkNq6TpmvoAiNKqVKma+hGaYFPJFwtWyhO96BEGA5zkEoUsYZglD4DkUbQun3SWVUQYRMPMoiSQJ2jz83a9wYv4I//TP/0ar02Ji61bml+osdx38OEHoJroqyJlZ9p4mgsHBQQaHxpg6doJKtZ+Rag1d1fA8D1PX2bRpE7Ozs5i2TaVc5sjkFFt27KRU7me+Psu2HafQ6PhUB0co949wyy9+iaYFiFRSGyrQcTr05/pYXl7mez+4niQBrdOlz9ZYDiQbtm0DUrq9ZUp9RWamTzAyNJhNZSoKh49P4XkBPcchkhGJHxL7QebGa9boOREyWGTt9suwJqpcccULePPb/4BmZ3EVQC1IEfhBQDFXQAagaCqxGhP7MXk1R6vVRjdtgijEyOkkioYdw5Lb4vKBQaa+fAMVx0FWt5OEOl+663p+/wsfoJ64fPTDn+fWb38ANR3hde/+ay7akiOxCuw583lsPaWAgYmUAXc3TWSQcvGIwrJI+eF/7GPnntN4/P4Z1m4f5/EH7+eSjQMcmj7ASuM4Nxw6iWjOcvv3/h2R+kixg+2Xv5I3vu1V5Pweu87azLkbyWDV0iLyfBbdOiWrgJIrYGgWIfrqhILCwcNwstHlhp/ewL98/cO06gf/rzLtGHiPlHKvEKIIPCKE+DnwBuCXUspPCiGuBq4G/hr4PWDz6m0P8OXV+9+4KUIDmUNTFYQSARLjmeiYZv9UQKimaJr6TID0g9XAm/5nbOzTAfJpy0P5jP0h/8lgPHMGzSK+ZJXJlkIYxAjUVbN+SFKFOMo0x0DWtQJMU6e/UqJQzJEkCWNjI1SrNQYHB7FsG13XKRYKCCEx9ITh0QkWGynv+Yt3kQI94OezXRStyEQRDk4tMHbGBZw8cRhbwMLyIocOKRT7BlA0DSkM/DDA9Zq4jk8Sq+iGwDBKON0Ojtt5poxjmzlsK0cArDRb1AYzoo2RN0mlIIwF9cUWTtTBa0f4vRyDJY25xiLrt+5i48aNhEnA+vWbmOwrk7dzlAsJaRQzMrKRqeOHCf2IZqOBooDn+oCCaRXJ5wtccP52Nqwv89nPfpq56WPMzc8xVjTYcflFdBbb9FwfKfTsL6UZJKkgiiLy5XLmCxNnqLLx8XGOT8/BwACnXvhcjizO8eCP/5WJi59PX7Wfl778JeiayeSRY4zWyvTCPCfmTzIyWOaVL7mcD37iI/zs+uv55Oc/xf/666vZun0rTz50N2HoUcpbdFwXNbOJQRXqai1eJRUqkVTQpYJtlxGKQalk4TgOtqU9Ux5Jwogo8FAUMLSM8GNoKopukkqJF4fkDBMRAmEPv91i3Ug/Gy45l5/eegf5coWVro+qSNIkJYwlmhDZeako+GFEnEoKpTJmLo/nRvgiZmR4hDAMWV7pYOVK6IZBfbnFju2nEcUJc7N1UBUaK01GJjbSPzDEselFqtU15Astoihi8vg0zWaT49P3cfzECQyzxIZNG5h88BE6oUIaJtx/7wOMjAyxtDJPpVKmr2Jj5/MsLi3RbLdYajZRROYV7UcRIlWIUw1DKLQDHRke58zdzyO0y7zpjVdxyXOegx96GEKl53rkSjYiEeTtPJEfoKlGlmDFCZquoOkaxWIBSzdJFRMnDikaJkVhsrlaYlo65N7+Mjr/+EPycZtObQx1sB+1CiU8ityQAAAgAElEQVQ1x6btpzJz+Z+xY73Gd776db7pTCNkF6kVGbY2sv0VL2bxkcfxmidY8hIs2U+lGlMsFomX91NfyuN5x1HWPJfPpTbtuYfQOEFkbEIEMZ/+7D9y4cXPBlSuO7yP2x53WDYsPnj9Lcx/6xVIRaCwTGgVWaOOIkwbBHipT0HqfOw/HubwA9MkQ68g8X1++o+fplpdAxz8jfHy/3NNWwhxHfCPq7dnSSnnhRAjwO1Syq1CiH9a/fma1ecfevp5v+k9bduSGzdkyClJtGpAbq1iflRyeRPTNDENDcuyGBkaJI5j+vv6MAyNSrWWWUnaFpqm0Vcqoxk6+Xw+I5KsmjfJBBy3S5qmuK5LGMS0O01838F1FxFCEq1mpp7nEEVZrTybAlSRqfafgn4Y+qRpZvrS7bWBVSRVGJIkWc01DkOSKKSYNzk4vUCbAd727o/QJc8F5+xk3Aqomib7Dx3h0PFp3v22N2FLH6/XJT9QZc3YOEudHt22g9eNkFJiWxqgEEUBSSLptJqMjm5C00ympqcyYyyRougGff1DxBJkINHIfKBN22J+fh5L06gNbUAt5Zg6vA8jThgcGmPN+AZmZmboui2CIGHLlg00W3WiWBIECUHYZXCwhiJ9usvLzM3PoCPpy/ezdv0Yc8snmVlYQigKpZKB7/rEIZyxeZTztg/TmGlwxtbTqI2v442f+QI//NhnMDQDPWdiF4vk8hVKdhHdELR7bU698go+/Kkv88sHfsmul7+RP/6jK7n+5nuYP3mSJx96iNbiMp/62Ce57e57OHV0gEp1gJ/d8jOWl+sMjmyg12oyPLGDZ198Mbrd5qdf/ye+/91rqC/OZngHJeM0FCybIAY910eKoH+gxujoOvr6h9FNC9vKsbS0ROB0aaws4ns9ZNjDdztEbgc38FF1jSj0QYiM/q2rDI0MctXFu7lwXQ4jiKi3Vzhj1wX87Ze+xLGZJfK1YZxUIM0cQtHQNIOVlRXqiw10PVOPFMtVRkdHqRQHyOVyNBsrlEolJtatRdM0dF2nMlAl7roUTJuzzjoLqUfMLs9TGRmh3Ffl6v/1cY4dPkSxFOF4HoZdxo9TtGI/c/MLmAiCbhvF6scsDVKs6kRpQOgGbF8/imFJujOTtFdWsV2Kjtvq4PsS07RIEkksVbqeR97KM7puHe9+74fID5YYXFdFLypIFHRVYkmFYqFKx2tjW3nCOCJNY6QqUTUNLSIjnxNjKJmXTOBENF2H2NRZUywSSoFa1Oj5AWdbJR765kPccvdetAt2oK0d4ePv+hDKUA5pu6gR1NavYXF+kuF1O4mXA8y+FCtnshS7mGmVZqtHmkJXCRgeqaJXC1h6ilEu0Kl3yBcTOgsRlVIFTTXQ7TEOPPEkhtXPijuP1utSmxilkwTIjofe6MOTgij1kTLArFWoFPrxpYJmGFg4hLNHcNNFeodOAgYXvPj5WLbCL/7yLf//1LSFEOuAXcADwNCvBeIFsvIJwBhw8tdeNrO67zcG7dHRGp/6zJ8jpSSWGcVB1RIUoSFTjTjK6B+JjEmSiDAIIEmIVhuA7U42pNCbdUiSBKfbI45DfD/MHLmiIPMJUZTM9PzXlB2aaqFpOqq0kElKksRIkWIYmXlRkkgUNULTJakMsxKOEEDWkBToOG4Xw8gQR0kSYWg6RiGHoijkrDxCSSjlDGpjGznuDjFQrfDc0zchFbjpOz/j3sP7ue0/fsBgwWKsP4/XChkYHUYUC+SKfSRdB8+PSSTEcYL0EnRNw3V7hAGEkc/xqRnKpRphJNi4ZSP5Sp5ytUooFR56eC/VYj9qlOL0PKLYZXR4BMePKFQKtD2ftWvXcuSxW+n1ImZOTqGLPI5/BBhh6mjAcmMO0gL9tTG6qxe+P3jZi1AjnxMnj+G3OgwPjPHzO27MTOFFipQpnVZMLq8yXBthZGSIfN4mrVTwg4Dl5cxjIY4TSGNUyyCKEkzTXGX2BeQKeU4eO0lOV/nY165hsnmIv/zMVzh2eD+GkGwbW4Opa/zt334cv+dxw4n9VKr95Ap5jh6Zwgl+QbVcIFH2cvuPf0i51uXAI/tZrC+SL+QJoog4DhACHN9DVe3sOxYqaQKtVg8zF9FxQwaqFopu4EYRcYaWpLmygu920LPGUWYABpnZfRxDHJPLm2xaP4GTTKMKBRkldFdalHMFoqCOkOD7IVPH5giS1RWgEGxYt5HBwUHOO/dC1m/Ygu/7JLGCaZr0lcuYpkmn26Xr9FiuL7HS8oi6Dl0cbr7xFkbWDTG+aYw4jhkZH6PRWKI+d5T6fAoCzD4XVbM4e+vpbNm4DVHWaa0s8Omvf5/bHtzH/37DVew65wz6c2VwGwS9JnovpF+16AQunV4PNQLLtDMIdJiAomDbeXpC5dNf/BwDI+uZXzrO0PAALW+F/v5+lpfr+BIMP0ZPddI4zuYnNA0/CYhDHzU20XI6XhCgqgmqALNPR5camimJ7BBXVTDdgGICx70GJzYM8N5Xv5XPfeh63vemD7JhwzpOGzyTI/vuJCzGxHunOGXNONFcim4a+AePMTxSJbe4Qq1qk6/UePDwIbbkTbrz8+iin6V6g66jMVobYblbR1EjmtpREi9AoDE+XGaBp6hpOaQXo53wWCNs1GaXfG4fLik9pYQ0U8JGlUpujthUEUrKs7cNo61by+LSACunq5iyR/TotVQrfb81Dv+3g7YQogD8CPhzKWXn6fotgJRSiqf1W//993sL8BaAQiHPL257HJkKysXsgNOwi64IcsUcCB1NV0DGqKqa0T9WcUG2bVOplGm3m4zU1mBZFlEQYGh6xmsLQwzDQBUKqdCeoVFEUZCVTcIAw7DwgxhF0QjDbAgnURKiMCZNFRynjR84uJ5K4Pl0Wk0WFubRVIGiwNzcwjNDO81mE5FkkFohBHGY1dx3bt7F5ku3kVNiDtx+N+t2bGZ5rs4D13+dM07fwtpLT8WLNG5+4AHmXJd+Q+HMkbXU+os8fO8UqdAoFoqoSo6BgUEMwyCOAsbGJ7ANycmFZaanp0GT1OcP8rydz2V+YYmZmRWqqkFzcQHbtrFLFoHn4zg94iRElS6Xnn06U9PT1MdP5bzzz2bLpl1MTj3Bjm3vJVco02h4dJxlRsYHaS4u84vrrmHu5GH+9Uc/589f94fs/9mtJPUnmUlNymuHecvr/oypuXme2LsXLQ5JRYqS0xBagt8KaC4tsXl8PaefdhrwHTRVwYt88uYgmp7jwBNPMj46RLE2QLHUT8nWufGn3+GjH/wEE6PbmD75EOtO2YypC6b23kWxWGagVqax2OCq37+SxW6b5zznVXzsA++lWFuL7MvRCebZtXmCKDH5yue/wjXf/xHXfOd7HHryCUhTpIywTJVE+oRuhGLaOI6O6/UwcwHdjsvJw9Dzlwg6PpHvACm6KcgVVOJIoAsF1/cYHBqhsTiPIuCDb385N998C5sHVZYmoRvFjI5v5uCJk4ydsouNuSrPeuHLGe4bYnz9GhQzz94DJ1BEQrM+R6lU4ql9T+FEMdXhNeT6BrPejGpi5/MYScLWapXKcBVd1yH1qNYsdEWgIAkSwcyRHoZaoNdVUNU9SDGDJptEzQ6h6NBut1hXGyeXGySYT2g+eYK1mGzbuBa5eIg4pzMzM4ciDBwHBCGNRgM7n6OXhhTUHN3eCqEfcMuNP+EN7/ocH3/f37DQcFj29nHBs8/NvIBUi3a7SyFXxlQ0PL+HUBUMRSf0o8zxTrNXSVZZ76VolEnTlChJIJT0l6ogU5QgRDgukVYkDQzmZYuXnDOKZsEnv/WvnHP5eXihQ92ZIs7plPOlzPLXKNDpdRGBQFVyzC845PP9LLsOkWkykO8jkZDXoNddplqxqJRTJHUmJgoomkGvlyc/mkcIlVanTT6EOA6pFosErocQLm3VxzOG0A0DEQSYqknR0kGLKEiVJErYP7VApTxMu9mFVEW3c+iFcbqR+X8ftIUQ+mrA/o6U8seruxeFECO/Vh6pr+6fBdb82svH+S8m6aWUXwW+CqDpqvzG1779DDw1DDJfa9Ikw8M+PQGjZPeqIkgSiapkDnqjQ6VskMXzUVWFKErJWRr5fGZmLqVcBcZqmGaGr1ppNiiXiwSORxjGSAmVgSLVWoU0jVEijzgG1/Hp7ysxVBtE1ePMy3hijGGrxrGjR1A0kw0j/aw0m9SGBynmMqMiTcsuEKEfYFkWXjdhZLjE0SNLNPQl4gi6XY8V12dqfgkliuh4MfUVh/7KAPNzU5T27OLgwYMsLfXQ7IxB1+u5TE1NkSSSQt7m8JFJRBowtmEbYUzm/mbZXH/9z7DsAnahShCEFPMFVE3QbbVJ0xRN16n295GmMd/4xteoDY1y5mmnsTSzSHflEZYbizz12CRSEdTWjBN6KU/c6/DYQ7eDgFNP2w35Ia674Rbmm3OM5QdwEx8RROzfv591mzbz6N6HUCVc+cLLueKKy3ngpuswNcFAbZRKX41uxwVgZHSMVNGJI492YwHDUJCaQsePWJmrUzIHOHpknsqWGs5Ij4G1m9h9+tkoYUrqOsgwpn2iTlnt530f+Dcipcdzd/8Bt950G0JTeOcHPsrAwAaiTptD9RmOnzhOuVig0enw7g99CFuLadXnuO/Wmzl8+AiJiNGSkO7yHIKYA8uTmVwSHdUApAZEWKZBqqR4nkc+b7Nl3SbmFhss1Of549e+nE63wcnFSfyuQ4JKV2h4Jsiihc8Qfstk7fZNPLq3Tsw8feWp1ea4z/q1azl68ClUVee003bTX5vIgli+hG5aJDJjaebz+ey8aHQolvIUihr12W7WIFZcnLBDqDksa1Xu3Ptzxio5ikJFtfKEkcKagRp5zaLPsnF7bdYO9xM051mZX8aZn0PLhyys9JChIFUkru+gaSb5vmHCKMG2+5CpxvkX7uYv3/NXfPTjf8N1P/sJv7jzdp5/2ZVEwqfdaZDKCFIFQ9WI/IiEGMvKZ6sHkfEpFQV0XWRkczf6T3MOipLt77RXyOUtVCQD5RrLTZdCf8CQqHHF67/DnTf9gMtftAXfUdn/4H6KVoltWyawLIvJyUnG16goQKlYxNNW+16aCkLFdV1arRaWlSl1dMPA913iVKLqBifnZhlfu4lKbYzpY0ewcmDbBTSzgEwiAicgbxdI4pDBoVHq7RVUQyUIEwK/S6FUxBAqcZpQKOZR9JCl5hKaUAg8j1IxjyoT4vi3g31/Z9BeVYP8M/CUlPJzv/bQT4DXA59cvb/u1/a/QwjxPbIGZPu31bMBNAXGBjQGa+MkUUKjvsTE6CimoRGGPl6U1aCHhsurI+k+oZ+Rk+M4pjpQotMxkUmaQXxTSNOYWq1Gq9UCVmV+cYSu2URRxMSQQRB4NGWC0WfSXylRG6zQV8mTJBFLje4qHDREJBJdj2gtO/iBi9dxyecskljBdxwSVSXwQrqtNm7XRcQC27ZIk4Rms0mlUiGOTeIkx9BQDsdxCEIo9/WRRBGlfIGo16K/YFHJm5ysL3PGKadxxx13MjQ4wkXPOpflRoOFhSWqVYv16zYTRRFL9QWKpT4MRfDE44cwDZtNG7fjeR6dVhvPjUiFh6pldrRKAuVCkQRJGEV0uh6abnLaWWewb98+7rn7DsIgYHhghHJfH0gFv+fw4M0PYxUH2LLzHC59wau55+7b2D85TerNsueiM7l8/Wu47dYv058orDQbSBIOHznIgw/cz9TkUcIwYNumzTwiFISikqLQaLY4e8/FQHahGRgeIQpTnF4H3bAIwhhFl4QIOo0ejhty2bnPY7E1RRopPPzgPhInZLw0jCE1Vk4ETNcX+Oy7v8g7P3U56Ckrj7Z53pUvYUUJuPyFu/CaDXpSxfddgiRl+fhhHn3gLsoD/ZipyxUveBYvNi7jxz+8if37jjM0OMDQUI2r33817/jTd9Bp+1n5I02ywBK4GJaJqgocx+HxJx4nQaG/WqW+uECrNcfg9jFSkU07Ss1EMXSemu2gWVXU4iB+08VPHAaGahw/dgxdickZITlVogjJzu3byFl2xoiw8xQKJZACP0noK2cj7kmSMDwyiGkqdLptLKsAahdTi9BLJpFSRvNzLHV87BxIkRLEKqQpi4uLjGwMIU5RCRAi5BMf/itWGl1GayWaS1PZ6jRWSJHoWgE/jJEixnEcpExRNItXX3UV9z/8EC9++Sv45V030g17JGpAt9tE6Fmvh1iiqILQz5r+um5kpTFShJKtSNPV7xaRzVAI5dcVZQLDFGiagh9I4sCjWjawdYubrpviqcfvo69aYG6+Trm0nmK5gm3YLK0sU60OrCrGFOQqP1JTVCwrGxRzHR8pEvr7yoAgiHxkmpUkozBD7Ek0ut1uZusgIUxilMBDKgJdUTIVm1gl3QcBlmFiGQaJYUIS0233EEpKHCXYOYvhMYvB/hFUoTDd9Gh3Qizx2wP2fytoAxcArwWeFEI8trrv/avB+vtCiDcB08Dvrz52A5nc7yiZ5O+Nv/MgFMFg3kTxOqRBjJH4iMQh8hKi0EdFw5IhSVcjESlxEBB4Hqmug1RwDY3OSockicjn80RRBGlKGkakaZpZpBaLdOvzqLnMyyWIXXK2ARULwzAg8Uk9n3q3Q6lcoFYqcXJqLiNUCyWzyaSH0FP8uMvkU5OUSjks1cTM5ciToCkqMkmJwoBKySaUKYYiUdKEMOgg4zaqyJNGKXEEzZUeSB3fS0jjlERJKfVXkXPzJEHM9q076Ha7PHXwAK22Q7FYwnMDDh06lDUk7TxLyy2KuTyG0UeCSs8F2ywxOt6fNXIkNNst8nYJVUi67Q66aZAKGBoZZGZmhlimXHDRhdx1yy8pVktYRYtDTz1Grr9CrbqOs887lzQ1CIOAvQ/ey7r1m0jROXrwADP1Fdac3k8viomEIA4ktmnwnIsuZt8Tj/Pda/6NJ/Y+yHXXfBcbhZV2B0uzefLQJB3venYCcZqhuwYGBlA0lUef3I8TRdTWlbCLRe6/8w5sVefCkT0cWd6MlnN49pueQ6s3w8c/8iH+8HUv52P3/QU3fu9O3v/mP+Rdn5/ltSMvYpPdz1jq4nptYksjLeTQIx/TNFGFZPsZZ2MXqpRKRXpLbaanp4nigM1bTsXOj/DAgw+zuLzMhz78ERzXz4a4snEiBNl5FcZg2SXOPes0Tt+6lanZWdqOixe00HWVqOeCDqpt01JzzM85qP1r6TUj6ktTmKZN6LkcPzrN6EiZomVTNPvoHyiz5/yzCcOEINGJRUwa9mhPn8A0TUbXTNBYbrJ23RrSNKVeX6RYMjEthSjukEYGillBKBGO79BzJZvW5nnzW3+GbqwliHpYUsnM+3WBmnqU8wpJEnDkyYdQUVGifhAC0y7RWGqjKAJEgNB0Nm3dziUXX0ZfsZ/pkzN89ZvXcvEll7L7gvMob6nRXy3gRl3Mokng+Vi6iW5aWIZB5IW0ehkMt1AoACmarpAk4aoyTEFRstVxHMe/UoEJMAwT3w8xzSKh12OkWOS6G6d51198iOGaixWrbF93Gd3eMloiGOor0ViapyeaVCp9tNpNEJlirNVqYeoGhVIBO2fjdl3CIEDTDNIkQcoEU89gvW4YUC4NMLswjR9lKEHbzhEHAYaioiFxAhff61HMlwlDnzAK8XpdcrYFiqBgmcRpTF+hgu85+O0ehxYfI5czGBseIPQ92p02qvbbK82/M2hLKe8ms+j4r7bL/ovnS+Dtv+t9f30TQhCGIZqqE8tMV22aBlEUYJo6kqwjXyjmcF0X13XR9Uwd4rguXrcDcYQmsgCZBD6KphOHmUSv7bXxggC346BKJfPv6DmYZRNLy5Mzbdxe65nj6LkuF5x+KrPTJ+i02+jFEoZlEktQVA1E5h8yPDTO4sJxvLaXZeRKgmFIdF2QJCGKyPTdaRoSeSZuz0FVNdI4wTBgw6ZhhKmj5QySVCGfL6GJrNEUxTH1+SWEEKxfu4YEg2azhT1iI1OB67rINGvUtNttJtZtI00FpirQdZWVZp16vU7/8CCquipfTAWaomDqBo1um/riPKZusG5inLnZBUaGRplfmGeoNsG2U/ZwcN+91MOUOB4lSmKKfUNMrN9GX7WKZmikuTLHHriL0gUXIVOwNAtpw/evvZZrvnctSJhYO8qfv/vPOHngCHnDIPYExVKJY0dnqdU8gEyTvHou9Pf3UyqVUHQtG36SKWsmtvD6q97BZ7/0acYLZ/L5v/0b/uTtb8DIx9zywxtodpfZPLGDlZllLsHn7OGL6M/7TLUfQbV0TCGw1YQo6JGEEMYJikgJMPDRyds2oaYTxyFpGjMzP82hIyfZsn0Ttm3z+KOPQpqpb5CCnCkJAkiiGIw85WqGSdu/fz8YWV+kbOv4kURRDSJgxfWYbbpoVpVDR04gEoW+UgXfbZO3QNctirakNpBnoDSIlbPxAh8QTKzbSLuXEbwxK7iuRxgllCv9tNoOtm0zPDpCp+0QJxGu10M3CnRDhbxiM1LV6e+XPDULjz10H2ngo4iUFIXEUFmqz7N9xw5Ozp5kevopNAWSOKHdclizbgNdx8Oy+0hiidBU1qyd4LEnHqVaq+H1AirVAc7Zcyav/6PX8s1/+TpvfdbbaC43UHQVZEoul8n5vMAj8nx0XceyLIQQNBoNqtUKtm3T7QbEcUIUPU0/X53dEFkfK0lTdMVEGDqKjKkUK9z9aJd/u+bf0eMAr9tCNQs0OgFR6hPJlJmFGQxN5+j0FBMTE9RqNRorTexVSa5lWei6TqfZJElAxSCJU1zHIVUEiYwwTJtiKY9t5HjheVfyp+98Fa98yTvw/QRL03A6bZASBYGuKfi+BwgMUydNVcIgO891w0ZXtVXBw+pQlSZpNurEbofxsRF2bt3Gykr9/4iRv779j5iIFCJbaqQyo3cE3ZAgjlA1gecEGIYgDH06ncxvOZez6fV6lMtFTENDNQ1iJFEUkQgFxTDRVTXzUi6VSJEQJxiaTjFfQAjBQH+VYrHI4cOHMQ0NM1/AixJyxRJRFHDjz28lChNCqSJSBalqJLHEjzPayPj4AEuNBRKhUCpW6HR62LkSEo04TAhjgaaZgIXEJEm6hJFDyR7F9T2SFDxHRUYJgRcT+AFetJCVMWQ2EXjqqdvZu/cxFEyazUVc1yewPXTDxjAMFuttPM+jvzKM73i4QQhpRF9fCSklA7UhSuUqc958Zq4vQMlZpJrC4MAQru8QeCFuq0MSx/QNjjK2fjP7n9pHqVRi0ylnZxcHUhRTZ7GxQNA7jmXmGVmzjkJpkOH1G7jn/nso2DVCdwkrgjJQHuzj7EvPp9WY4+Mf/js++qdv4MjBJ1HSiHanyRnnnMXCYqYemZo5TpCG6PZ2yuUyG3eeShBHuH6P0f5+fvzTb9DzfD70R6/jK1/7Ep/88D76Oc7yQp0/vmKI9bl+zu062OUchJIo3k/vpEV/qhEWDXS1R4xCZOeQfg/j/6XuPaMtO+szz9/77hxOuOfmULlUQVXKEQkkwBiRjA0iGIxpGoMxBnfbYxqbYDDTDo1D2+3psRljDLZJPcbGGIMkkBASiqUslVRBVbfCzffck8/OaT7sWxd6zRp9mllLs9eqL7VO1bnh7Gf/3+f/BFVnfGIav9Pj+JGHecnl/47jTz3Mjm1V1lprNCbrJMeeZ25uH1dedSmtZpOrr7yCe+65B78XESYpipqTZDl7913B0soGYVZBUwt006KI+yRRB8e0OLu8yNzMDEdP92m1FRxbYbrawLRU5s8+SxAM+alXvYyqU+XiQwfwvRhVHyUVOYUKtl2nFyo4tXHIBbmml5VylonQc0hrBEnO6mKXalVlY1lg2TUOH6gS5QWvedPv8/RDD2KObGfbzEWMzx7iZVd+hrMnHuLIfV9izFZ5/etuIi0KfnjnXQwHHVRFUCgqQVJwZi1mZucuKppJw9XZsW0fP/z+P6GEPY7c9V2mdx/gV37lPXTSnIeP3sv7f/N9bKwuYyhmeR7JClbbZYb4RH2SPAcpChp2lTAMUVSD/qBLf9ClXmugqaKkLNIUCoGgIMtygjhlxK2z0lwlVRIunh3nmeMx7/mFj1Gp5oxOxaTRJIEXoGjrnJ9fomobdDt9JqZnsLUpwuGAk602+w7sx61U0SyTMPDJi5Q4iqi4VYpUJ4pi6m6FJE2JsxzyvFT4RE2+/g/3MzU5xqte9Uq+8pV/4qJdU+RZTN11CIIAWShIvRRB5FFBksZIoWBZFVQVsiwnz2JqVYfYC6k1DEytgaHorCy36LR9alXrBfHyRQHaWZFTSEGcZ+hyU99aFBi6gYwDkCpCqhRIqrUR1tfX0XWdJIUozjH0nEJAkERkRemEDJIYTdM2lSIJ5KXBxvM8bNum3W6jKApjY2N0ewMmZ2ZJkggvGpJGEULRUAyNql0pQT/LkQUYikHsh+yY287x48+Rpwm5Vb5HGCUMvQDbtCiQZFlBRmkEyoqcJEkwDZUkD4kjUGVOnOckWYqUEt2yKfIUQ9OZf36eum0wGPQwFZ0izRgfH0eIgjQrS4p1Xce2XKqVOsMYDEtH5mXJQxCFaKrBwBuSpimGbaEoKmkUEUQhmVpa+TVNo93cYHJymuWlVdyqQzAMCKMEP4hwqhXm5mZYaW4wOV0njzLOnj7PyWefYXbvZezcsRfiPmeTUupmSBOp5Zzd6PL6yQnuufd7vOVNr6TfWWd8tEaSJCwsNrHdydJUBSiKQMicoR8iNB2p6QhyhEgZ9tu8641v5Oz5ZT77B59iZsSht7qGkQzZXzOw04xs0KYpc/aGgjQGqUI/C/E1k6xeg6GHEibIQYiUkizOqVRqKJpJEoVU7AphGEJss3d2hq/9j9vwuhGnn5vH627w0V//D3zxbz/PL7z5rdxx+730O028uEtaqCyurnDDTW+k1zpPgSAN+mWfpqsTx0PIJDe+7BWcXNhgmLi4dYPUX+X0mUVmZse56uvDM04AACAASURBVIpXsH/fQdJIEkY5USxRTBNVM+j6IYViMD65HSlVIj8glhpuVacQkqGvIEXK+sY50GyGocuhizR2TercfleTj338b5k/+RgXXbkP3Sgg0VlZWGaiarL70ivpNB/gZdcdJog97n/gCMNBDyEU0ixDiBRZCJLuOsP+NJGtECc5Tz34JbKkT57FDL2Ek0cf4mt/85dc+sqb2XF4P0kBjuGSpwVJlKEaOk6lSuAN8cMARVEQ5ERxsqntTkiTvFz8aQZJkiKFRpKUiZmaakAR4zouSdEnygWTI3VWVl0+/1dfRTdCdE2QJAa5lAThENsxUGSOF0UIoWAaNqIoSPMMMxcsnF/ErVYI0ghT0ciS0suRpimhH5HHObpeOqTJMpAFqRD0Bj5jkxVOHDvG29/5Vu6662Fsy0TJfQxTxRt2KYQgCVKSNCurC/OcXOQMh110XUfTNHTdZjjsk4Y+pmNTkBKGObVqgywr0NT/H4A2hcA0LIosKx1RhSTNczzfRyoaYRyRK6JUFAwGjEyM0e12qY3VSTZSDMMq40hlVLZ5WxZhHBDGEbVarXRP+j5kogQzTQPKbI52e4NCSJZXl7BtG9PUyYqstInnBZ1uB8e2MXWLNE2J4xjXNjl37hxXX30t02MTfPt738O23E33ZfkQEkKUcdNCUAgBRsagFSFnMzIxwB/kOKYkEoKMhHjogWqQJKVBQwiBado4TgW7XsF1qvheOUWvrjXpdvvU63UUqVHkktm5CbqDIcvnF1FVFdtxUDezj23bpkjLZmhNUSnSDAE0ag7z82cZqdU5d2YeDJvBYIBhWUSeh1IFr9fl8cUFpmZmqIyOIB2JZAdSaAziAc88Oc8lB/ehItAVhWYWMu02+MQvvht11GZ1OeD+H36ff/6LP0FVClTTYt/BPaw324xMjgNgOTZJmqFaGmEWgWah2VXs1OPQgYPccsONZJHPdlTGOqsI3SJMBAzL370+NYoVZfiKTm+YUBSSEZmjJDqFqDBmKozO7qPQ1umuL5VqId1g5/5LGHQ7zO3Yx/jUDkbHHWoVBX8YI5AU0QJFc4I/+vTvMDbW4Mtf+AK//pHf4R3vfAsf/OBHufGmV/Kf/+TjrJw8j2IVjE+N42oexqhOZ+15NMXiDbe8liOPPoF0trFyfomHH36A97zrFn7u1vcQpxGDYcCxM+dRrRHoW6hWg1OtLqrUuOjAxRRFTi4rdFoh3W7Itr0muuXQHQQYjkanFWIZcxzcqyKEwnXXvBxv6TTK1CFGG1OYtRrryxl7d+0kUJfZMZfRXouZsGbZu2cft991D8tLLYDyPkpy0qKgKODwNa/GHZ1ldbXPz7z1jZw+cYyxxjiP/vDroKpIVVKECrd9/06eO7PIt+/+Pq14SM3QyJQUMkGaZ/hejGFU6Xs+WZow3qghVQU/9DEMk4oiMXSrlOdqVhl9nKvESYiUgrxIGAYJg67g8r3TNLvwc6//bQbBIjPTBV6vwJCjWNU+vWGM1+uSRjEUGZouWVo5S7fXZO++g9iWy8lTp9EMDVVTGR0bQYqMXjcg8MJSsWKqxGGE1DQMUyVXCmI/pF61MJwqd9z+ZT75qV/j3e95E1//4pfYPtPg6aceY2y8Tp4VGJaCmkGS56hCIcsERZHjex001SAQQ0ZGRvDTHp2NDlKCa1cJ4oDRsRHWmqsvCJcvCtAWgFJAISTRpra6zAdJUTRla1KO4xBdV/E8DygXCUmSEPpBKa3TDdI0JQpC4iTBth3iMCGOEy6oaCqVCoqqomQKnuehagoFYDoGSRohFQ1RQBLFFEJSqTpEQUwQeJimWU7xUcLIyAhLKyvoqoGmaQRRgGEY2GYZHHTBPp8XBQU5ueLRbnm0W31qI+V7DPsZ0tTJKVCESq1aJ0kSCk0js0w6RYZSc6lWbIpUQ1XK6VdKFUUpGPYHVCo1wtBDD0rd8M7du2nURzg9f5x+v8+O7TuJghhF1UtqyTJQRamuSaKUWq1CxbZQVZXt+w/h93tUq1VarRbrq2tMjI9T2bEDRaqcPnkKx3WZnNmGplrErTVWO+cJs+14iY+rZ+QCPvPHv8e+Q5ehj41x2VVXcPTxo3z4515OrVJh6MeIJGdktFaapGBTjmluuuwkQlUJoxTHchBCYGcedXWUmgFRmuElIboqMAydQMlI84ie30NVTCy9QpFlGIqOX6TE3R7NXocvfumbNPtdbvmpq7Fdh8WNDZ5++kkG6xusrqzw7W/8cxluk2Xs3T7HNZdfydFHHqK3soLhWqy2+gxVwcSlO/ndP/0cdz/6ELEGFLCweJx3v/fDPHDk+9x9322IzTD8g3tmOLXQBq3C0uJJKkbMB957C29/8+s4v7BGLxCkWY0UgyiuYbmSXNPYu3M/q0vLLCws0W0nXP/SUXYfkJw+oaIqFfr9DhvrMdNzEq+fsWuPzkOPr/HJj32GfKPH2PbrmKlKlvqnyRKTINqFauhYWQtdG3D44irJ4Gm+971/I0slmmqV6qoo4EKMz0tueCl+ovDR//hpPv17f8Rf/pffJxuc4Q2/9DvMtl9K+8R9BHGK7kwxWatx/myTq3ccIErWeDLp0NvoYRsuhqGTpz6KpZHEgjSVpJmBqoFhFcRximmZZUlJBo7jQpIjcp0s7GOYGkJRiELJ6GiNflzwpX+4l07rGUanJwkGKVJIOr0l8m5AEiZIFLqdDlLmZHlMmARU6hVarSZxJWZubg7TsqjUKyycO8NrX/PT3PW9+7DtKqHfx3ZM2mEfvz9ANw3CJKRar6EbOYEXYWs17rnrMS45eIA/XjyLrUXsv2gPy8vLWI4DlAqSLE5I8hRF0TZ9JaWs0TQMkjRA0yl3JJsDn27IMiDMdV8QL18coC1KyZSq6oyMjNDr9UjjmIKMMA1hM+NB2DZ5lm2R+WmcoMoyTU9KyWBQbqQbjQaqkCRx6U4UQoAszS+e52GaOlEYYtt2KZ8KfQzbIk1iyEEWJeCqCGI/RN2cfNM0JQxDGo0GeZ7TavdZXW9iaDrkBUk4JApDdEVHCrsscCEHmaFZLkUiMXVBESd4/SEjVYdEFGxsrDGlmrTWWyytLDO1bQ+1WoOFM8tMjNWIvCHdYU5zvYdpGMRRhpA5UhiEfsD6RpN+0GfnvoOkoeT0/Fmq1SqmXta1ef0BtltD0VTiJCEMA1RdIw+SLZNSkglOzp9henKcR598irGxMSrVOiur6zSNMuPYsSy6rRYrK03yMEGrNrjm5a8mjTw0d5y1YYv/9OH3cfXl13HplVchkLSDkLu//TWO/PPfE0c+UrFAlL8L0ywhot1tE0YJhtOgPjqCWdXIojKEyjQ1mnGP6YkKcTfAtEapkhMHPkqmUam5dNc7TBmTZFkIWR9TSKwsoJAZXhYj1D6/9Is/xXI4RA8L+oMmM3NjXH/tZdz1b7dxeP9+fu7WN7N3f4Mg8zh37DRr7bP85u9+hG3VaV7zjl9EqDZpmvNX/+2zHH3sBKDz2ON3oigGw94qy60W672It/3CO9EYkqYhVx4+zLNPneLEiSVu/YW3YVU0kjjmyIk+Uo5yZmWAZrioeoWi3+PphSYP3XcHJ498hxyT8d3XMDO9k//2Z39Oc3GBiR07+PT/+mkOHDzE5DiMT2R8/1v38MH3/QXe2tOo6gR5lBGsz7PeMTA1l+179lDXNfqrj/PTLz/I/OJJ/vqPP1eCswaIHFXLSdKY3/7oB3nXu96Cbo/x53/xt3zhS/+Dt7x2BwU5r377b2DqMYnf5D/86of4k88mXDxdY3VpA0XRmdzWYM/e3UijQRYNONYwabc76IbD7Mw0URyTk2A5Fp1eFyELZraNEecxhWpQH62hodButsrBaOijmzbLyz3cWpWx8RomcM1l76LXipjaNkaeeCSxJC9CxsYr+EONwAsIvCGmoYAUIHUsawQhCvzAozfswdAjiTN0Q8W2VB555GG63S6DfoTIE5rrK1THxjAdBafioAeSjY0NbNtGkQazkxN8/Dd+hantB7j0sotx1AJJThj6aJqC5xWEcUSjUSfPFYIgQVHyzfA4SRQHEOeMNxyyPCbLU3RNB5GiGTFhPHhBvHxRgDZFUcZOUmqwVVVFVTWkopLngiSOSYt8S2fZ7Zb80IV0tWq1ihBiK8kvz3PCJN4CJEVRGAwGWJaBIiVy848QAkSBqmmbaYHlA0Dom6FUmlK2kFM+FC7wXnmeMxgMUBVBEMRkUkNVdRTVwrYMEAVpBoqQgCRNyqCqLPTRNQ1NzVCynEIoVKoO+aBPICLq1QZFlFCv1oijhMGwj27ZpHmOqigosuR/pRREUUqchuiqgW3bXH3t9aw0W6QZzM3Nsbg4T5ZFTE5ObUmntE2jgqbbZGmIZdkUcUySp5iOxjCQFLnCxOQsipDoUqDrHnEmSOIyKzxKEiy3iicCknCJpx8TjE1WqZgVOt4iP/2zt7LSGfD29/8KH/3oR3nk4Qd4/PHHKVCwbJdCWoS+T5JE6FoFAEVRkVqpuS9QyGJQhUSSk8YxCuBUDWSkQ5LhxRm5LMiUFMcwKAy7VPREAtdOEElGKE1yRUPRcrxuQLOzTjdMWXn2NNfe/FIauUT1fbZfPEfQXSXobrC60MFLEqbmxhg6Bl/6+pe4aOdBtEqFetWFeJYde+scfUyCjAkDgaoHZJGgUR1natsulhafhCRg//4ZwjTimePPMjuzE9dy+da3vsPs9knmIpvqyAS10R20W0P0XKEbSr78+T8nDZsgK8zt3E+n3+ZEr830tgPURi6htdHhQ+/8dzQOHmbv5HYOXH8tX/kvHwdXZ3bv1dTrNaJ4gO/nuLUqilKjbpv0h/Mc3L+N4889w4P33bF124mkxLUkiLjhpVfwtrf+LMefe5zmsMKuPduxdYWOoqGbKrf/43/l6LMnObOa8MlP/hETo2P0gxwpQza6fS6aPcjTR49hu1N8/tv/xC+/4VaecWKSMKAxWmUoJY5tMAx9HKdCESW0W31Mx8Q2XAaDHoqiEYQJjqEgHIliVIh7HqZaIU9ivvKNR+l1W+zeuZOiyAlJyGWMLlSGQw9FlvdzVuS02m1cx0bTBV7WL6W/ahngFoYxCsWWsuXeu+5keuYwbkVD1SWWrZOk5Z4sT1Msy2JUKASBh9Ri4jhn74HLMHST8Vqd5555jDgOGR0dR6AQpn0UXcHr9ZEICkWgqw6KWqCpBkmSEEUprVaLimujGgpZHlCp2hQiJ82jF4TLFwVoF0VBGJY19KqqloFHWYZhGgyHHrqul5vZzQzWC3KdJEm2wDtN0y0XYp7npGm6FcGapj/Ouw7DECkhSco28DiO8YMI3TK3XiNlmZusbuY+m6aJYRhlHObmv9F1fYsCKR84bPLQJu1OC9OykUJuljSUi8MoirB0DUWECHLiIGS0MY4fRYyMVWi129x440t44PGnGGmMsbGxQZHl7NyxDdc1OHXqFJ6nbUqgdPzhkMwoj1/z86cQis5gmNDeaJWTuAJRkqGbNrbrUhTlz8VxHE6fOk6gaiiqoMBCLwQTjUmCQZexkRE2Om38XFIbnyTwfIbDIY16hUqlQrvbo2I7hOkoXhAy9GMOXHYla6tTSGuEleVzvOKmmzl29Bl2z02wcPYcs9LANFySXMGwCghVHLcKQLc/JIgyZnbsoe/1GHEdNEXDtcfptCIMtmFZ+9lIT2D4QxqGSzftsZ4MOL+2giJVBnnKODYXu1fRHXY4458iLXKixOI5cl5y0md+Y4HV0Ke9EWGNQl4xOfvdJ+kT4jRcHEenjoYX+EjdZffhccIw4VWvvY5wEOCaFXS3wjt+cZYw8Gg0bL7w198E4fPs8SdozOzGGz6DZUvmtm/nnvvv5pbXvga3Ms6f/Nl/xwt87vj+Hdz0qj5vf/u/R5Muo9vH+bu/+xx33vZ1FBlCMkBVTdbOP0d1eh+zczswzCqP3P8IxBnW6CTC7zPMQh754Z0ceMWr8ZpNsiLHtFxUXSOI27TaEilSRKXPy1++l0cf/QFH7nmgPKpTUpIpFqo1wm98/NO88qYb+eq/fIs89Tl1ap7moM2hw5dz3z3fIY0Epm1z+OJ9CDFGkRvsv+qlhN3z+EHCWMOg5y0xogn06jS3/eMdfOCNbyNLM3KgTV4uu2sVpqYnePr5U9SsCnW3QpjGxEWC6bgkYcTo1ATttSaKotLuLjA1swsvhA+96/c48uC9XHHwMINuhygOyCh11GmaYpkGaRqjqpDGpVtVlaAg0A2DOE6RskyShJwoCnBdl9W1Be578BE+/tt/wX0P3Mb0xHZsq0DRNTRVp9frYNsuvW6XSq2GHwZIqSLSnPW1JZQsYXp6mpWVJeRm9n6tVqPf71N3XZIkKW3zSoIiJIHfpSjAtS3cmgMixXFUeoMWZpYidZ3ZbWMviJcvCtD+yesCwKZpiuelJSiH2dbEnGUZ0SYXeiGi9cLkDGxlaJcBTqVI3TCMzWLfHPMn/v7ClC6Vkq9OkpQkScgpwc00zS0b/IX3vAC+qlpSJqOjoxSFQp4VZJT/39r6KlKW9Iym6uSU2vPIC0mTCE2R+P4Q03ExHYczzQ2M1Meu1ZAK5VEr8JAIms0mMzMzmEqO4zh0u10ss0JRZFscu2HoLJw/z/jULIEXMz09TbvTpN1us3vXRZtJcR6DQZ+5uTk8z2NicppBv0sSxUCAVE0Wz82zd/d+er0eY2NjbLQ6eF5AFARlVOWmndc0zfJkkqmMjo6SI7AqVRq5gW5V8YMYyzHIs5TID8jTjFQVpDlsbLTRNAVVN7gg/x8MBmiaQRj7VKt1ZAGaoiEKkzNnz3PdTa/DkRaHLn8pzWCNda9L3Va54YrLmNgxx/FTp2lMTLH9ov2cenaJ3YaB9sQjFCTI6gh70hDz0l28de92lu55grOrA8Z2W4zO7UAz6kyO78FxxhEiZtDxqDYaKFmCFwzICwVNUYkRFMSsL8dYdkDV0mg1V7EsFT/IKWTEgf2HePDEvzJat3nu2PNEcUxjbIwz8yvouoXluIxNNrj3ru9CkTA1tZfnjh7j6JOPAR2yLENTU5I0BDKCtRXOd/uMzOzi6huvo9naYHF1nXhlhVbrLJMjdXxquK7L+tIqa0sddEshKUKiMGLvnn2MjRY8fP/dPPbIAxhSJ85yDFUhzjKQFa6/+c185cs/4OHHFti1aztHn3kCQxXkqcXa6rnNrHlBOAzQdB3HchgZO0jF1UnCgppuEA19pmcbZH5GL2xz9vgzKIbO+z/66/zOxz6OWx9h78wMj26cZ0bVGK/UCIOYIIpAk3T7fWqOi+/7pGrO2OQEiiLYWI8IYjh7vsPSyimmJmcIvSH9Xodq3S1zgYZ9DMOg1+vQaNRxXRchC0ZGagSeh2EYdFodqtUq1mYN4DAYYBg6lqGTZCa/8Zu/yS0//fM88fT9zG2bobl2niwuKQ5NLydj27SIw7A03uQ5mqIwNtqgyHJ8PyhVYrK03SdRiio1ut0uipBUbbc8aWcZtl3GONdqFeyKzkZziSQecO0NV4AsWG+tkYv/e9nKT14vCtAuimKzSUbbmow1TUHkkOcl/yml3FpAapq2RYVkWbYFoBdCrFRVLcF3M4K1DJYq7caapmEYesmJpykF5WtUQyfLSnCVqtwCxCzLtvK4tU0aZTAY4LoulmXR7/fRdXNrAh8MBlimTRCUYHXhhGDUHcIwQhOgFDnDbo9qbRQhVdICKrU6RVFQq7jcdMMNPPbEkziWDVJy9swC27bPIKVgenqKTqdLKd6X5HlZEuE4FnEYUKuVO4GZmSmkkrG4tILtuhg5KKpKlhdoukFv0Gd8YoYkGDIMQrrdLrNTk8SJhyBnbWmRfDNvfGZqgjyDJC9Ya3YYqbiEoV/SJ5ogDHNaG12SROOO7/2A/bsn0IRPEof4g7KA1tItLLuO61Y3KawCRStPKKqukRcFYeRjJRbdbpeRUZNYKDx17HniosLTC+s8em6Vg/sO8bKrX0/RMJlfXuDBZ+eJCpXFB+fZu09y5XVX0B72qOy+DikVzEJy7UXbmV9boPNsystf/W6q26ucfHae937kI/zGJz7J//nFf6Gx91Jeed1VnHr2eRo1l2EYINSMTq/LwrkFdu0aoV6vQ76dgXeGxfkfUHNnufKqiPvue5qnjtzO2PQ++v2C6669nE5rieuuv5l77n2QwSDB80PWWxtEQQ9Th0fvv5so/EH52dBiFEUSJxEgMU2dNCvIsgFJltBqL3J+5RxSquzYPcvooRkQBouLi1w2PUcv8HD3HWTH9n0ceewpYm+VSy/fjsh8dmwb4R++8ODmZB0jEKBUyVPB5N5XcrZpcuDm9zAxNoFarXHdxKv4y0+8HUHA3kN7+JnX3cp3v/tNHMsmThN2HzjI237+51lbnufMUszS/FFOrpxjoxVSt6p4gxViT6BaGg9//y5+/v6HePrU8wTtPp+7/Rvc9IqfxZpz2YgDhCjQFEGSZSRRgGnqGEJhdfE8hj5BdWSOL37tdtZXB8xt30232aG1cJbxsRHCZICiKoxPjNDpdHArJq2NdWzbprm6wsryMtu2bSPPYdeuPayuLpPnKYoqqVdtdE2j125RG2vwyJEj/N4f/hUPHHmEZOBTqToM/RCFUm1Vr9dIkozeoI+i6Ji2Tex7ZFlClKdYjsnk5AShFzA1NsrxZ05gaDpOxS3jZpOUggx7swYxIcW1dZob62R5jGlr5ddHTpyl5a7tBa4XBWgLKdE27aIX8q9VVUXTJUJk5HkJ0LZtl+65vNQ8CyHKDO6ibEspm2nK16qqusWP67pOGEZYlr4V1eraziZVIlEUZfNBkG1N7Rfe4wKPbhjG//TQgB+31wghSnNMEOA4DnmaYuoGiUhQpSwTyihPAYqQ6GrZTJJufg+52OTL4zLPoVafYN+evdx1z0NMzUzT6fY39Z36Fr2RxJv6cyRpFm/y8xqKEHS9ISdPbuBULUzTRFV0srw8RVhWqRQpXZcZhu0wDELSNKXXbVH0mgh0hkOfkdEJhMiJw4hKrYqyyTLFSVLmixcpiupiGAJF0dAth43mGpcdmCJLQrIkJEnLh2UUJzQ3WtQqVTx/SCZA1Us9ar/fx/dCdu47QJoWOBWDOA4JkwG3/+DfOHP6PJccupZbb/0gS+sdTidNnn/0LJ1Bn0IaCKnzS+98J2fPzfP8848x6Hrsmz1Eoev0izZnF1dwbB3dcFlYWWXp/vu59pXX8ND3zrCwtMj1Vx3CcQ7x1S9/gZnpbTS7PrKQLK4tsWP7HqIsQVizDBKTcyfbREFZYZbmKSP1cYRIiQYtWuvnscwqrZaPJi1so8by8iNEkaDdaxMFPoZtE/ktCspjdpLlSHLiBEzVxq2YFJgIqZJloOkmil7eF1EcMH/sOEuVOhVV0G72UTWXxMsIow6rS6vsP3iY55/38Tpr7Nu/gwfvvw1QKJDkIgUkYRSDdKnUJ9m5/2pcZ5zYLzhz/jl27drFNT97C7/6gffwr3//D3grT6MIhTAaUuQKjz9yB0kQMhhucM0Nczzy0DGkSOn1zpShbgJ0FYoUzmdnyHMYnZ7l8C2v4VdvuZXel/+Gq1/3WkbMCqOWyaLXYsJp4FOgaQad5SY752bRpcLTJ9ZwjBpVNyUXkqzIkapKkqUMh0N0U2cw7KMpKoamo1ZrOI5Du9dlbHyULE+xTJeNjQ0ajQaWZRBGAb3uBt6wjy6VcsHoNDjx/CkOX3Ix3/z612iMWkRRgG27ZHkp8/XDqNwNRSlRHpBmP6Zcg7iMRsjShCSOcQ0Hxzbpex7IAtMwUHWVbre72e9p0+v10KTAMC0MQ6LrGmmeYVUq+L7/gnj5ogBtKLZAUtO0zWWfShikmIaCopQT9IWuRiHEFu+d5zmKplLExRaHHacJWZJSFKVL0q1W0E0dsZn2Z5omQpEUAjTLREvKcl4pywUkOVvv4bpV0jShKDJUVZLnkKY5iqJtBuYUCFFgmDqDgUe320UoypZiJUlz0jxFkwaGVRAGKapu0uuusiPbS6HoOJpBlKQkWYyi5qiqZHSsgWnqJEnCYOBx5MgT3HTTdRw9epRqtb5FCyVJuZGuuA5hnDEY9LBNEy/M8IY+gb/AZZdeRXO9S6VSYzgckGXZpmqmz6CfMT01gcgaNFdWMAwT13UZGx2h0x2WS5MkptNr0xibQVE1sihAKhAHCVKqWK5Wfp+Jz3e+9U1M2efqK3aiypw0Chm0h+iuy7DZotFoIDSNsXptK+Xv0KFDbDS7eJ0MS5P4XoglNZ4+/Thn28eobR/nfP853vc7t2JYJv5gnR37DyKEIAlzRK5y27/+FVrh8OrX3Eizs0F+8Xo5Ze05wOh+h/lTpxmp1el2Jjh+fJWTq9/jDVc0uOjiEf7uq99E689DtYasTbO2scrqYpcxY4aTp3Puvnue9YWHecM7PoAR2Qitz9rqE5gCahXJ9tlRFhb7nD76KDdddwsnnnuCN77pJo499hCrq22GwxB/EGHaDoahYUmTJEsI0iGIHEWzyLKYMBUkvYQ0H6BIjTw3UZQAywoJggAhBI2xGYrEAikRqkev2aTRqDEyPk0sEs4snsYwVSquwDG6nD75JGCUTUxigCTDquzkxutezlPnPM4vncFJJZrqkOQ9nnv+CEKBYVqwuLjAE/ffTVYkaBISPYNYcvLE/RR5yjf+8Wk03SZNU66/9npOnDjBZVdv50d3PkNW5GSeR5FDeOY0i6dPs/Pqy7n9W7fx9rf9PEMFltY2cEcMFtorWJbAW/E4uH03w7TgO7cf45Mf/U987LN/SC9ok+Y5WT7EcSqMj41iO2KrTDuME5QiY6m9waGpCdTuAMXUtqjUC0mBveGAoshxKzUUCYYq0PwIp6LyN1/4PG9789vxgiHaIKWIczRb4gU+jmNRFBlppJDmMapRFmQr5ASqgCSGPIUko93cwLYsikzQcKskeUiW5xRRhoFELUArVhFlIwAAIABJREFUCkSWMbtjgnZ3jdHxBpopSIMAz4NK5f+lPO3/Ly8hJGlaZmVfAEsoF45pUk7WlmVtUSc/2R6jqqX8zzZMIj9AlZI0TjBUjWCT0ojDCIkgCmMcu0KRC6IowXEqpQNLKkihkSYplqlBwRYVUgbWlKE1qpTkBVi6gT8YMj4+St8blt2LQgFyDMvc6hBUNIWiyEt6ppD0KRCWTjYMyFOPVEtxrDEUCmxTo++V01cYDXEch7SI8bwhuiG3AHp6epZer19SCPVxksQnCMokPz+McFwN07Sx3DEURbC61mR9dZ1u78eUzgVnqBQqeRayunyOaqWCYTokScTi4uKmycDBciooukkUlTkulmmgV8s40P5wnW67haIK0kxQ5BKBSpwoSLVOZ2MVzTFwHAfXdemFbbJCoKg6CwtNdu7cA0BWCAzbAkMgTUmaZ3iBz8MPPMj8/Gn27Im4+OIDfOL3/jtIi1/95fdyeNZm+3iFo488gFlp8Puf+xSTO/bwzne9n2Yz4dQ5ycTYBP/095/i4FU/xYP338nSQpO27/MHH3kLtZGDfPOPf4DCNLW5GYbrTeJsA/Ob/4jQ6wT9Hu/44H/k/NlTvPodN3LddTfzf/ztvzGnzbB09jynnnsCJQnZsW2M7jAkJ6E/aDO2YxuPHX+UE+eWefb0EkHQIgw9bFsjzUOK3MLzy6IN27LLJXoYUzLHBXmRIpSSklOIyLMcPxJg1Mlyk7hIyJUhSRCjyAKNmCwe0u6dpzqym0sOT3Ps6eeYnKzz6MNHEDKDPKZMxijjji13llQdwa1KEi+jGHQolAEjpscwHfLeG69kqnmeR370DWQRYao2RRpRzx26xBTEiBw0bOI0w1SrtJobdDodrrvmvfzwzqdKWQoCIfJN2rLg7NNP88X/7e9Y7a8RMmBydB99P2TCnERqMZWGgZaqXKSm3PRbn6W13KfTauJ3OxR5gKLoVBwDUYDjVPC8AUkco2Cwtr6EbdcASPOM0dEJfH9IUQhaGx0yMpK0pCksw8TQ1LI1UM2Jg4D24jzLy2fZtm2a9V6L0ZkxvIGPlC5kVaquzlJnmcm5afzQIy8GqDJHDUOsmkO718bYDJ2q6yqkOXlaYJs6SZyjSMiTBEPRUOIMS9HxPYHjTuG4I/SDNpo2ilA8oix+Qbx8cYA2oGsqEgGyoACiqDzya6pECIV+v4vjWD/BXUvyvMye1RVJlmdbcr40jkHVyJOUNIoRmxZ2oWrEWfn6vJD4Ydm2LoWOlBcs1SU3nSTZFl+e53F5M+UCzwtIkvLv+/0+WZ4gFQUQhHFEHEckWUKap8hClu0lioKp6azEHTBM1DhnOFhj4K1j6FMoikYaehRZRBAmpIXPWmuDm29+GXd870dYjoE/iNjYaLFjxw7W11rMzW4vLbqmzfr6Oq5rb7bKDwgVEKJcWs7MzDAzOcXGRhOpuAR+hhcMqderBKFPHPQp0oBuK8Kwx1F1DdMo6928uAApmZjZgShg8dxZhppBfXICXTexalUsWaDInISEIA5oTI1yz/0/4tvf+QY3v+QafvvXPsjk1DidtTUqNZcTz59iYmqG0bHtrKyVetQ4A9UwMVwT1DIzZvf2GZ545giWqRJFPnHU5sMf+iA7d1zO9Phuzj5/jjF9hoN7RjGcGj+665u4jR3kMkJVJZONaZSsPKGNjZjUTQFC5z0f/nWgyuF9B7h//RHcBgTrG6R5RGWkStjLmamNkFsVFk48xr//1Q9x5vQaf/qpT3DNTa9mom4zuf0SXn7TBzBFhEx9DNPm9z/zWdLuOUZnXXYeuJJus0176JGGJkYh2DYxwXq3Xxq26uVnLQpiNKkAKUIXZEnZ/JIVKgVQ9rlAkUCRChQV/LU2uRljuGNoQqe1vkik7iZPPdZXjrB8vkLNrnLsmTOcf/650jAkElRNI4sFOTbTey9mZRii6A5R2GJ24iJUNWfElhy8+Aouu3qSb//wn0H00RSdLIuIZUaYD2FEIcly3LRKlKRcsm8f45Nj/OBHd/Oud/8cn/2DPwOhlLU+EjTd2FziS256yc289fWv4D//2ed437vfzD1LLbbPjrLqnUT1DUaNWZ54dsDPvOGX+enr6jyJTbe5xmx1lDOWxtqgT5EW9FohqilQFZ0iUbE0wfS+i1lrr5OlBarhMhiGFEW5D5ucnmAwGFCrjYIsSOIMFJUoi7FsF9PKqNoK9959O41Gg/awT5Q0EWpMPJRQSDrtkIlph2PHfkS1rqEWFZJ0FFUbYW1xiONMIwYxZiTIFZMgC0iVhCJJ0XQDS9ORVQPVMhkMWgR5wHTUodluI5UpVNvAtmooRfl5eKHrRQHaUKCqGnlBacsuLuTtavRabWqNEcRmlkdRCLTNBZbvl03Y1Wq1rPrK87JfzjDJsgxdL5UOUsot1UcUeaSpgm3bhGFIrTZJmqbl5jpNykjFON4KYLcsSRAMSjpCVVF0A6mCpqvMbptleXlxU3aYbnHjF/j2C5LAoihAAURKMCibqv2hRxzkVEbqZIVE0RyKMKNaUfGDEAUNp1LhDa9/Ffff/yDCFTx/8kz5gUOyvLxKozFWThFZqU13XZu1U+fJKgWKljI6WmNp+QynTj/H1Mwcw34fRS2rvLI8RdMFfpggcwkiJ+yvU6tUMSyDTqdDfXSKdrtDbcQnCH1GR8ao1+tlxvXAp1EfRWYZmlJWdalGBc/3GatVcLSUbrfLpdfeyExV5+YbX0paFIxPThNHGYvdefZddBiA82fPYds2eWgipiX1mRobvRUqDROMAs3V6HgeN9x0M2fObaDXJP1hSGN8AhHEeMOEHTt2cfia6/nHO++jvbGCrkvOnTkOucvq6lnuvuc+ep2EnZdcxFf/97s4dvJJVDUgDTIKaqhFQtgZQl5Hc1VOPfckvhlx7/fv5s67HuDVr7gFR9eYMBpoXps7vn0HFTsi8jvMTO0iFwZFITn17Dw/+/rX8Zn/5UNMTc2xGp6h6tQ5u9RB6oIoDcjjMqfFNM3yIenYZGmMYjtEYUacqpt3RUnL5UWEJEKV4FYL+mFIPOgSxRloDtFgWC67kmfwBtO86T3v4yt//0dIJUIWCmlekMYFYFAb3UMcpsgiIco8pCa5+9tfwN9YZ+bqS7n3R3fxtX+qs3OkyuTsjawvPo9GwohWMIhj3vALv8YNzhj/8tV/RpeCZrzBPT+6mz/8k9/mv/7pX2CpOmEeIkS5F4o28z/27L4IL4rZffAgn/rY7/LBX3oLeRLzbLtJZ2hy0eR2vvHd+/nMm19O7uyhuTbK1VdczLAzRCkq1KuTTE4NkIMNNGmSFiWlExg+opCojmT+oRME45KJmQnSNAGlpEvzVFBx3fInmqaoStmvmmcRqmZgmQZ+EhEGMXv37KfXWsWoTtFsNlk8fpTF588xvfswS4tnGBmZoEgLhCaItQ49Pyb0A4JAp2YLdF1iKwV52McVFqpiILIEkhRVFcgwx0g8xscajJt7IbE5e3SBK192CeuLy1Sq+pag4v/pelGAdnEh3S9OtlpmLnzZlYoDWblYvGBvv2CMUaSKQFKv10mjEH8w3ARcgTQ14jDckgXGaUKaZptLxPIBEIYxQRD8T0vNUrmibWm9k6Rc+BVFQZhEeH4Zu5h5KYal/4Qc8Mea7CiKcF23LBTeBG+RF2iy/L4sTaXpB5uBTXpZp6YrhGGI5Vp0uhGqWtI6tmGhScEwSdANycLCAnNz2wnDEMdxaK63UFUdXTVwbAdNL1vjg2DI0B+UzfCmQRYnZFlMtW6RF5LAD6nVXcbGxhj0NsqdQpjQ7mxsPnhiDMNgbEQj8Ia4rsvK0jJJkjIyOUnVtfEHPrqukhbFpqwwwNQ0XNdFVjUWl85z5eWH2DM3xelT82ybnkFXYjTVBKlgO6VOm81lreNUsCyLQuQsLi5Sr9fx/RChqNRGJthod5icLHXj572Y+x95gkNzBlkmWFpd4UCYINARmSTPPVSt3DdolsL8wmn6vYiiAbVJl4HngWah6xUoNGy7yurqBjkBvfYCgpzxMQtVxtx41T6+9eU/ozc8j2YbJEEAaY5AIAubhXNpuZgl5tnHHsDWDFSt4PrrLqHTPIVrO+UQYRoMA5/19RXyJCQMQ4LAx7YdQOJaGooicIySJ07iMj5VFCppFgA5Lb8DqaQ2Msre66/ksXseI6VDUaxz00vexOErd7KxsUZRRBQFyCIvKcNCImUFxxklz3UKCgxd4IV99l95Na32KvsvupgR1+K8rNJUVC55/T4u374DmQSoDLjk0ss533yOP3r/R/jTD32Mws1432c/QCHgW9++jY11H0exERnIzcwdIQQzM7Nce+21PHvyOIowueHaa3jg0YD3/9Zv8Zef/SwDtUqnB5+49X1MHTpEc/44jz+0xK5+hH9shUyvcfnF12IZdYgCIr9NoajEaYIQKkkcs7i4yCtuug5Dq/LUc4tU61WSzfswjmP8oY9tm5uu6PLea4y4SJETxzGO4xAGfUxDo1Yd5+HnTiMVg3d++NNYpkvFrGLZBp//67/CsWxS4aHaGSoxr7rxFTzy8GPE0YAsz6laDo7pIAIFQjYX9gUyKbBsnTzyWD6zTGXPBJGRkBQwdAWFUsfflAS+0PUiAe2CJCyzdC8oKhCCKIrodbtlVGNWpvepioLvRQhRoCil0WQwGKCKUp1RrVbx/fD/ou494yUry3Tv/7Nircq1c+/du3OiE01O2kRFBkRFHGAUEdERc8Aw6jgqg3HMjAKiYkAJElRAUEBspIGmaTrRcXfcOVauWnk974dVvfHMe5z3nPd3PnjqU3ftqlq7qta+1/Pc93X9r5bDUZld+SothcpfDzKPwaR8P8RxmhQKhZa0z8RI6JimiRABXiBpNJtYVopU2sJzgxbv2wclDv+1LItkMk6lMc2YgdJ0Yo5uGEVk8hnmaklsp0qomPi2QhgGGGmLRHsOTdHI5DP4Ufx5qIpCGEjqXpkLzr+IF156jonJEpVKA01TmNPTj910WbJsKbt27kJG7QwODuI5sdTQl5DKpBk+chBV1Thz/TkM7NuPQghRnPDTrDfI5dtii7+A8dEhokC0ZgaSmelJevv6OXh0kJ7uXqxEohXWG7vXEukUdqNGJpPCadokrRSa4jA1NYOVEOTzbWhhg4lihXQ2F5uYdB/Ph1QyzzPPbuSTQHvnHEZHR6lWyyStFOnuHvYdGubUV53H05uep1KsUe1oUKo1+JdPXce1V15D/7x2QlWnbkdIP6CrO6K7kKO/r5eRgSNoNNBFHaEJ0ok805Pj7B3YR1f/fFAUdFkFzSORt5kaqlNtGrT39lOcMChOVxBKk05L58WNfySbMqjUpzj7NYs5/4IlvLz3Od73watJWPCR637Gpr8MxdFjkU5ChWf+fD/JVJM/PP5bLMsklAGRFtJsnTc9cxaACvVKGd+zcRpFBGDbDQxdR3Vc2uakmCo7qGqGyAfsKbq6e/jAez/L1pd2MnC0xM5tW/nthieYni5y5gkr2bzxMX5+x+08s3ETihQkdIHvC3wlRAQGi5eeQTKXolY3CESIngyxtGT8fSkmf77vPlaedjZJVmGkMmBlOVqvMDlxiENP/46sb3PR8hX84JM38fzTf+DJPU+QS+Z47/uu5KZv3kbSUgibEZGmIgMRB0YIhTVrTmLgwFGSiTZMXUGjQV/K4Be3/YiffP1brD3/7ez4858487wLOLDtASzVJ6VpVKZK2OkeXnfJRRzYd4Qg9KHpo8gkAh+nUUHoOZKmSqUU8Mfnfs6R6YizXnUpmqKiWSk8L8AyE6gKQEjkO1hJHU2H0LchiludvuNgKiq6CutOPI5VJ63nlltvY/DIEENHBhkuzpBE5Yp/fBMTg2NMSUimDCqDI1SdNs561ZVs27aNwzs2MToVMaenFxHWSVsZbGmj+gqdbVkcQyDzczBch31PDrH65BPIp7pJ1QRqkKAxNUHk/1/Q01YUhXQ+j+t7WC1sqowCNEXFMkx0VUeJIjRDRUbEEBZNQRIQ+B5CJAnD6K/03ipCSNyWjvtYGLDrx72iY9PkY4kYiqKQSMTayHh17UMkWsYagaoyK0N0HK+VGmOhqsqssuTYgFS0uBrHhPSe44KUVMtlSg2IfA8tYWI7AY7j4kcx2bDeqMeuLVUjYWZRhE69OU4YCPx0kf7++VSqNkEQUK2VsKwmg0en4vciI8rlMplMhkq5TBjGssBGpUxPTy+GYfDcs38hncoiUfAjifB9zISB68Z6ds/zyeQLBK6P78XcDrtRo1Iuohsa09OT5LMF6rUK0rbJt7UDYFgJAhmSy2epV2qYKYMg8tB1FWRAuVondD0ymo6VShD4EYYh8L2QhQsXw/NQyLdTr9cxUyZNz2ayOMOevXs567Vnoyo6ZkqlXCtz5eVXcmjvXs4+/3wG9m7F8zza2+cwdPgIhwYO8PFPfJjEknWENKmUR2k2Zuju6KS9vZ1Cvp3TTj2T8fFxTF1lqjJDz9w2CgWLsaNHQTo0qgaa0oE0JG4zYE7/fBLTZQ4f2k2mUOOZp/Zzx68vZMOGKR5++CG++a+D6FrsLwyCgIVLuhmb2IVh5PBcgQxDfD0kChU0w0BRTbwQXM/F931UzcIUJmGg4Do2EOAHoOg2w8Mz8fAKG4nkyquu58z1x/OjH3yL8bEpLnnjWznxtFfztS9/gZUrV9IoHuDRBx5ky9ZtuF4DKSS2LzEUIMgg6CVSdEoeoMmYax0YqFJDYqBpcctgsjFDrq1CaWaMngU91DMGS48/memZnUy9vJ2f7P4Z39j9C1AiFhbaeOOl53Dfbx8BFBRhEipAIJHEARCLlqxA1ZPkCgpB5BF4UJx2SWf7CQeOoAA7nvw5Upg89+Q9qHiERNRFA5qTnLTmElYdv4TBySZHtm1lxYI8brMGIiRhZtD8CM+VHN2/mygQlMeP0tHeTeCHeJEb78qVAKGoeI6HYcZpV6oCSc2iFpUI/Sa6miab03liw+Oce8aprFu/hAXLOrnhc++mUmzw8c9+An+iSueiHGoG/MlB+havwO0s8PKOzWx67g986L3v59DpS9j8wg4mR/cwt03D0gLU0EBaHpPFEp3tHWR1hWZQoqPPw9SHyOZUjhw5isBFmAnq1cp/Wy//Loo2gNtoxLDzSEFXVAJF4roevufRkU7hhjaqr6KqKs2mRy6XIQoDDCOJiCSarpJu2UaPDRADPwIUXNdpGV1CTFPMJrJD3BfXNCN2GlpmPPzU9dnVsmnGWuJQhri+RxCGuL6P6jqYmC2ruuQY2SsIfFw3Dl+wbRtaPW0viNCsFE6tSLuVBNSYTKjrpKwMAgcRaCiBxHUrIDQyyXw8aJUmplHHscv0ze1h/74RUikTQ5eE0kPVNUxTp9loELRO1ISpkE61Mz4+CEIlk8lSLk4wf/Fy1BDcSMH1I4h8EoZFqBo0HLeVeaiiWFAuTVOrlenq7WN6coZUQqFas8m2FwgjD9drEMqIyA2JPJ+O9nZc1yEM6lSrTRKGgpXMgeHTKFZQhY9nV8nnNQoFi0Yj3om88OKLLFy4ACdokOtq41f3/YqNmzdz+gWXkEj3Up0+wBsvv5hbv/4Vujvmoue7GR0dx62Df1wX/fP7cOqCyR17OeG0dgSSUmWUZrPMkqXLObz/EMlMnkhAcWyaOT1Jhg+VkFGOarmJpoWEGDTtKkJCZDfQDY2Xd+3Dq0rSyXmUKbHqpByLst9jwYJORsemaO9uw7YFc/KrMBUTEUQkqBC6NVIJQSQzuF7c2gulEucN+j6W2Y6iODSbJaSUpHJ5EskUzWYT3ynxruuu4iM3fIzHN+/gl3f9HlVZwPoLz+OjH7yWSy8+nVL5ee748Q+RUcTJJ53Mpsf3Mbp/Po8+9hDI2FcgIo0IHzcyMVIddHZ300RBkRaqWoIoJPBSSFVH+gFmZycCQX10hK5UH6vbMryw8XFWrjuZnYcHOX39uYRr11H802Le+v4ruOJTV/HYo4/z6ovPZ3KqDijYDUCPA3wB3nLlNUwV60xXHYLQJ6EL7KCJI0y6l6wh3PwH0HKIyKZQkJSKNoGSg0ggRBkpmtRDD1Xt5p0ffCu3fbNKtXiAyHHRVPD8AEXXEUKDoIavCT5y492k2ropFaeIAic20UmJ7dQwkjrlehNEREJTKTbK5NJ5bOmSahckdYt926e56ye3cfcvbkbIkMvPehAliAhi7Q1f/eiTyNAkl8+C2U2lMQWyycLVy9k5+BdePnSYr3//J9x3553s2fgA4zPjVMoN0tKimQhoenVOPeEUejqXYqzt4aSTLqLhSY4Le2nUqtQGR4gcB54482/Wyr+Loi0AoWogQqQiqDpNlJadvSOXx2nYhEFETVZim6oaoeoC2YxbILEsT84ab471lhU1BjUZVgLV0Fs9cbUVJuq1NOHerDHHcZyW5b05Gz0mpYhXJS2YVBysIEmlUrFTMvBpNhtomt/SeisUCm24rjMLajr2Wnoihe35RIpOFDo06yXMdCdmMoVbGkKGEZGI0z6sZIpIeriuh6JGWMk8ibQgDFQKbTqO7VMo5Gk6DrYT0NHRRaVSQZQUVEXFNE0mJqZIWClyuRwT41MIoTB45Cj5ji5QTIRQcYOI0PcRajwbUJH4TrydrNVqLRxAiKoKkqkUnu/HBqBCG3ajTiqXxfclumZQqtTQFIlhJCgXZ9i+dxdCOCgI1ixdOstmado2/f1pUGJpZxAEjI2NsXrVcjo629n4/DOYqTx9vQsIAhVD09m3ew+nnnIyK5es5o77HmbBvH7Wn76W4vRuFN+nOzeX11/yGoyF85gzpwM/CAmlw/j4JM3QplZtsGX7FhYsWxHPGoByuYSqQRCAZqpIDELPic/DQGDXfXLpeagiS7X+Ii88ux8hDEaHS/iBhttMs2zxiTieZGZqC4oaYipZXDskilIIoeDaYQwQiyQyUlC1LJ6M0DWDfLoTISCMXGzPp7ujgIg6+N73v8uBgaN89IMf4Mz1b+Cpp//M+69/L5dddS1//M0tzExOk0iYuE6DndteREaCE044EWS8a4xkBKgoCBTVo69nDjKdxw2zOEJiShvTSBA2PEQUYvqCoFpFkTa64eIYJf6y7Tm8SZ/w+DMwUhn++MJhTj3+eKrt07ztXz/JhWe8Cj3hYurxcSLiRVAYBIDGypXrqDVsiuUZTCtN6Ea4WopAEaCGDAzvobv7DMruOF5lGq/qYBiCQDroaoiIBIGSp1iaJtsnmdOro1seZj6HrysoYYhphahRkmpg07/6LJ7fXmNg3xZ62/tRZUTDjluVsawXZBhhagaaZmAaKg3fxhVN7GqZA+OTVGsODdcBPSQhBPg2plXAiSqEKZOUmcUu1YiSEYFIML9jHvbULrxIMrjlRQ5vOowg4j3brycUDdxijTDfz/HrTsDKZ2nv7iGTa0NRFCbGBxm/c4KnbrsKrREwXjpM6HiEdh2Av05Q/6+3v4ui3d7TxYe+8EGEotCo18nn85gyNs4QSbxIohsJvEjh6KHDbHr2OXa89GIsNQuaWMk0iqrg2yG27SElWJaJZsZJy7oUcYp2C0xlmmZLhaIjlBDTSNBsOqTTaWy7Ea80VTE7nBQoEKkgBIau47sBipD4gT+7EpdSEEYuYRRhOwFRpKCGYCaT2HYT1dBJhA4zxYD5x3WgiQHUoIhpLCSR62Tm6EsktCTJzhxK6ShaokxQX0wqXeW+3z2PVHze9c8f4Uc//gbzupeTTVUZHx8HoZHNtFOcKSGJkFFEAJRqTQwrjamlKE43MYxY824lNOx6iVyuk4bTJJdvp+K6EEWMjwyjIujo6MB2XAwzSRBCQjXp7+1nfHqGTCaDb/u4toOVTKFGgigSBEJQaO9E0xRcu0GbopE8IY/0SkjpohAgtRCfAEUzcQKJjGLt99Ilx6HrKl6oUejoAHxE4PDog3fTLE9Sr1Tx3YixyUmmqi8SytjIUJqaIasnAAV8h/JYgJ6skdAyuF5Ab+9yli1fxJ82PkXgC5ymx9h4kXyhE0iRzeZxvBIodbr70pSKEU1fZdGilfT29PDc7o1c9fazeG7DJkKhcOLqs3GD+LyZKk5gO2VGhvagah5JM4PnNxgdHyEIAlaunk9/fz9nn30q7e058u0a9UqVSqXK4YM29aZk38EZmg2PrS8+B0qFtq5+Vq9YQlfnCqZKM7zuHz/E8pVrKFYTXHvVJegEVEo+vb3HMTE1GCs0RIQv4dzzLmDTS5s4PFDF8xqgB6xedzq+10PDbhJEoGtVtIaOlYnzK7V0Gi8IKftlEiGEJGg2Taq1NhavvZRas8b48BRd3R3M61vEkaFJUstX8caTv8fTf/4un/zKLZxw8vkM/+5ehKmiRAGar3DdNe/nyOQ0oTRIZ9vRFEnKgMiZwlI8aqZNR0eOB558hsGXZ7j0tZfSKI2gBSX6entZd9JKHvr9o5CsMv3Sfdz5BZPV57yH/S/Opeo+Q39nO3nNQFezpLolCZFjz9M/4pwzVjBvzmnULB2hZCh0W3hhTPwMQg8RTZFQfGaOHKC3s5tT1q7jng1/4Xt3PYKv9tNd0Bnbtptvff5f0dwhXK9OpVjGERlU20YNFbxQwxJpGiWf6tp2Xnv9t5moeIzs388FH3gPV19+MkU7xA1VKlM+1UZEPqkQBBE97SapAkg9ImPGRj1L+ReWhSpfvesw37judUhxOMZNh87frJd/F0U7mUqzdu3JcS86DEiYJtPVGfSWrb1StwkiyaoV63Ach+7OXnZs3YYMAyQxfOmYX19VwTCt2Z6153lEkULo27NDSFVV/4fjx6tzWhb3mP7nejZR1GqlBHGv2tRj+WDRmSEKUuiqRrNuz64yjg0/QWkVfANFB0O2YsfCEC9SwUwQ+k18u4bnRgShIAwkuqZjez6aYVCaDsnnygwOVxBqmfsf3Mw/vP5kqtUqG556AK8e7xQaTQ+l6WL8+u8PAAAgAElEQVTXbAxTRdcT8WrWC0gm0whhoKohjlsmlbTQVCCUqIokoWtxUk0ilpyJUEHKuJdvGAZ9ff3Yts2hA4fo65+P4/mIpo1je+i6iZIUBF4Yt4CiOC27WKkShT6WapHNqRSnKygSQFKtlsnOyeG5Ic2mzZye/tZ3Flv0e/rmsXnrS0CEoSusXr6Ywwd3MlBVUBUdYeq4QqInTAK/TrVcJFVQ8Bo2hQV9LFm+iMlkB0KRzJs3lz17BujpPYeOrjmk01kuufiNbNm9Dz9qgIDOjrmUqjr1shNH2Gk5NE1y6OAu5s7rI9/Zx4Kl83jm6S2EXsjRI/twI4P+/j4UqcX2acvFbqiMTo0TRk0WLJrPokWLOOtVx5PNZkma4NgVpscdQi8kdH08u0KzIVm8dAkLFy3h1eedzvbNf2HhkgLLly7imms/xNHRIg89+Sy/vvcezj3/PHa9+Bz1aol8uhNNTRG1zEwQgFDRjHbWn305A/tuA0WiJ9Zw1dv/jSm7wQ/+82Y6Ih0nCEA0MWQGMHHcJmEgyOVydM3pYkJGZE2TfDKFpgiyVoqS5zNtl+nKmBiqxnRxBr9ZY9lxJ4ICE0PPxn9EqoLv+nSqOUpTZer1OpGhUGu6KMLGa5QodOQIwoj25Els2bSZb33uQb731Tfz3n/+MDd/+e1IJUd713Hc+L0HeOhhFaop3v2ef+Rjn/8Ky+e0MW9BP0uWvIHNG17gwJ77EUE7Lx/YhwG8471f4g8PP8qqdSvYufsomYzKoZd30dXeQ8pMYDs1Ots1ypVxLn/jxSxYcjxjDY2rV15AMehi3+AI0csOc4SKmV3JCWtW4HoNHvrl7aCZRJ6kqDig1llz1ms4uP8Iw89uZGzDLwi1DEpgcd/3Ql54aAnL157K4tXHYWSyKKFKfcYmkTSZGqni+iF6LoPt1Sj646zqXMhvhlS+cfUlSCZQTCNW5/83ApK/i6I9OjTMLd+9GaEqDE6MxCd7NkXNaaJGkFWTKJZJrXw7117zTh578lEOHfWY1wuZVIIwsEkmkzSbMd41Cn3S6SyVSgmBRrwbtsD2Z9kkeisRRzfioaHd9LCsiIRlgIhdjAJm6YGKjBNzdF1v6cTjK2U6naZWr7/yWoFECkHouQTSQNgxXdCVkjZDpdms49YbZNMZwjAkkcuRy2apJlM4SpVg2ieotFFI5PjNH+/DbkAUyThQQRisOfEkfF+CEpFNJ0lnMxQrHpZhoKpgGgb5fB6/WEJTBJ5ro6qSZCKN59n4vkA3EszMzCBUFUVNkk6nqLtxKyi+yL1COcxkMrR35Gk0aixbspym41KvNWdlkolEC2/bbJLO+hQKbcgohLBJ5AVUS+MkDYmh2RhmBrvRJJUs4Hluy0UKYegjhE5Pd4Ff3vvDFl3RZufurUzMFMkmTQ7t30fX3DaadpNGs8TKpfOxvRp6MgcY1O0m03t2kjllIXrCYO++PSxbvISZ8jhWQmfXvu20t7dzeN8AhpZA1ZMEUYjfrKPoGn7doX9FJ4f2HeLUU86ASODPBIwPKWTb+sl0TBPYNRYt6mJiYoSZmWn8wKWjI8+KFSs44cQLcV2HqekxxsfHuf2HP0a2AjbCMEQRgt7uLlLJJL19fSiGybZNv+OpP9m8/vVvIJIuv7rjVxSybbzu9ePMVD2O7p7k4je8mVz7PF79mtezc8c2TCvg5FefyRvnvJvbv/5FqEOghlxz3dsZmBrjp7feQb7/JC59xzV8+l//jR/e/RPCwZeZBDwcED6Tw/MRVo5s25LYR4DP+MRQ7DNo6yIKXWzbJ20lmdPRhhCClGmRSqWwGiaRrhDVu/DCgBe3voCqWoSBC2o3//rV73BwYDdCXYihW8xUbTShoCIIygHVio1qWPR0z+HZR37Fmj/ehV8ZQIiAUKuwbftDfPIT72HzbpubPvlznvjTT7j6+iq93V184K0LWLX2HaxefDKpOS7SynPzf/yMh366h/vuuoXv3/c05cYMJ0UJbvnKzSxcJphsJHnHDdczPHqYLc88yuLVJ7Hx0CCZdQvJdvWQ0PKMDFVIipC6a7N3rEItk2a4aTExPsSpl32BxQsW07Adhg4OkG0rcNza1bzwwr+z8JyTOf6E9ei6Tn7uIpYtWohUYbi1E2/Wx3ADQUITlEpgJCJUNUlzskxfd5r1S5fzppUXohg6n/j41/jZz27GaqvheDNweP/frJd/F0U7mUrxT2+7Gj8Mee7F55nXN5e5i+cRBAGduQK1Yh0zleQnP/05g0MjLF68mLbOFzFNl1KpgqEzm9+o6+Zs0TEMoyVfU2aVHccGkK9osg0i5ZXV9zHrerwqb2mvWzK8YwoSVVVnZYTHWi7H0LFRy2rvex6a70Pg4Yc+qgqOLvE1F9d14+c0myAVhAq2p5JQbRJKAlVaHD28k6YDV13xQaQM2LXvMIWuTvr6ehjYu4We7g5q1WrMrhAhbmCT1Cw8z0HTYyVA0kqRzWZQpKBWr6KocS6mYRgETlycDZ3WRS5N4AZYVhgnSUexGqdcLpNJJ4m8+PMtlWaIwvh9V6plID8bEKFqOg07NoHksxnUUEHXNAzdQxURqpD4QUQoY/hXLhfbjs2khWElcBwb13VmW1jvuPZtSFVhz8svxWlDrouqqcydN5ehkWHyKZMgyhJJhSDSqNtN0jIkm8/Q3H8I3dI4MnSUocOHEULQ1dVFd3eFZ/c+S+h5DA4P49aLFLo6KI6PY9ddVFXBcRu4gU+1XEMEsPPpPyH9iFNOPZ4dO57GtR36+/tYsnQRy5YtBSIGBvYyOjrK4OAgtu3iOiEtntjsLQpKJIwGlVqZfHuBuf0FdG0Of37qcQ4PHMX3QQiV3btfZmS8hGLNY8OGDVz0hreyYPFK9uw/SqVeZdMLu/n6M5/i8tddxvpTO8BvRw/L3PrjO/mHD9/Ijj2H+MkXLufc15zB+LSJTwLVSGIkyphqAWl1k0wVMJMp/CAgmzXp7s1zdNNzMaujUceX4NtNdCPeXZZKJYQQrFqxBjWnU41sJqemkaQIwwZ6KPDVKX5670McHtrFBz/zL3ztB3dyxZuu5s4f/5grLrucBzb9ls98/JOUSkOsWZxnz8EGw/s2YmsKXe29TDaLSD/k4MBLvPDMAE9veJ6mO8zGvwywaOVc5mgJli1dQSF7lLnrjqM6OMPVrzqL5WtWktIP80+nacw97gqu+vhn+eqNN+Aogol9Uzxx5xcx8w1oOhzYOci7rvsAr3nThVQaEEQ+nqKTyUkMRTA9EfDU/ARd+R4aDYepmRk0EbG8O8vypXOpe4I3XnY2TemhJpOsXLGWk05qo789wkYhImIhCqqMMEU3buSjKyo6CjIEN4qo6IIygk/f8CRnXHwe1ZGjPPTnRwmET+A0SKW6gL/zou0FITO1Jlu2bMFQBFqgUt89QnlympeGRulZt5JkJo3nhZipDGY6Q9Otk1QVkkkLNfJajsA0UgqCwJtdCcbFWp2l5GmaMVu4FUWhUqlgJdLouo4iVBzbwbKsePDYKthxLqVNR2eBMIiolOto7TpW8lj2m4FpGnEAcUsDrUTxFD+RTOJ4DlrSQkNQKZcQ0kfXFBy7gW07RCKB7U8jQsgYKbY8/zQjUZP3vf9TfP/bX+Xe3zzIFZdfxarjV1MqTmIaOlEYIpTYyq/pkrpjEwRenIEpIPQcfNeh2QhIpzM0nEas5rAswtDHTKgx/Mq3mRork83m8XzZQti+4hjVdZ0gDGk2m4yPjZAr5AmDuPXTaDbjTE7XBc2kODNNvr2LdCZDqTxDe9YkXyjQqBzBUhzQkwhNRwoV1w9mJZiuE2dubn15G4PDR4E4w3J8YggpHTzPgZRBV1sfm7ZsRVcz5FI9hNKn3EjgNgIK6TbSvX1Yuk5vXx8dXSPsP7iXSy59A21tWZCSyYkJNAVOP/10tm56jnPOO5fJ0f34YUB7JkVESDpjMLB3D2+67Ao0o5MT1p2K7Y7yzMb9fPoT7+dtb38TUSDZvWsvhw4d5JlnnsH3JLTSFY+52Y4V7GNGsCgKqTeq1OowOQPKwTGstMBMaLTlc/heE0WB6WKZiZlNSDT6V8xFhE0cu0yus4uLL7+c7fs2c855r+fEE99GdWAfb7nmq5x05gV4hs/DTz7D7bd+lK37inz30UOMjpR421tO4nOLVuE38/TnVQy9Sk1VEb6JZ3somoapKzRKFRJtnczp7QaRQTUsZBTEuwXbo16Ntfm7du+kgU972wLWLL+QsSNPc3TgYX704/u57M2Xkci4/OC+p1GcFJ/7yPUsWnIcrz1zDY1Gg7tvvZGbbngf6y59M67XYO+fHkRRSyhRmc42hb5UB23pc/nyt77N2ecu46p3/og2ZS333fMffOIDFzHjOhx47j4O507j3OVL6Vu7hDn7m5x99jn85te38+W7t/Lqi9ay7TCMHnqZoLSfN1xwFl++9if09fXRcKZIZgvcc8dneOCeH1KaDrC9KpauE9mSju429hzZx7y+BYzbVbSETujUyGdzqJFB4AXYUZM7/7NKIptFbQru9wWBbxNKg0zSIopCfFOjNlOkZ34vaiLNyK6XIZlEUQ0iz8FQdbxyg56uXq654V2sPfVyzlzUgdqZwys6dMsQOv52TuT/Z9EWQvQDPwe6ieGLP5RSflcI8QXg3cBU66GfkVL+vvWcTwPXEXdmPiSl/MP/64X/y61Wb2AmLPZu205xZJIzVqxm+7MvYqgG807SyKYzeJ5HuVxm9ZoTmDevB0sKqpUphGDWeh7FEOhZSM2xUATX9QmCgCCIZtsjpmmSsLJoqklxphG3BiSzq0zHCbASSRRFa6FUw9Zx4pV9FErC4BWa4LGLxDHNtu/7WK2VvxcE+BJCX4kNRDIk8OPdgCJMpmdGWN6/jOnJGaadMkGU4Etf/RIIl3+68jrmzZuLIn0iD5IJq4WfNVo2+di96NguQRC0pIYQ+C7JdBpFUWL4um8TIQnDCE3E6emOH5DLpHE9B0W1Wp9RMLtzMQwj3v7l26i3ApSFolGr2TE+1PewTIMgzi9HSEmjYWOYSVLpFGGgUC41UAyXtOJiWrGuOULitkwE7Z0dLSmlR0d3F9OVKfwgZHx8PGbHCJXx0Qmq1QaGMOnqnMP+vbsJfIeJsWGaNY/RnhpSVUjuH6StLY9nO2gJlT8+9ijTM0XOOPM09u7eg2UVmD9vKZlchiefepJsMsYdFNIpanWXWr1KWzbL4NEDnHLieXQUknz5+/dBw2Ne/xwOHzjK2Ngwe/ceiotzRKtgxzs5Q0/GbSbfQ1VUwshBiIgWPBJNU2OuTQR2U+K5PqoSh7y6NkBs7vJ9gW/XCRWN/fv2ccar55FI5uibPo6MleT+3/wSdyyEaAKpamwdGOOFn97IxNc+yspFbTw9Okoyq3JwrM7b3/Vhfn/301THpzFyNbBUbMejPRfjSsOwQcpMEApBs+GQShdoODZJw0TXDPSMiZGwYjmtJxGhje812LBxA+eedyXjgzv41q0/5pZfPEYhmWD58QsYHR9lZMoll97E44/8iLBaQk+0EXV2cPZrX8WzG15gyWlLMINRFszvR4sgJMfD9zzOMxseY/36pRQUQbyLGUAKyBs66y//DPf+8HMs7zqVX975XfzJCb7xsW8hk708+IOv0Cy9hZtuug19eCNvfu+/8FixCJFgbOwoS+Z1UW26lKdKnHLO+WjZKm3W8fhOCVOJqFYD/uGSSzkyeJA1WieqoTI5M8bE0AhrT1pLNt3JUGmU1SvaKc8UKaR7ME1BpnM+mzf8CSOtUcjqFBIpIm0JoWrS1tPDcHsC9CRt2Rw11+bg8CBjBw9ghqM8+cRj3HH37Tz60KMsljD/wn+n8vLXkP+1QP7vFG1ieskNUsqXhBAZYIsQ4vHWz74tpfzGXz9YCLESuBJYBfQCTwghlsk41fJ/ehMIZKgwf/5CRo4OI4Vg3HcouS5RrcyyMMBzXbLZDNVag1edezbdvT0odY9afQpTN2eDCmJ7d5w96HkOdbuOUAwURW0NJn10PbaMSylJCI0wcGdlecmUiev65HI56rUyworvP3YhCII4tujY7ViLRNdjHq6nhrNF3/d9VDWJoijYnk2gxjxsu1FHU1RsN7bTppMZcrkCYeTz0raXkDkTUUqSTYTsGIK+BWnmtxeYnJ4in+rCMAwqlQqpXAbXdgCBYSXQdZ1apUYQBHR1dDJdLFHoSFCrN/GDmFSYSCSAgDDykYQIIhr1ckwJdGObfzabbbWaYjep53l4XoBpxUqYbK4NIdRYQinB9xzQdELfplGvkLDS6Ikc45MV+ucvY3pyCCtRw/NfiYSTUmC2eNqappPP5yAZD0K7ezpxfZevfvkbIOMVrC4iarU6fgAzk+WYM6MKGmFEpMOB8UmEqhKND6ObBqGn4FftVj5jgmeffpoTTjyRtatWsXXHHoQmSGgahimIIh9dE7x6/el4XkBxbIZisczDj9zDbT/4d/LdSxHSoTg5BCIC+YpBSxIRl2MFKRWsRC6Ok0rFhEeEBiooqpxFCfulIhAQyQgFjalJHyXSkcJDKIJESsGMYPzoJlTVwtcUCu1dGMkMvX1zWNDXz+tOOYNwZgsaCQJFQuRy0TU38dwju3ntWUt5z4WrsaOAj3zxEUb21rn82jcxOXWU+391HwVCksn4O6xOF+lckOfg/gE6++dhWgn8KERKhaYbYpoRpmnGAkJVQzegO93G+HSRJcctYbwOJ7/mY2z83WfRjASBovDUsyZOqUjf0nVMjE4QNotIBGqYIBx6jq+977XsvPhMTln8NRYuuojLP3Qjm7Y/we//8ByGsYOHfn0P5110Jq855WTAojE9yubtL3H6mhO585bLuP/2LTx83x3sfXIjpXqTanWUr9/xAj/7xS+5SFokCxnmr3kX+yca7BnbzeqLP4TVk6E2PUlfJseh7XtQCsvwD29npHEEx/HwmwGWZfLs7w5y2Vsu5+DLh2kLU/SKHItXnoDSCJis1OhiCYcPHKRv+VKGJofZv2OAvlV13vfxz/D5j32MxuQRct3dWDkdxXPo6VuAaiaoFScYGgyZ19vPyM49LFi8iNdd8noeeeopuhsRJ/edRKJ3Dte+4yp+Y70T/nL7//+iLaUcA8Za/64JIfYAff/NU94A3C1j6tNhIcQB4FTguf/mICiKRhBFLD5uOUuXLkZ3JWeceTqWonB0eAzb87DdqBU44NNwPMzIRZPq7Mr2mK09CAKQMZjfssQsYFwIia7HrZJ0Oo7skkFM/AplROAF8FdRP68oTaLZ4INXet9ilmsiZRxNdMxNqSfi3EZCHz/08YnwhSSUMa7SDT0sNUHkeIhQJ1IEk2NNlpzQy/B0gwjJ4le/iZqAj3zyU8xvy1KaHMbSk0SuTzqdiwNQrRQyjC32nuPg+B4CcGyblJVsZVNq5HIZKhVQlAAhJbpqEIgWLkCN3XFArAhRFJxWvzuGbWmx1dcwmRifQGgGqVTMVfGIMZhRFGEqIUro0ixPYxkpanWPbMrCdwVJw2KyUsQ0dHw/hvRouo7rx7KmxUuWoCgG17/jmlk+uRRgmDEDJvQjAgmqFKhIVAJCEZMdo1AgQxAiIJPMUK05SNvFMBNYyTyl4gyqKhg+dIRtm1/ilFN3c9rZ5xDKiP7ebnTdZ/Vxi3AaNocHDmO7Do7dIKEbhG4RXeiUZg5CEKGjIaSHL2hdvDVARREahp5qafeDVjJP/BhVAxkKItVEM5IomiCdM/BcG9+tEngekpAIBaRkbn8PY+OTeI7P5//tJs59zaV86Tu3s3/vTo5beyqNho3ieKxYfTy7NxxG5EzwXfCyrD/tBBq1Ir++9zEWffZiAgGLFy/m6KH9PP/Cy7zlbReyYs1yvvjeGyjkVETSJ5VIEtZqlIpVFnf2YiomdU9BMXU8zwffx0yk0HWNIPAQqsC3Hdo70oxPDTF37hoSKQc1nYxNO0Ev0hlBlRqf/ui7uO3nv8YZhcA0Wbnkdaw67VV88xcDrFs6nx//dDuerWBYbUxMFTiy5adcc/2t/OL2D/GNH/ya5V9fzts++inu/M7X2b/vEKcdfyI6Ple86zLc8QFGFq5j0dJLOf2Nl+H7PvW9j/D6ix7g7EsvwvMl/fMFKgENNEbGYfuuKSwtzYO/uYeR4WkySZ0wSuM3x4lUlWbTZeWyuSzpW8DWDc+zY+QoKxevZMsTD9Ezt5fS5ARf+PZ3WFM9hbt+dzfnnX8hPfMWkLFyfOfGL9GcOETaMvDdGrkoi5lvJxIBhc4cbjk2/E27JZzybvbuGGV8eB+vedMN3HvHzfR0djBdHuSZ+7/DnJYU9m/d/rd62kKIBcAJwCbgLOADQoi3Ay8Sr8ZLxAX9+b962jD/kyIvhPhn4J8B0ukUbrOB43vk021UpptECMZKR1Ail1qpGtPlnBqB16BWrxAJqNVtAgkikvhhgKWaeH5M2wsjgaJIPCcgYeloio6UAoGC5/q4RjyQc3ybpGEhFIVkMo3rxn1cp9VOOTZk8wOfCAmKwPUliTDAC3xM3Zgt3oZhYJoRuqLSsG1MU0dKSBkWshEQpDS8qAJ+g1DLEgQCM5pBaJKOXIonn3qeTJtBRa7lT3d/my998xGeuudeXnX6XCq1MebMbadYKZLM5lAVSb0eA7IUVFKWScoCzwtwXZuGHRdE37VJJTP4pgCsWKJHFPfCFa21G1AJwoBAOqTSFo5TI5PJUK1OYxgGvheSViSdPd00HYd0NhPn3+nxoFczDRqOg2KYOJ7L5NQInd0LcFyPrlwXp53zeu6982YySR99dJz5/RaqiN2YABOjY+QLKRbMX8ThIwdJJhMxZ9oLURQNReiEMr6QCAWkIlGiEFVXYmWGqhAGEfVGGYipoEEQ4DjlWc553a7G+v20z57tGzjrlOUUi2XqNZutz+/FdyNC6RFELjLyqYQhthNiFky8kgThEMiYey2lTnt7F4qiEQZxG0xBbYHD5F/tJiASMQddhB6+jPk5gWahG1nau5agKqCKkGp9gtNOPYETTziOW279Hp0dfWzfOcWKNXUO7NrFWRdeQaK9nfnHr2LXxCC7N/wkzqOpAJrG3MXreeiRP3Px+ecwd36Gmz79XdasOpUbrzqLJfPnsvkve/jNnQ+QKCh88QffRg00Pvv+D9PRVSCVTqOoEiOtUKxOoxtzwZMkDQ0viqjX61hWCk23CBwbP1JplGysdIp6aRjLStE773RKE/swUpN05tZRrNT41Gc/Q+B5BPUioZZncPwxHvn9vbzl2s+z76VuerotNM1g29SLtPUY9J/xVUxfIunlnz/yUda+6dNsevg/efT+Z/nxbb9g/drTmL+8ny/euIalPSW65s3Q1r+Yz7z/3dzz+5s5uv5KzliwnM6lZzF2+E9c/Y7PIoOj3Pm7QyxdPZ9CvoMF/QtYmsyz9eATGFEdYZj05DMYUlIslnn+6cfYt3ELjXAvIhRsmXwGBIyPDpDK9/Lp9/8DKBEXXP4hfvof/4JqqGh6ARHWQcxQdySG7zPjp5HJPjzH4x/mLsdNZ3l+8wDzFhxPw/85N3zzRW751nX89tabUTnE5PBRhJrjSFs31aHi/5miLYRIA/cDH5FSVoUQtwD/Ttzn/nfgm8A7/1dfT0r5Q+CHAF2dbTKRiPGpQjOoVOtkrQyaaeL6PrnOPAndIKHHQPdCoUBXZw8HhicIhYYmXZAKmqa3flkFKWNnpFCVVmp7bMJIJGKKlut4RKHEj1wUzUUSIgWouk4QRaiqNutoVFUVtSURJP4bmcVO6nrstNRNvXVoGbcM/JgvbZo6nuOTlGmCUNB0bIoTw/Qsmo8QATpTlGsNtr24GdNI48mA3/7up8yd08Z/fO4m+he2oyRg/uKlNO0aVipJWz4NoofBoZFZbojTjOWIqhFTDOP2j6BcLKEgWr9TRBiCoggMzaBej/Xtvt9a7Ukf1xXouobnxSn0cZybQ71RJZWOo+AGBgaYM2cOqmYwOT2DrptYiSSeewz25RNGTUIEmtlLEDaI0Kk7PobXwFMCZqpN1p3SA4BqKjz9/LMIEeuxHdcmDGNMb5wSJFFV0Yqdk0RSxMhSN4p50wKE0JAyHmwqSgzjEgKWr1jAwoULSaUsKpUKg0cOU6s1yaRzOC2eehj6hIEkjFQajowZ7jK27Eci4P4n93LhuYuJgJzIxAx2RcP34vguiFOQFFUHIiSCSAJCgIzPRVXTYoASIjZESxXbkRCFSHx0PcuGDVt47JGH0FSfUhgwMvIQv3noZxA2qIc6q065gMmaoH/eHLB6CZ0xQmmgRDa33/tbAuExsPEFyvUplq9YgIgm+MxXbuOmz72dt559Brc+2MfBXUd4ZudLNGoOt91zF6NDB/jih6/DzGRQIhO33iCVr+O7Lk1HgG4hdYswTOC5EQlLx1QNEopJtV6l6tTQ/CRrT34zy5fOoa/Ppt1qZ/MzL9C/ppdd+3Zx6jlXkM22MeVVcEKf/du2suFXd1GqVTj97HUENWhr76enAG2FBQxuWcCDt36fx+/6JtsrkvUfei1PfP4fufupTVy/sI/F3RKUHNV6jekXnuKyt1xDPTjAx2+4gbsiD9U2WHzh+fzqR9cTCUHvyjM5um8HA1NFhpatozKyD6c+yqJ1Z5HyTXYOTnLRRRfhR0MsX7ESoYTs3q0jVR8RKCjoJE0Tv9kENY8qHfzSDJE3TuDniEQjVogZFgldozvdgZk0yS3sJ1IlLx/ZwYlnnIx97wNEocJPX6rzq4fu4cp/up6XBwaYGluEomsULA2js4/kSTrc8x9/s3b+LxVtIYROXLB/KaV8oFV0J/7q57cDD7f+OwL0/9XT57bu+28OIJEiwg89ysUKiUSSkYlhFAUifJKGichl46BNXcdzg9nBnyKjV5jV8Z9sS7Knzt4nj7WghUKEbCEdBZoAs6U/rdbt2SJtWvFA7tgKGsBrYZ+VO/oAACAASURBVGPj984saApeGVwe66tLI0bNKkErF1KNMZ4AqQTIKIDQxXXqlKdnKJaq1GxJR5uJ1NKcdvzK2Nvvb6etYz2RN4NhZJiabtDeXiBE4vst6JAaG5CiRJwuT6i8sjvwQzzPxbabGIbZAmnFvX5VVeO2kecjlLhQR4H4HxKjoyDCdpskkgnSaZNiqUZ7ezvNZqw9jkIPyzCJRKyQ0FUVzTJwPA/Xs8mk80RBRC6TRiLJt7UxUymyc98eMlaJVcevA+Atb72a7Xv3ksvl4oBk30fTWgVZxkqS+Lug9fm/0paSx76QVsFevnwpK1euZGRkBE3TmL9gLtPT02zdumMWsZsw0wRB1OKr+ygiHjQ7boSia9hND89xUYWGFoT87lc/wrev5me/fhiBDaSwbZt0Ok2zYSNlFPMvWufCMUAZQCQiwjCmQWrCABRUGYAEidpCDocEYYiRtPD8DIFbBhQQNQgUdDOHa1fZ8dJWrjj9QkYGh8gXjqMyWmbuytXc+G9fYmR6kv+HuveOkuyq730/+8Q6las6p8lBM0qjiAJIBIkkAxbWxcJkMEbgh425xgE/mwfYwMUgwNhgG4zBBgNC2DIiCBGEEMoahZE0mhy6ezp35ZPP3uf+cap7Br9r3lvvvbUePmvNml7dVV1d55z67d/+/r7hx3fdyYRtYRcUi6cgP+hSqxX5zg+Ocs3zzuHSSwcJ3UWOn1RU8mW+ets3eO5zn88Lf/313HnbrfiBwnYKeP4qlg6O6YCVIgyFIMHQDTR0en6bUtWmPlCm2wxp9hR5R2N+ocdP7r6LthdQKzvMmXDRpddyfN7jyM+OYloOrulxx0c/DDLho3/9Gc6/4AKedVGdhw+0UEEOPXIYGupy/48/xRu9d7LkDrN59/l0XY3bv3Mn7/mtGxAxbNta59hxB1FNaCw+TbFkcfMfvpNCZYS2GubYkz+jsm0HUa/F3KF7qQ/uwtw6xvzx7zM+spPytj0cefwozoBFd2WeW74yy8DIGKld4IqLL6cwMoHyGyxNn2Bm+iS9wEfXYy6/6uU89ugTHDt2gpw5QkrmHJrTFLqdIyHlxEoDZULJMYgCn9AXnHVhlT/67HeY60pG6iO85jWvpiIsrrj6OsJEcnLmKPlCjoFKmYHhqf93RVtkVesfgGfSNL35jO+P9fFugOuBp/pffwv4FyHEzWSDyO3AQ7/wNfoZkVauQMXIIWVMvTKAIQzcboCDIGfapJqOlJkVar0+yHEVZ77OrQChi37RVFkOXDFHFPloWrZtNY3cz8WUrcWJxWGC1/NJoojI0NcT3J1KFURKGAWgiSy4U0ps20bT6DMrjHX/bzhN71or4Gtf5/IOnZ6PFWRdeKPRYuuOlFoVlmZnWFhaxKiUEAa88L/dRKWUIFKNHWMbqQwkqKWAHjFut0McxwyPjpLPF9e54kEQZhg6mb3nWicImSq01Wr1k6kliQywbJ0olNg5E5QgCMO+Kb9DGAR4bpd8Po9hmWiawDZtklhRLZdRKmVsZBRNyzpRXdfRAUvTaDUaDIwOZwXcdvB9n0a8SKU0BgL8IGBkbIJKuU6aFvjQx97DXwAD4zag+NznPs9f/uVfcujg0wghqFQKGIbFrt272bBxko0bJ9B0Qa1ax8nliOMY1/NoNZv0Ol16rs/jT+zl6f37SFPw3IiTx2cz+91EIWV2/btJjyRJyOftzEwsTfp8/JTIjzB1ix3btjA9M4OI63z79m/wpS98CU3kMO0qpino9TpIKSmXKvR6vazzPyPnFJEt8LqR74dGZ/cCKoueIgWlYvwgQaJRMAvEKPKVAnlNkAhJY/4gKQFxCLvGB5lbaZKsNFg+uczIxi3sufwq7r77bt7yuj9hx/Mu49Lzd6OXs11e0TGpGgN0eossLDzFBz/yXd74jnfw7tfsYeLBcX78g70M7Jjg2JHHGN+0ga/efiuf/MD78NMOU6N5CrZFS1pURiaxnCJPPj1NHIOiQiqhtdBF6QK7UmG4WuNUY4Zitc5ffOQ91AaKtPN1JrpLHFDw4qlhnlj1uXJqkMLALr701S8Re6e46bWvJFEudmoS6gqkRENHCQk6/MNnbuarf/XnHBHj3KwNct8P/p1E/zu6KuGDH/0Ir73+Piz5NE6liN0dZvNV55OrTlFzzuL2rzVoH+0inDwjo88iiX30oMzIyAV0Ox3mVk8ytXGU+WaP8tAUoe9z8tgslzz3Gu65+z7cxMcpVJifXmL7zvPZsHUnTr5CqBI0JZg5/hCaSlBaGZQJVh70EpUNG3jWnivJ2TV0u4xtSCzHobG4SuBVCZdmOXTyJGHQY3DLJo6sNBA6hB3JQN1gecHFnDvMW35Bvfy/02lfCbwOeFII8Xj/e+8FXi2E2JPdfpwA3gaQpunTQohbgP1kzJPf/kXMkaxqa0hlEfQy2pdl66heSMvrIYWNsAKsWKFk1mW1201ct4vvxRRMC6EbJEncT3LPgoA1DTTNJAx9LKtAIvtpyrEiTTRSHfKFHF6YgJal0pimhVIhQmWBoKTZNlYX2no+ZVaYQdNY/yBaloVIIZFJP8sx7tuzxv3td4LW9wnTRQmZCFKCdTbK0lKP0cE6nW6L511zHQKDUECp7OFYDq5u0m12qdSqdF0fRNYlFgoFej2XNBXZgM+w+jCCQtMydoWUCUqCaVqEYYRt5fuLV1+O3i/2IhWIWKKlChUrkIqk/56lYWCbNl4Qki9aqCRmenaWqY2bSLEyXN0QmDkNoSSohCTwKTglNCNHFKaQ5nDdALd3Cm1KZ3C8yqVX3gA/u5U9V7yEufkZ3vqbb0UA9YESI2OD/Norf4NioU7eqSCTAGW2EcLE73jMzsxQKpdRUjJYr7N5aoJDx46iaxbVao6lxTblUp12t0MSJximRhj56FqOQsGk0+nieX6fi26gVIJt21TrFYpOhXK5iG2AkU+JgoiBco6e55KKLF/UMKz1nVapVKLdbq+nJMHpjlshEVpKnEiEkiiloaGDyNgYQmjoaJDoxKlHmoCW5tBMEI4DcQqJj9tawIxNPvfn72Jix7nc+OZXc2pmjue99CU8/vTTFO0CQipkJOm6HsV8CdloU6/WCDyP3Tu28/lPfppffdGvcd3lO5hwivzb9/eycXKcu35wO7ec2st5541w8nAHz12m14WIMmObNjE2PsTSSpO5BQ/bqmae7abMYDU3oBWsUKkNceTgQ/zKJa9EihLkzkbzjqE0wdY9z+ZUY4YP/e0XuOaaF3D06b2kSvGH7/8zNm7exLYt24n6XjdHjx6n1VjlPe96C8cef4IPf/bf+MbXv4tmCJRcIkwSnDTPjS8r8BqzRBiaFIMmDW+A3t13ceNvv5fZeYOh6gassR5J4iGEw9DAMHMzpyiUykzu2kCn26RYLqD0eWTiMDw+QYpBq9uhPFqleTJAugH1zbuYXW0xM/tTDM3k6l95JedfdjWzJw6y0FnGKFaplMYZ3biTIOyx2Am57Lrns33bZjqzCX4YUTQqNDttUjxmFlosH3oGmYOuDlEQ4tg2o8NDtJpdRCox4l9clsVpWOH/v2NkuJ5++lOfJApTmp1VDFMSqTaWUSH2c1RKinzO4GcP3M3o2AQvesUNfOxjH+NHt32L8aEaaeSiVEy1WqPT6awXTtu2cV0PyzKxchaJSlEqg09AZSnLcYxTyOO6Hvlc1h1alolp25nkulBgdXUVSLGsLDtx7TVyuVzfRSxGygQ/DNB1A4GJYViEoU+hmEWjdb2EvAmhVGi6yfOveQkNN6Lj11n1Q3rLhzl44jF6jQJpuMo//vtP+cKnbiJ2U6YG6vQCndnFeRqNBlMT43iBixQGBw4cxuxj+WswzZkKUK0/bBwYGKBUKrG8vNyPR8tSgGzbxvf9/iJQI+17tiiZBStrho7vZ6KhYrlGnCjK5SqmaZLLF5ifW6ZQKKEZGTXSdgxSw6BcnUTXLIr5CgNVhycfv4vhqkbotjh89CRu4AEWaRphlupoOtz4yuuZ2jBGwTFYXFzm9tu+x7FjJ7CsLLVocsswhqFx4tAS//rNr/PTe+7li1/4R8459yz2Pbk3g7ryIyAUSZztdFZWlimXa7SavWxRN1X/WlqsrPRTepLw53ZhlUoJ09RJ44wmGccyox5qJmgCqei7S6osjd5xCINoPeJOqcy4K01TpNCynZjQ16E2W7PQDJtQZkHRuWIFlI0vPQws/HabJGpgFFokgYueSMY27GZgdCNuCuOjWxkeqTMxsRWlF7FzZXqteRwEYa9BnPhUaiUcRxAHHTZNZrODen2Qk6eO4a7qbN2yi7//0i0cPHIQs7BMHHYYK+v43Sb52iT50gTDo+djDdRodHq87JWvZu/eA+y9f5lcLodT0tAMnaXGKq1Oi1LeYGKkxGuv300ulBTydUwjYnZ5nptuehVnP2szZdtHD30Gx7fR7pgsTbcJpE9rJXO2O/fCPQwPD9NuN3ng3gMU9JBup0mKjiV0sG3+6vP/wmte+TxSLeK225q86Td3o8cxrreDKNnLZTe8jrA7Qj7yeeD+O6jUqqR4NJeXKBZqRFKRy2XMJU3TcHJVNENHqTJOXqNcNyiVSti5QVTqMjt9guayTxD6xHHIaH2QSn2AZ/Y/w+TYBGMjwzw9O4+3sER+bBu6CujO+2j5EBVGVLefTbFWYvaBf+M9X/wava7k0fv2EkmoVcexbRtDtzJNRT6PUhkt9paPvBIBe9M0vfg/1stfCkXkWraYTFIc26DdWSAWbRqdBvXqRtDyhEmMjGLiOPOrXvfIiCVGmnWKaxarazCF4zh4nreOPxsq8+A1hYEQKUJCJBOMPswA4LoeqcgDIjNuURmWaprWOla8Zge7xmXOmAo+1XqNTttF08V6EVhbFIUWg2YhZA6lUkzHQgsVqW5hF4uErWPkS2VyYZFUwMG9jxGHAWGoWGp1kHGmvlRK4QU+dt4hVilOPkfghdlcQGXwrt63pAXQtAxz63bbfZvVdH2gGsfxuix/Lc5N07T1DtuQJjophqFhmk4G9eRyWJaBUilHjx6F1MjCUBsNisUids5CaQa+75Mv2LS7HSwtxTTyRG6TV//aDRQqQ9x/734OHn8aHr2HvK3YuHEze86/iPmFaW699eucPHaCen2Qt77tjWzevJ1vfetfsQsWy415/vsfvJ2jx4+wceMUpbLD5o2TPLP/YVZXujBQykzGWj6GCYVCkW63Tc4x6LkNpBcDWaKRShPCKFvAM/ZPjiSJSJII2y6BaZKmQeaXrmmZBwwC3cjsczUNgsBd92D3g9P3Gpyee2iahlQZZKYhkBooJRFCR9cyXw5Eio5AJZJyqUBtoEq+4HL00H6inkvgdWg25rEHhtBEyuDoGMrUaTaWKOd9LBWhGybCtEiiLqYlMHRBLwzwPI9et8ud37sDz0945OEHWG12qFeH+tBNj7yR4LuKKIGqXUAzLSSCxeUl2l2XU3MnqdUqGEaT1dVV7EDDKeQolkuYlkbotZmbPcXc/BSm8GBhhWqhRteLMWOF0fTYsW2U4ZEKt9//EGm+TOQJYpXZRjhOgZ/c+cP1mMFUaATlErnQxdFhQYERF3jrO97G298eEgTb0aVi+84LePKJHzE+VWNuRmP2mSc455LXcPLIQURJw5dNRNykXi8SyAhNaOi2jqlZCAzcXjNLB1KLdNqKlVWXWqVKzl6lXKtim3l27Jyk2WqjaRqH9j3F3NwSpWoZb7XF0U6HV/3Kjcy1V7nrrvspj4zSczzqEzVanUNoWguiVURhlKTnMlyuccGeXVgFh/m5HgvzK/0dPiwuLzE8NIpU/i8sl78URTslJZAumBoaLtu3DVMrjBF0BZ2ORtMLMOzcaUFDmqJrBlEEcSxJkhgnb657j8Rx2GcQZNxI07YwLBthm0TSxbQyU6hUCMpOGYWg08u8FZxSATNnkzMsQr8/sDMslFQIPesmfT+mVMpUiRn7IsayLOr1OmkKbi8kS0wT68k5mi5JohgoIImJREogEqx6BSHG6cw9isEor3r1TQDc+Z2vo08UsKME6QpKoxVwDXL5PMuL86Br5AslioUCpp6j02n1vb4zJGptMYnjsC+EyTyrJycn6fWyzsZxHHTNxPW66Lqecc+RaDo4lo0QKRKJpgSNxgqDw2OEoY9SilKpQhRFGAbMnpqmUqkQBT0Mu4RmaQRJgCZcTNMmDJpMTE4ymqtwz53fYWLDDi465wouOv88ePQerrvmZXz3ju/x3e98k3a7zZWXX86OHTuwrSLbd57PX336Y8yenGHjjhFGRwf5+Mf+ho2bt3DtC15AkiiGh0cpOEVSBI3mMrXqIEks8HyXFA/QwBds3rSZG1/zShbnF9i3bx+PPPLo6Xuw7zkDGobmYJkFet2AVORRIiRVWeeu0hQkfZ/1LJDa910sq0KhUCDue7SshWjEicQ2TDQzSwnKWTahyuLdsrx1gzgOSbUEEx3NMlCJy9FDB9FFjzRV2LrJ6soCCTEXnH8BoxNbODzfIY46FPUEt7nC+GQVz4qJ9RS/scJjD+7D8zssL84xd2oGIVJGh0dIQoVTSxkt1zBlgoh6SNeDgsFSpBNGOZJGwO7REh034tzLLmR6dpqFhTlSVSKOfDZMTtJ0l/DDgDiKILGZqG5Gthd58PbHWGo9xYaxDeSLVZSeRd9pToF2LEl7AZddfiXTi/NMn1xmoD4EcZe5+QVyjkMiI5I4hlQRdnqEAroa2PkChmNi0iaJY7ZvK3HsyP0cXdyMlha56lcuZt+B83jmxzez9cJXMLFhO/t/9i3e9d4/plTPMVgbJWeWSVNBt9tlbm6WO77/I55+4gECdQIhNFKpEWMy35ynVJpiaS7GDUN0q45tmwyNjHLBc55LGEXkjJij+/eB0PnW3f+EpZWwKiF7rtjI3bffTnsxpKQNoC+7VCaLzLqHaSy08HsmZpqnvRKhWyaFSg0lNVRqYSU2cx2P/yv045eiaANZBwLohkmr4/P1r9/Kbd/Yx9e+9jfIIEQJhZ0z0TVwXbdv4JQ9N5d3UKlEpadl5GsQSRAlKHxiKdH1rLvKeppsaOl2M/zZ0DRQKTKOSTQNpVnEMiGva8hUYZhGn3GxFs2UMVDiOMqM7KVkaWmBqJ+WvtZtJSojgcWhgVIxuuGSRIokjFGJpOF3GBjZRKRSAr9LYAS0laLpeSQn5thUnMLr+ohOlyjOjJy8nk8YxlS3D1BwisRBrx9/lik917buayZXGbdYrif2GIaB53l4Xo9yuYqm9Rc/Kdfxe6Xr6Eam/HPyWWp4u90il8/j+6pPxdMZmxhlbm6OJInQUmistrCLRXJ5B9d1GR0pEgQ9Ui2XRWkJm+H6OBsnR+gG2W7ga1//F4ZHa3z3jju58847uf07t3L27k34nuLUzHFueutNPLHvIVI9gtRkw6u2IBONqclRJifHuPeBexgYHWTEMnnikQUazTaDQxUaK5Krrn4uJ05Mc9auXSwuLnL33Xeze9dOXviia4jigKee2o8mjP61jNfPVRSFaKYiSeT6YDmJFZphoguNREYoKfvXOUXGmdgmiWNEv2FQSqGkQgoNTcj1RVUzcv0FAGIUmi7QNZMwijE1DdOwqAwM01lpg5aSkBEF4yihWB5FaDm87kmUn9BYnca0BF6vgNQFrY6PO3eM5cVFkB6GYTA4XEPGCavNFTQtIEozczPfizA1QapS9AhUnHX93U6LOJbZgJaUkeE6jXaL4YFBZOyzunIKp2yD0gj8EGEKDNNEr5Q5ePgQRV1jx9gowzvPZqW5hIHOkZkZNm+5kPlWQE5qbNu8ne3bLuXUQpurrzqPOEn5q0/8BbqQkIKdAxkkJPlscUxclySq40VLGJpF6+Qxtm7dzLmX38B3v7nKzFKLK55zMQ981+Pvb/k+t99xAN0u8jv/25uZHC5mylQt81JZc5f88/f9NkECxbzg83/7He74/rd45LHbmT7p0e0eg9SkUt1J128TWQXm5qbpuh6FQonC+DDju3cxu3CE9uHjbLnkAhYe2s/DP/U4//Jnc/jQftKWjjVQZWxyK0/vu5OwHWDLmEUClGGQxB7VSgXXizDNPLatQ6e1zpL6z45fiqItEBimTpLEGEaRRJq88GVv4Opreyz2ejilClHkY1sOnU6LSrHAhg0bSKRJIiRuEAKKkumgGykEBpFKyPffvUxTDKVAZANBGcp1/nUxX8DJ51hdXSZNFa4fUxA5klzWJceRT88LsHI2qRdkeJdjEXgBxYJDEsf0ul2K5QJJJPvPSUhUlgVooZHPl5FRilPUsO0YfznASE20pE25oBgslZixx0jDE1z0whdzaNFnebXHxqrG0cYpdm3YShR3EVIio4iRkREazRaN5RWSMMF13XXxyVqm5Ro8kn3vdBbmysoSw8PDrK66GUPE0IiibNFx7DxCaOs+LoYuSFWC73oEUYiVLwDp+i5GCEGv08EwdEzTYHF+nqHhDQhpEAUeqci47anUGR/dwNzhhxnJFYjcFL8F5cHMbuB/f+9vs7B0nFf86g1s2byTXrtHY3maWs3m0DNLXPP8V9PrSFS6QM6o4Ps+uplneXmBQjmDa6xcDb8b8dbfuopGo8nxE9M89+orCUKPcsUmTV2cvKRYKnLs2GH2PfEoF+w5m6uecxnfv/MuDh8+jiYsdCML3EAkkCa4bg/bzAFgWTZpmuWCJkmKbTv4gYdlWPh9mMTK5YmjBKXIlKYiRbdMklhiGjqxTMhpEEYBRj5zT7RsHa8TkLdqeFGTwHMZHqrRXkkxDEEiY1JMarUBjh06jEgP01mZZ3VhFpG0KORsVgqZ6jeMJYYGKg4y+MYTfasDhVQRiVRowiJKJcIwSFItc7OMUpI4G9a3F5vsve8ern7xq3n6sWfAUoxPbeHQwacIg5CRDXUUbYbqA/SiCo1Wi4f3PcbwUJmzLriAa66d4m8/8icc+vunQAguf85zKBbzNJdbxKHJcrvJympKJ+5x/oVXct/hBnauwM1f/hnvfv3zsXNDhP40oCDKyABpChVHxxU25fwoC62nmHtC59Rcl04vZcfQHm75zKeZqhV44PDjLJ0I+YdvPsbMqs199x1jdf4gx47Pc2LuCLXqJM++/Pls33oO27dC0YE333Qdr7/phSTp32ErMLQsh+BzX/kaf/f5H/L4g18GIWi3FkhqBjOHAsziBgYGBtjzwhfRXm3j1HfQaVgsLp6ivbDM29/1AW75l88xtOMsuL3A0GiZttdFepklRLfVxqWH7eRxvQ6aaTCcjzH+g9//fzx+KYo2/YJiWRa+71MfqPH0M4/jey7nnncRgZf2+c76Ov94raOW0iCVEsPI8F693/Wm+looAetqxTWPEFR6Gr/tY9OGYSC0bGikaRqe56H3MWzLyk6irmf0QalkX6SS/XxNwWfomblS4PvYTjbgWsOMTw8JWYdO1pJxTFOn1WoRhiGlUom5uQXcTov8eIGW7+P7HpqeEoY+SaLI5W3SfodWLOZZWllB17JdgOcFZ1jLrjnOpesBDXEcrxf0tW5wjZ645uqnaVk3sv43r+0akgRTMxBAkkQUCgWq1SpFVWL+1ByVSiWDChAM1AeIlcx2IX0qnO/7dMKIdrtNKqBgZHFjT+17ktHxGvV6jg0bhikVE8ZHd6NkFxmV2HXWDg4cegzNSCG2GRvNEyVQKVXZtnknsYwYHhkk8HtEccjgcJ2du3bSaDRQKgEk23dsJggCmu0WmtIYOGc3Rw4d4NSpU7zoRS9iw9RBfvSju8gZZVrtFTZMbWV1dTVzRYwzw6e1hQoygVJmTpZxtJVK+jYKp8+5pmloenZfJ3HQH2rGyLSDaVuEbojtFPE7LjKSYFgUTJte4jI+UmV5XhD4MQiw7Gw30GmvkjNzBL6L22tSzme2DHEUkaJh6jpRFGQq4USQkhD4XXTNQqnMBti0suE0SYqUEbppkaYKGWf6h1KlRJJEIA1a7RXsQp6RkTH2XHAJX176ASOjdWwnodXpMlCrMDm2E+HD0vws8yLkwOPLnLdnD5dddgkA8zOzLC8s0m4vYlkWy4vLDAxLiiPDzC0tUatvY25pjlqtBmkxy0hFZTFmSWYalZLQabeRaYK0uyh0Rrafy2/+/vv41td/yLd+cg+5YpmlmRm+95nPsGP3C/n8Rz/Aw3u/Q+gFoC2CUOzcfgNHn/l3Pvf5jyBEhWKuQKGyxLMuuoG3ve0VXPWCiwj0IjkFyoG3/Oavc+ONN/Ivt7yCP3jne3GDw3QaMdWxTbjziyyHPYTeIJ+3GRoaYXp6meMHp6lVS9z61c8SJRrbpsbRy4N9H50YFXsEKiCna8RSkYY+oCNkttAn6r8IPBJGEXEE7Y5HKmB8bDMqkbSbQZYYLn26XpYSowSUShXipJ+YosR6AbYdE0Xap/xl9DzjjAGi53mINPtQ2badJa6j+j4RWQcZhiE5p1+A+97SYRhS6IfeCi3FsiRRHCO73czEX8+eK/u87TPDBDzPwzR1wtCnXCqhaxKlIJ/P04yzgVki+zTBJKHR6kASYxs6I0PDLC0uUa7a2DkLEUWYlqBay+N5HYaHR0HEmGaOtQi1tWIMZwxCxWmvlPn5ecbGxpifn+8vShau62LbDkkSIZO1BJ6s8OfzJpZl4McZy8LJGdk5TCQLc3MMj46ii5R2q0F1YJi8Y9LptEg1Qc7Og4JUJtTrdWRrkVgmNBqrJGQDl2cefIKxlz+foNehXq7w/j/6U+LYpV4TrDZTrrz4hXz1y/9ErQZIDddXaCmMj41zamGBOFakZNxTgSBF9P/vOz6u/wyUgFoRzjlnFw888AyWCTKKOfu88/nxj3/C7737dzmwf5p/u+0WDFNiW4U+/JWgZIwQaX9RyyyA804e2ZfjSxlnQhohkUoi0DAtp+/bnnXChm1h5myUFOTMHMoPKRYdWt1jDA+bvPnNb+TJQw9y5MhhQk+SDKzEowAAIABJREFUsxwSFfKr17+UZw6epOm2SaSLqUUM1su0Vk6hqRg0QSpMpFKoNCKOPHTTQCY6MrFIdR2ERMek1+n2r6uDMARKJqg0JYozE7VYRrz0uuvYNLoVN8oxuXEbs7MN7rzzJ1zzgpfidpZ55sknqFbLbN88Sei3efHlk5yajVmcPsQPb7ubOAlpt9vYto1tWn3PGQ23F9AJAowgoGQVcMoDBEmK66Y8dO/DlIYm6S4dpFiwCYIw263oOT74oZs5cuBpvvSFT9NqNyA/TE85nHPFc7ju+pdw1fgWfuMdH+dvP/4ern3xa0nSfTz0wA/Yed4F7Lv/XiZ3PhejUGRiywRBIWBwY4mqlcO2FMX8IKurCffv97nj3rv4+7/+Y4LO0yC284EP/h4vv+4G3vGml3Hjq6+jntNouHDFpZdzePkYaaiYP9hFmFXMimRic4VtWy8hljqP3/cjpjZv4W8//l5e+4Z3sDJ/KmOLhE1STTBam6LjhVloCoJYxei28XNMpv/V8UtRtNcGdppmYpomzUabREakUmGYeQqFPJrIAghimbmOlasVVJp5cZtqjaGRrk/rsw9X1iFmSsDTna2Mk/XOac072vdTNN1E08L1gSfofRtXE5km6x3rWreapinlcpmVlSVytkUSq3UHO9MwUKmx1qSi6SD7trBrXayu66hEYeogRFbsfd+nLT1EmnlYR5pBqZzhadt37sgSu+PMMrXZbBKEPXKORRhKkkT9XME+8/ye9hbPOsEwzGTqpmlmC1eaZoyPfB4hsveaSUnTdVaOUClKZO8BobBzFkHbX/fULhQyP+EoCtCdUl/mnR2ObROaJmrNFVET9HpdAGaWGsyenMauVTl86Cn27DmPbnseJx8gaGLrOpPDY9QGJDnbJpGK1ZU2U1NDRLG3Pgx2SgbIDJ+XMiafz+M4GaVRSoluZAt8IW+jiZRNkzUUgkOHDrG4ssw//uM/8IbXvwmhmQzWxzDNHJ7fII6TdXqklGsDy+xcpsh1kVNmFJUgRNYs0IemkiTFNOyMjQT4Xj98WvroGqwuLVAt23z72//M9MxRbr/jy+x7/BE0UuLIZ+OWUZaWVuj1eshYw8zlsExBJ/Ky66trCHTCJCGREpVKhK6RShtdzwb1aSpQiUFCRLFYQKqYIPKJwpA1L/Bqrcq2bdvYumM7r3rVq3j5y6/hLz/5FPMrxzhwdJWdW8/hxIkDzJ84AWFIoLdZmD6EpkueeORxdOEyffwR6vU8KkyoODboGj2vne0yOpm1sUxT/J5L5PdYmD3J2RdspGgW6LZW8NwmpmHh+z2UgGdfex2XXPk8VkPB1ddexz/942cRwkB6Ie78NEsLXS44p0qS1KhsOgfDGmT/3n1opRkcZbPvgbu5886n+PDHP8u+Yyc4e9fFdGOFN98kGijghT7L6RxHp4/hOAXCuME1r76OuWMVurOLvO9PfocPfugv+ehffJx3vf16XJGihMsPf/pdfvy9J3nDm65GL5SQyRJR02JBVdCTJ7CqKV6vw8FDBynnDL7xz5/noosvo9FoEUcgdBPMp0iBYrkCuk2hXEK37P8qg8isA+z1XITQqNVqmDlB6MdYVhk/6JEqnVp9gPmlBVzXRdezTELD0NCUAC1jdoRmnwWRZKHAhrYWaSXXfaJ9L+NiZ2nqkiTOhpQIQRxLTENmGAan02ziWKGTFUTLsgilWocUcrnceiebyezDrFComChKsSzQlIlIIfQjLCMT4+iaQNdSPL9Ns7VMkkQsLs4z57cgldQrVea7MYWCw44dOzh+4gT5fB7dNHF9f52HPDRUY3a2sY5bnwnHnPlvbRHLBEptSqXS+oK55qESBB62bQOZEAnAdXsYhkHOsYmjrCCapk272chw8qUFnLxJqiSd5jKdTofNO3dnvHe3S94pI1JFp93jqSeeoJSrEAUeTx3cB8DY1ABC9eGbKOX5V7+Uf731K5hlQRwuE8YeA8MDJMkcceRiCIs47nHixAHq9Rrz83MIHUqlUZqdjNoYhT66Jmk1FrFzOTwve1+9rs/27ZtZmJ3Ftkz8MKZeq2FZNr/5lnfwxjf+FlPjO2m2F+h5q2ipsW6L4EUeppGxalL64iNf/dw9nMioD7GZ67u/zI9FJ4yzhVoXJihJHDZJiLnp7a9l9uQzXH/js1la6mLZVT76iQ9y1RWX8e3vfI877rybBx96CNupMDoyRZqmhAmZv4xm0ellST9KZh7lQssKtiYSSHQcp4bvu6QiglRDIRkaHuZ511zLli1bqFarVKtVhBD4vk8h5+B2XP7Hh77Ju9/739C4hLGJa6gOVAn8U7i9FWTQwnEEpmURBi66srHMlFR2WF3K7k2ZZgu01xclkWpomoGhaXQbq+Sky9TQGPP796LrJlvO24l0F5Ga4p++9j12n3shj+w7xOzsLF/4+0/zySPHSJ1RNM8HOuDF3PPt77Nx4k1QeQlXvGQ3n/7U2fzZx/+Qt91wGedd9iL8gw9x3QtfxKVXvZBLto9y1mSVmSckld2b6cUuUqXUBqZw7I384e/9GX/wB+9hpDjIYwdGOPuc53DddRsoTzgYBY0//tA/8JH3v5PnvvRl/ODWr/Ka113Ca16X8sEPf5lPfvKDuKvTJO4MvWSYYDpl09QkIxs28ei9e4mTHvf88PuYToHXv+EtfZsFSaPRYKiu0XWblIyUIEr/axTtNE3p9Lp4XoxMoNOTJNIHBDJexc5bpImHjDK/DbR+Snofv9bF6Y46UyJmtLU1a9UzQwosy0Ilct1bJGfZffc4AUIgRF/N1i/Ya7/DNOV60ZNSEkuFYaTrf78gY1rI/gnP+M4plpVxgkWsE8q1nkbrMxXS9eK6hnf2ej3ylSK2bXPs2DHM6gSudMnnM7Wd7/tU6wP4YdhngbgMj41iLfXodt1MnSmycN4zO+u1TvB0koqi2+1iWRalUonV1dXTjJd+kVLqdMFPkgSh6whx+jFr+H/Pc8nZOqlMMk53zsHUdEqVMu1WViyj/gBV7trFli1bqAzU2bR9KwA7pzYxszjPns1j6IYiCDzO2rWDucVHEUZKL3SxcjathR75/pQol7PRNAPLMtF1kbEsZAaXmYZNt9sln9dIEYRhhFICw7DJOxAHIeVykVarg5RZIX3mmYMkEjZt2EW73SaJBZpukvT9StJUoYmsCKfIvupWO8OPJl1/XKppaCLbqVmWiWladNouGDa6bhIFHsiEyclRtmye4sknn0CkiumTLYSe47wLzubxRw9z70/u48EHH+PE9CKxUghMcna+r0GwicMRZmdmMHSTOJHoupb5g+gmCXqmkEx9PK+F0DQ2b9zGyPgEz33e5dRqNfJOiXw+j+3YNBoN3F7GQuq1O/1ZhsFTjyywc9dGYjclyDUIwlUCfwHb9DJlbmyiaxYySgljDZU4CF3DT12SkD6UaKMUBHGWQypjiSZg32MP0ut02b37WQyMlPjaV79BsZrjpS/9VWpDm1hu9nj4ofv599tuY+X4UXQVcs7F17Lvp98CU4MEpk8eZPqES/2KPfh6inFqhkfu+md0eux76JtoKo/pJDz59K14q13O2TbEv//b31CuDFEs15CpxMyZkJborbyNh372bTpLm+g2jrDUCzjw1b2UyyVe/aYXU8x7nH/pRfzku7dy4ZXz/Nl7P8RLrr+SP/7jG3nzm69j4+gEQsbEdhspYXbRQKU6w8PDnFpK2LFjG61Ol7vv+Qln7dxKKWeTG65TH6jgWIJ8IUdlsI7rur+wXv5SFG1xxs1v5wxUqjDSHLoGllVGCYvITwmTHjKBJM7s+1OlI3SLVPYy7CvVQSoMI4NHoiRTKpIK8sUiSRStJ66vYdxRFOHkc/R6HfL5IlKy3sErpSCVyDjOPtyspbkbWEaC6nN31+hiUZiQc4pYhiIhE7pkzno+BauIYULO0UlCg9CLKQwKRChJkxjb0unpGk/t28vEnitxilVGNw/TdFOay4sEQYHxsSmazTatZg/NMKjV8iRhylB9kKeiE31Ze+8Mw6jTJldnYtxnFpq1xWuNEQJrwQ59g38Bumb0O0QBukATkMQRZs4hVYKhgUEQCXES0Go0SJTEdV2EbiOETq+5iDkxzuLqIrkECk4RL/D5xF/fzJ8A42ftYHvlPA6ffJxt287lszd/g9//7+/mw//ju4xP1Pq7ggLd9gCWBZ4fEoUZnDM5NUirPcPQUJ4wCQmVgQVouk6CwHIUhpEjdcEPXSbHx+k0ugyVC1xz44186ONfwFg4jmHC//GB9/OTu37Kvffcj2WZeH4ng8rifhJSuoacK5Q6PXDMlAZy/TFK9VfnVKEC8F2XfGEAz+sRxV22nzXE5MQIKRHLS4eQEo6dnOM5z/41rnvZ9Xzkw3/Kj374IEkcZorbJLt2mWDJolSu4voRcSKYm2/2F1CfJJSkmOSMIlc+6znEysPK5dh+1nYmJsYol8u0mw0sQxCEMZoI6Hk9ojigVKyg6TqNZpOB8gD5XIEgPMH83EE+8fGPosXHyas6fnsBPVYo2Tcki2NSYnK5Gl6QkBIT+UFmoZtkoqFYiAzrB0wBSWpi5Udw8jYzp6Y5sP8gGG3ue2KBuFJnrGDy/t//CF/54oe59vkvYOXYfeiaiUQj8hYpD+3AXX6YBJuH99/H8Pdu4Tkvfh5RO6C4bZCvf+UrnLX7CjZtGuXQkf0E4TQ5rYB0KmzeNMVodYqpyQEK1SVcv0N+YJA9O15B0H2SHaMGG4cFpGVGKznU8BLd1gmSzhV88UtfYNvmYXZsGWG81uHTN7+FX7/xEMdPBExMVuimHjYptp6jb/PI/IyHNHNsmRxjacWnu7KCtC2+/b07efmLL+PQgSexDcHMkf1UKgXcVOsHlfznxy9F0YZsqKNkDJqOYeTpem1MkdJtTBOlOmHkkzMFKtXRTIPxiQnSfsyYqRsoBIZhIoWBJEUmKQWR0f3SRBF5IbqpoYtsmr/mD5JqrAfJZu5ymQuek8uK+prlqy100j5nV0rVxy+zUF+Vpui6ge2Y6IZAagopUyzbwvMi8o6GSgNk5OAHGnrOJwhdqvokSdIkDF1sK48e+hw+ssTYxRodulj+GEbQZGRqI7rQOHToENVqlXK5zPz8PJu3bsJxQhorq4wMDzI7s4BlGetQ0JlY9tpx5tZrDVfPQiGKWaHtd+Znsl0SFSGVQEkThIaddzAcG9cNMtggcHFyFlqqYTsVEIpTM/splisMj0zQbnfxOqMcP3SAP/3ddzI6tolWq00zyjDtWq3GM4eewS4NstrocGr5JD/62e30Qg2za9LzAgZHpzhw+BDN2RUCX3LeORtZXl5mcGSIfNGkVBmgULTx2qcYcKokXYlQId1EI6dptN2Ii87fyfzJw6iSxQkv5a6PfZGLLziH/QcOglnkg+//AI7jILQEz/eBFCW1PtsnBSHXd1X/5x2sgv49mKq+OldK7JxGIiSeN8ueC3cxMTFGt73E4sIMK6tNpITVZY9CdZArn30Nn/rUp1iaO44Qp1lHp69XzPHpZfZcsJHRwTKjk2MMTQ5yan6RE8fnGalMcc1LXsTI5Aa6vQbThw/SbSwQex779+9n++5zMrZK0MbOWay0m8RxTBwEuD0fvb/T6vU8Zk7Os2XnBj78iY+yNNcgVxQ4eQ00A6kUYWyj/MytUE9DQq9JHwVC0wxSLUUIB1JJvmDhul2KhRrSdMjrFWLPxfd7hH6HW3/wAC97/nmc8nU+9Od38IWbP8GGycNMjRURyQoj9TqrrQaaXeCZR+5n84WX0F6BakXQPfIoB7ecy5/c9Bb+/C1/Re+4Rm2kwNMHn+Ds8wc5eeIYpm7g+Qucd+EuXK3JfG8e0VTsqIzgxTrufI5rfvdqHnzwAQIZ4bkNgm6Lpx7bSz6fw7Ys7rr328wuHkWqHm4nZLjm0Om6bJoa5Gc/+S6vfd0r+enD0zz7oimSJCRUknzeIlEOjlplej7AoMKeS/ZgO2XyOy/k4acfZKwygt9pMDExgWFKBm2BU6jAyfn/eIOtH9r/4zr7/+GRqhRdU5haTBKHxFGCoRfI50sMDhYZHq0wPj5CpVjDMDJGh2FmIog4jpD0g1U1nVQTpGj9LbOxvoWXUmL0I8fO7DRt20aqzEMiw6RPP35NTAP8HFVurUsXgr7Yxling63BMWtQhFL0O/EQTbOQiULTJUHko+uZE59KEgzLBjzclQjDsZEWSE9REDqdno/rugwODtJqtRBCUCgU6HYzJePq6mqGafZfE0DXxRkD1f/8iON4fedxJsMkex+SNJWgpetDXE0ziGVCrBKkkpRKJZy8jZT9jl0oQrcFictQPU+hmHL2WRvwukts27aJex9+lHsefIixrdv6/tKQM0xs3SAKMqxdEfLEk3vZedbZzM+3ODkzTavdJYwSXD8hFTqrzSa6aeL7PrWBOgtLiywutGg2fE7NLuJ7ilbTw3NjAtfD1sFMBfgK266Qeavn2Pf0ITw/xk4lGzdu7MerZSIMTdin79E0/bk5wX92ZKKZhJxlYeiCMHCR0ufSy85lasMgPXeVpfllet2QblvSWPERQqeUr/Ot277CySOPZddPAynXYL1s5wcwt3CKufl5SpUyCVAbHWXrrt2ce+GlTG3fjTBqrHYFZ59zMbt27MQgRUUhtWKZ1dUm3W5EqueIkhQ7lyeXd3BsB13o6Agcy8bQTErFCsdPzPH4Y/tYXJynWMkTxC66YRPFIaQRyAQ91bE0E8fSKTgmqQQVC5QyMe08QmSq29GRSbwYdFHAiyRmkiDdBlt3b+dFz7uAp5XOgZmTfPETH2TY8MnpXUo5Rc9tMDU1QSJByRhdZBmkpAZeO0CmMUcf/wkkkukHfoqpW/imwaY9l3Lt9W/g0quu59qX/A43vvZ95EqjBFJw9p6XoVlbmFmwmJ6pcOyEYmh8OwcOHyBIPVZWW1h2gV7XZ3ZmgUKhxrETc8SRhl2so8wS3VhRHhnk2IkWv/7a6/mN17+Tqy7Zwtv/6AMEQrLgR3zmq3tJNYPiyFkk8QJaItn70H30um1+dvd9VIcm0cwqF174HBqNHlKmBEGmn/hFxy9Fp61rcOjJh2m1euhGEc1yCMII29IJow5oOiJJMbGIlMTSwPVdBCBldnNHUUIYuMSJiSZSlEpxXRdNgyRSmHpm6brWvWiaIEmyD8TaB9JxHFo9DyXTdepcGITrDJL0DHVcxnleUxiaBEGI7C8CcSwROv1MxoxBogsDFWskKsHUwPM8wqiDniakQYxdriMTg5n997B907tBOKSppON7aJUcceKTyIDBoSrdXpNOt0Wzo8iZBTRdMjQwytTUBK12A6kypsqaqAb4XxaaNZy71WoxNDS0XvCzBJYzksVVimZk6TApGkLLotlylkHgLmWPVyG14Trbd2yhUq+wtNqg1Wwj3Q7Ti/MMDozSCyK02jAzs4uMLnXYuO0cOPI4o1s2EqqQU3Mn0VOPwYrJqRMLvOu3f5/9+/4IKQzOOnsPP/7xXdnri5TpU20sS8M6MsP4xFZ67lHOu+RiGjvn8b0I2zi9gFYQOOH/pO49wyQt67Tv33Xnil3VeVJP6MkRZhiYGXKWjLCAIrqoq7Ls8uhjWHXZVUTXgOuaxRXQFckiSJScnAFmYIbJobtneno658p15+v9cFf3uO/xLs/z0bePg2OgaZrqu7r+dd3n/zx/Z8DGxSexbzTBzsNHCPBIZy2qxQpS6hQqVfLdfYQycoaoqo6qaDUvtpyWQY5/HF9ATvVGRndh0e+U7RQQQnD++eeQSqXo7TvKzu0HKRYqVCtFXFdOy4KKElDKj7J76Ai6quP5Kr4f0NDYTEtLE4cO7icMJYZu4Lqj7HzneVpbGjn55LMoujoInTnzXNLZGPGYQcWxuOXTN4Nf5tzT1pGwTHynQjJhEVTzuH7U0jQ0OIQiwyg12ZQi8Fy8IMSKWxh6gp/+69cJ3ApuEJBoa2HGzLmMJVuIxY4y2N+NhoqQNk7oE+px0tkZLD9xPa0tc9m9bQvFfAcNdQ1oQD5fZUbrbHr7+yAhKDh5wjBg1HVwVdh8byef+8SprDuljfxENyODE9Ql65DjQ8TTWUxTx/N8Aqnjjg8AdYTSR1MVlPh81q/WaV3zAUaPHGNOopnugzbP/UGlue5annzsRUIEs9tX0dO1iX3bD5OKbSIZD8jWhfT03Ekxb/Lq89txZIXhvgEWzF9a63YtcepZZ/CTH96BbmVZueYk+o8N09+7l6YZ9dx55120z1tJf38Pl1x8Cft2bCWdquOXv/gtF15yNZ4/zoYzP8ZI3x5s0QPCo6d7gsYGQefBA7Skmnn3zW0sXTKbkj1Kti5Gz5Hu952XfzVDu1IuUS1XcPwqwtCw7WqN2aFh2zaBbdOQzmIlUzhOlcnJSSCK3UoZIhR1WnsNA4UgCGtOCkGoTMkZIbZtT/OvVVWNuiM5HjaJ9NwgCokkEtHiUvr4fkBYWxhquvLfOB+y5iT5SykiklaoNcv4xE1qrAoTKaMljqqahGEez3VRNYsw1IFRGusTKJ7Aj/k4IiRt6EglQFGgUimTSCRobm5iIjfJyHCeFSvmUiwWyWazFIo5LMsi8CPpZorG9f81tP+S+T0lpwRBEAVKan51OO7xliL6mYSUiFDiVMtI6aAgOOnEFdRnUhiWxfDwMD19vYDC0MAYzU3NTGo5rHQ9k1WbeDzJg48/SbalBbpg87tbWd6+APvQfpJmArvo0TarASUIOPvMc8hNFmlpCXFqTTNh4CIBxw0pVyvopomqaYyPFHl37y7sYpQK9H1AwtxMivlWgl55lGvOvYKnfnk7+dDnjRde5YXnX+Hr37qDBXPb6DpytNY2M+W5lijiuONG1hzgkf97CgoVadxTz/nUcM9kU7S1tZHJJti/f3/kshnN1zgwEoQgJARFoKoGpXIUKAlDH1WzMGJJ5s6dWwuQRb2ZrutiGhqO67P5z39mdLjK6edejaabOBTZf/Qo9aksVnwuihZj4dJ2NCvyiZuWRmFihKbWGSQTaQzdQBMqilBxfJdyqQrCj/YiTpXXXt2CXa0S0ZUhV6ww20iQbU1jJhT6B45GP6sIQGqced4lrDv1QqQ+l85DvSjsRjFA0yUTozkU4owNF4gpCtXcOB/50i30OAUM3+Mnv9xOQ8MsQpnDKWo4Yz6GaVKu+LTOqOdw91GaGpsY6h8kNBxiioXX0Ep5citmEMcdG+Znv+tg3Xnr+OPPe4EMq1YvwNM1LrzoIja/00W2sZ6Fi9K0zmugYcZyGhJthOEENjlQ4Rd3/YKxXCeoknjCYHCoH6fiYcVS6GoSNV6PZdXTP5hjeKxIMl3H4e7DrFt7Asd6jtE+fx7dfftJJkwMmeQzf3s9QVhl0vN59/X7WX/2PN7b9j1QUzi5PJbwmdlQR248T9vCxcxc0srwYCdheZSGTB0w+j/Oy7+KoR1KwZkfuITGptnkJssQhqTqknT1d3Hw6ChXblxHf38/lqKw/b0d6EIhZlpIQjypovmgBwKhR4M58GW0UJQS348G61Ty0TCsCIRU43BE8kkUtxZBELEmiHQ5VVWRoY/vexFXQkYLp9BXqFTs6XYSz49of9VqFWlaKDJauAQIkCGeC64CEj9qrUFjYryAW3VRELhKgcWLVrDz9UdQAsm8ufOZ07iUzu6XIg00N4yqakgZ2Q0LhQJhGFJXlyEZTzI5mcNM1mFaWq1mK2JHCxGR6f5SG50aLH+5fAzDkMnJyQi65bmYWsTWYIobTvSn70dhGOFJmpoaWLJsOUIJKRcr9PX3MjiWolCsgHT51YN/pH/gMDNbVvDlL97C0Mg4Sm6M+jkpCvkJTCPDKadshC3P8+ivH+ZjN3yEY0M5Ko5CICCdqucPf3ycc889n4cefYbWmUuIdh8eijCAyM2Rz1VobGhmfGIHpjnE1RdfxcJFC/jFPb/mwosvYvGCxRzZt5OHf/c4p689m/0lDTuU+Ch87+ffYcH8pQgZMNA7gEAjZhlU7ULNQ68QyqnWoanuoeNlF0HgISXTrfVhCLPnNNPQWMfMGbN54403uPADZ/LdO75O+/x1WEYLVXf4uMNJKDVnk/PfnhtVVYkZJqOjowwMDGBaFo2NjVGidHICVWg0Z+JIb5Ifff/zKJpG08w1PPXyE4z35rn4tA/y1Lsv8vQjD9P53qsc6x0mDF2uvvISDh3p4Lf33EvF9lm5fDENzQ2sWrmOWNIgU1fPRH6C2//lVgg8EgkLtxItEEdGRti2bRtXXn8D5WI789rPoL+/F1uUaGuew9KNG7GFwaOPbmVByzIa55/G0Ja9VIr9qDTT3JRlsliiWhoj8EOGbJ+ZJnztB6/x/Ts+glOY5Cd33c+//fP/IqnHKVcdLEuj91h/zQKcpaGxlT17+xgcOcLje3JcdcpaYpUSsniA3/z0Vv7zwYd447nn6TkwiC26CbduY8nCOKN9jzMyMI9lq8+jv/8Q48O7ycU7CMqTpGdaLF27ibYVrfz6gSe57V//nmOdIzQ3N+AG4/zo5//FQ/ffR1DycOU42XQz+/ceIJmokp+ssGfXEea1LmZkoIv5i02U0KJ9djPF8kyEbrBgwWp2H9rKI8//M9/+0iLu+ek/Yls7USazDE/orFqzkT173ubY4XdonTeLRiNGqWC/77z8qxjaUkoqnkr/WImYZhGGJQa6DvPezncwmtvpHxnBk5KYUCkWyrVarXCaaS2CqfCE+hcn3ujFpKoiClzUeBoQ1pZIkT3L80J0XUOrBXB0XZsuGfAtA12rwZ9qL6gpbVdVBb4X4uu1YgTleM3X8RDP8YosI6YTuAaaXutQ9GrBExG1mQjDBKkR4lOegLlzlzBU3Uz/4CDti9rxQ0mxWJhemkaNNTZ2pYplWfT392OaEXnQNPXolElYi5z7/01rh+ODZ+r6R5AtI+JI1waHrgf4niSUkjD0UFRobKzkfJmBAAAgAElEQVRn5crlaJrG6PgIXigZHhlDS1oUqxpnnXsxZ114GWqsjqqdYv6MNHqilaamOBBSzedJWSqLF7VSHpsEwAsUXn1tC2dceBGCENd/jXyxwqHOo2zceDoHDu1k1foNCCXENBU8N4BAIhRBqVSio6OLwPNxAp/HHnscVUDMSnL/XfeSjGdQRcTUuOPZB/F4AkvTAcGu997jlRffQIaCalBFV5O4tnP8Ok3dWQhR+50RSEIMXZ8etJHWHAIKhgknn7QeoUiee/EF2hev4vxLLuZPL73BySedynvv7ERXEkjhoSi1eLb8yyLg6G7IdapMONXanR/ohkouPxHJL6GGgkL3kUMoSie6puHZIaNdb/PUk1uQZhypdPHEY0/xzlubOfTe6/zvf/wEh/bvY96CuTz51NMMD/cjFIW33hpEKDq7d+9l0aIlrD9lLbbtgrRB1SiXq5GsJ32+dds32PzmNhzHY8HSVezc20PdvHkEk3maFs6nkHc4cPQwZ284lUNdeaxkE1rKorF5Ie6kz9B4jtAf5NOf+zrDQUhZkXzl9rf4wW1fZt5JLr37POY0n8Lw6Ah17RlkOYKfNdanERL2H9jPmaefATK67s/+6Q1a5q9kouMFXE9DOXKYje0+Z11+EU/98NeEtoeq2fSPDILMgrSwaGKoO0dcq6dSHEdRTKqTLo0r2vjDPY/zi+4OPDmGQhqBhecUGR4YZseOt0EJCewy8YSFaeoM9R7k779wEw8++DDZ+jSa2YiQOUxdMFFxUGXIx679HPf9/gf0dI+yZP5MfvXjD+GKEX73q9upGD5ZK8W4n6dh4TLMwKJcHsHKpjAUBzj8P87Lv4qhjRAEIs7QcIHBg29xwqK5PPnow4QxnYWNy+nonWCst4/zztyIYsVQNY1ABIQyxA1DYrXb+jAUtWZsME0xHT8nAL02TKcG1fQp2fOiF4wWEdp83yeUEDON2in8eH3YVNms60Yeacf2cBw3astR5HSqUK2td92qi5WwqFY8AiXE9T0qdpVYXKFSLeFUKxGYKHAxsw2kZiykOHCQah7mzFtO106HOQva6enqo+I6zF/Yhq770SJWizznqlBq+muJiYmJ6YBENptEyuNExMCP2sH/0h0ShtROfdHtt+O4OHaILSO0bCabYv68dhqbsmiawkB/L2EYcuzYMcIQBgYGqUqVhYuXsem8c0nE57Ns2Up0U7BtRzeHd+3i1s/eQLJxKXZuGBl6JKw4E6UOzl29iPH8AACf/9p/YKWaUJItpBMWty09lV/+9Ac4jPHQY49CrWdRhj6BF9YocBFgDODw4cNIPCqlAlXbRweaUxYVLYbaVIdarFCulPBUDYKASuhQP7ORhvQCXnn2t8yds5ykGYtGr2pSqtg1j3ukZ0+hIBShghS4jlMLy0e7g3nzZnHu+efR29fN448/jaKqBARc/5G/ZXTUZPOb3dz/yB9YtGA2im4SOhHofjre7h9Pjk7JKxFVcYxMNosQksmJHLqhoWpgGRqVqkemPk08adI8o5XtO4/ynVuuIhAqKB4d774MzjjV6iRPPPEEw8PD/OGZxxCBFvHeAx9NNZASxsf66O3p5uUXn0DBpK5Op5C3ue6GG9i37zDxVBLbg9NOP4vt773D97/7TW7+7Ncpl6s0pFq593ePs3rZUq776Cf53KduZuN5nyGeyeDLRvxQkqwTTEwcQvoB48Imi+Th33Ty0+98kHnLkyiFECNuctUVc3nwwT9z/YdPZ/GCxfT1dZGnSCh85ra18Oprm0nX1VHIm7y35Vkuu/ZG7v3GM6B5yOIoe7oNHv3WiYjv7COmS1xP5Ym772D+oivp6+ilsXk2+3bvAW0cTVbwfQfhxLn8ymv5p1vuwhQaUmoolBifqIJU2L7tz+Qn+4HICfLs8w+QTNRx6ZXX8c9f/i5rl63GUkPiliAZb6K3p59zzvkb8pM2u/c+ypLFTaxYtBLFTOKWj/Evt3+MiUmHp+/9GkXHxA6P0dTWRN9QN2HeZsewyhmnr3/fcflXMbQVASIMiBs62USCw3t30yAM3n1nD0uXnUpnvkJLfSOJuizFqh318NVcHY7jkIxrqEo0jFRVRdZOLdPx4uC4g2Kq6zGC0B+PtqdSKVzPwwlkhKeZLvaNTtCqrqOqSo0PEkWDFTUCBwVBgGlYkRtFN3DdKbsdhF6khytK7dQ/9Rhrp1tVV6NuPCOGZqZJp2MUJ0Pq62egaJJSZZyZrQ2Emk5f/wCWZZFKpaIXvKZRqpYRwqWxsZFyxSaZTFIoFKhWq3heMP2YBXIa1wpToaHIvRK9MQXYtk8qZdHW1saMGS3EExEI62j30aiVRdfx3IB8vkI6ncGWBvc98BATeZuTNpzKc0//GSsWw3Uc7vjS9ag4pFrWYed6CN0iUoYUvRKWotOSleSL0WOpijgYaUollXzVY9nspVz94Y/z0G/+g+GRERoaZlAsFiORQkRQHdeOZC9ViVwFpqFgITBjBsmYxfyF7Syvb+D1N9+mNDGJn0xA1UXXHKSAicEJ3uo9zEc+9HEEIZpmUKiUCWVYe46O7yzE9F4gRBIFsjy/igA2bFjP4sWL2bx5MwcPHOaBB3/DPb/5NS+//C5f+cqtDBUGWbbsRG699asowkAXEleI6UE93R3JcdzA1B2hogp0XaVQKIAAz/UxpILtl/m3b/1vPv6JG/jdA0+gKQn6O37EqF1GYkDg8/G/+yTbt/yJY907OHBgH1KAHo+ha+D5CqHjE4Q+UvqUS9RgRqDrgmK+DDKqUUtkGlm4ZCnxRB2OW+XSi89DBlV+fNvf0zxnOSM9Q9z1m5+w+8ggjzx4HxvPOYtSaYg6sx5DT2MYkmOHXqeuoY6ygMGywk9/tYdvfOGzLJsrGeocJpuxUPNZDLPK7OUtfObvv8ajD/8niWSKTJ1JPj9JJp1AKMMsXrSId7fvpGPHLtauuQxXOmi+gpGJ03ngIPvnLwWjiaq7FyGKlN1emuc2cqTjHQxDY3DgMJ47gO/l0BUDGfSRjGvg53BIIijV7k4hHq/n0MGo+jZmWjiBJFuXZmSsj89+7jHefXsXjU0ZdMWhUi7SP5CjqamNqlNh34GdVMp5Zs9vY82qRnbt3Mnmt3dwwilr+cNvv8rGwYBdW+6nWhpkvLfCrNblTOiTVAs5tr63+33n5V/F0EZKiuMj9PaNEXMrTAwMs2fvHj5+3QVYGYP+QsDhjm5yK5YTs5LRrbtQEBIstXbyVaPdflRaoKGoGqWSTV2dieu7eF4UYQ/DSM7Qda32pz5Nv4uWcRLf8zE0fXphads2qoxuZ23bJp1KAKAoPjIMSaUizoaUU8u/6EmWcQ3Xd1AUgWd76GoKBYFfa9+pVCqEKR0Fn1Qmy7KV69j67Db+8NiDnL9hHZ4DqbTFaG8Oqy5Oa8tMSpUqXYcH0HVIxCwcxyGTydTSoIJ4PPJbp1Kp6Q7ESL+v4ZRqQyH62QXLli9n/rz2yFs9cJRSsUKpVKSvz0PUWsqjNyZJuWCjKzqGmkSGGnElydVXXsqb73Vz+23f44Xn/8TVl57H7++7ByvegF0Zozi0HWTEXpEhrDthLQff20GpNMLQ8DEAXCtBz+AEW7ZsITc2zO1f/AwfuOLDvPXyU7wzOMCiRS3kJgc468wTaGzI8slPfxTXdujqOkJX5yAdh7oZGhpiPD9GcmY90g/wFZ9DB/bTOKMFo20ummvScWAvPjk+f8tHuPCyKzFElmRcx9IsmhrrKQ1UkAHIcCpoFDlVpkwjkgDLspDA+g2nkErH6eg4yPZd2xno68e2Pd54cwc/+OFddHZ2ceUVl6CrFioglWTEdbcjL388nqBQKEy3CE29DnRNx/U9TN3ik5+6ESEER44cwfd93n77bfYeeIqWptmoMsOuHXu4+xe/ZWh4nIJTwpBRW40bSj517Rn4ImTJkjVMjA7QNncuy9ZuJBGLk0wnqJYrpGJxZOjR2pilahd5Z8tOdrz3JoqExqYkW7e9Q+eQz6kXXEmiLgO5gM7de1k2M8s53/4q2fql3PDpK9m6ZScnn7eRn97+ZU659GY8LcLBamqC3FiO/7jjHj73hesQIZSLCpqym7vuvIWbbrqGxU1x0plmJsqDxFtKnLFmMb/8rxf45Z3fJhEz0KhgWRZjo/20NCQZH+rlvLMv5OVXdvPqK0+j183AzQ2hFya44xu3sXrTw9z+8E/42gfPINmSpVydx3kXXs7bW0ZZfcZq6p5YxdjoIRBjhHqJ0BmnoSmGIAPxBDEvQJM+xSBkw4ZNvPrKcxhqEtstoAqLif6jhL4knTC4+e9uo7ExTffRncSMBKeddgGu6/HWO6/RUJeCagPFIR813cHiFSpnbVpH++LzeGPXY7zxwm20z3mKyQlJudBDtbyLxhmzKY+r+Nr/H9CsQEI3WbF0BcPFY2gzPM4/QSORqad/XxeNRpyFS2dCWMDUXYr5MXQ1hkSh7DpkLAVFg1S6LhpQXhnPg2TMwFB0MKDiOOi6hhmLWtn9MCDwottUTdMo12rJPO94LN7zPNwwOhFpSOxwyj8b1NKGNQCQ7dQWnSHxpIGmqoxM5HBdyGaTqL6HoSYhLKIqWqSMBlXC0Eb1M8Q0lUp1glg6i6nW07/nT3QtmM3wGLSmPeKJVmyvjGJBIpXCMsbw/ZBq0Wd+Wxu4LmOjefSYhV2sYCo65WIZzdDRVAtf+ggtwPWiMMTMma3Mb2+lpamZXCFPd88+JvM5gtDB0OMk03W4jiT0VXz/uMNEj+u4rk8QCjwnslQ+/+g+Pvelmzh6bDMiNPjD/b8CCXZ5JLpumkHgQzLRyMzZcxmfmEAIsGI6tpwVXeeySlLxuOiUFQwP1PPS489wbMdsDE1h/ckr+fQnz+Kaa66jrm4BgRjgnW3vcfEln0FX4zQ0zMGKGVRcD1UzWZiay76uPYy2FQjrVSqTAZYqqRZcGswGRu0c6zedz+WXXofQdfKVkGymgVzJI/TCiHkd1pKvMkSRAZoa4gSSWGsbf//FbxLIEmOTu3n2iccZPTrCrbd/nX/7t59w8xe/xBPP7ue0cy/laE+JU0+5AsIQRU0Q+DlMRRLgIgIoFgokkmlsp0Lg+wgFRBDtIoRQCXyF1195h8bGLGPjAwghSCez3HXnG6AqtC1cyb69HRw60g/CR1VUfAJEEDlcPAIUaXDw4D7qzTqWtS+iUijhKCbKuE0ul4NWBUsTCMUkGVNIpbSo/guFkXEoaUW+dvu/c+bZZ9C1bzfjo2PUNc9hdKTMkcFeFidaSBpt/Pqub3L33S6KqEMWOpi7cANd+zqoy7STSKn8/ok32bztIO1tJ/HqK6/z7s47+cBlZ5FtmMHhsUFatR4SdRpuKYWmFLn5xov5yMdu5f77vokVS+CUHZTQpXGGT0dHiUUrM5j0031gM3VzVlLIjaKFFSa2HWbL82+zYuWJJOatI1kcYGbTTGLpHPPXzWPM9bBZBMFhYBiVGAHg2DlMTSGUVXy/SqahlcLYCE2tDUhMGhqaGBwt4cvoQJaun8Vv7r4LQ+1lYkRFeHWgRn2xe/fuprVxDrlSGSVrEgY+9pgkblgsWbqQQwdeYoaZYtj3uO+l5/jAsjVocgbZjCRQq6iN8/Emtr7vrPzrGNpCUKwUWLlgKVsefYneY/s489Sl7Nh1iLbWVZy14UwmcuOEikahbKMbJpo6BWkCWVsuep4TdTqGkQ0wsttF9rCphSAw3TYiaqxriE5RitBr4ZrIZugoYBrRUJ/StMOQ6TSl40QDfarQ1TAkFdtBStA0FU1TKBZL6HqkX8biJuVciWTKwHejqHc6qeB6FSqjY8yc0ULVKfLu5se4/IabSMRa6ekbIq666CmLUqGAaepkUml832csX+JwTw+N2Tp0q4ZurfUflu0qQlWYrBQAwfIVi5g1u4XR0VGKxSJjY2M1NK1HtepSl8pSqVSQoUoxV8Wxg8hKp0aWMIFCtZwjKlmIZJJMJsO/fONGiqUy2fQCJvNHkOG0a44lS9qZmJggncqQqWvG8wP0VJxYexs/+93DzJoTaXc9+3fz+stPIop7I/NcaPEGGmCjm3DTZ/Zy02d+hiBAEQZzF2W5+qqr8VyFp55+nsnJAqYpcKomA31DnHPO1Zx7xTXc+cu7MXxJpiXDewefxXE9vvvNL/HhD90YySzSo7llBk7VZiw3TiIer/2+RO0pUpEIDMqBi6rF+OTffZFjw0ka65vQaOGGj1zOuWecyON/fISPXHIu7W3tfPvb32F21gBVjzRxTcULokCUE0Ynd1UoSCmwba8WtoKpMLzgOHisq6uDgwc9FNWv7V4k3/7Wd6lvbGDZyrVcdulVzJ69kL6+rsj2KgwCGSJUH8IUoRScdMoGDu16mxdefo0PXfchinaVglPGD30q+SIyGWPfoQ5aGrIc7OwhDCKJRAif0mAnd//wW7z10mqWLJxPfTrF5NAAhqaw4ZxzKBUCTjhxBZu39aIJi4Ai27Y8Ae88TyaTQTMCuo700+UrgIqeBM8O0OP1vPrCDjJJhYsuP5/BwWEOdR5BFSpzZzUQhnDlBzfyqU/u4aPXX0Lc0jDNUeySRqCO8/JzD9I0bwlDPZ3cePt3+cE/bI1W7kov//6v3+KdXU9zyumn0rX1z7jS4bWnX2Pjxg30dtroWg5TDdANCJUAw8jy1ua3UCyD+joTp6igqDp/c82HsKzouY7HksxsbcOMhVSrkldf38nGk09kxbI2Dh7sYuOGTTTWZ3nt9ZdIJeKMjoxixU0q1WjI6zETLWZxaHcnX/vXH6KKBLfe8X2u/8cbueLvbuaxu29jLBdHm/BINx+iYeEFcOjR/3Fc/lUM7ciaFlKtlDjvrHNoarqE++77BYEDveM50qPj9Pf3sfqEJZixOFJGOjRSIoMp9GqkYevq8aJaVRx3b0zhWae29FKG02UIlmVF/42qocoomBOGklgshq4pVG235gw5XnwQyQaRpq0oCoWCjWUJDEMjmUwymY+GtW1H/BNN12uuDDGdppR+RNeTQYhdLFPf1BAhXGWVge7DlCseC9qa0CoBHqCrUQwfQ6W+vp6xYol4Ks5EPs/SFcsolIoIEVkQbdumLptBUQTpdJr58+fSP3CUWNwkk5lFoVCgVK6ioOLYQdRQU/ERIfhB9GY4FYeXqiCUAbF4dJdSKpbRNAPfg7179yFUA0VUMQyFWCxGOp2isbEeKSVz5szE8wLGJwYplKKwk676VD2fohNZCA/uegtRHgdFoAB12TiZuvrayV8lFrMoTNr09Y7iSZeuziG6Ov6AacSoy9STiEOpXEBRXMIQXnrtCW69/V4+8Oh1bDp5E77i47lV3njzKc489TIymST5Yom2WbPxvMiPLoSI3rQIEKhohhoxZ2RAXUM9s9tWgJrE9QS73z1Ka3MTlYkS0rFoTNdTN0MyY3aGW794C4oSEgZOpKooIYpiRocJNYq2SxGV+gaBD1MHDxlV7imKUtPVo6V2KAOmvNKGYeC6ZYYGywwNDtB5YD+REcYnlNGS1NASSLVKQ8N8Cp5g974B1DCGpIRbLBLTNRx8gsCjUgIvjN583TDEdqIqPt/zUYTEVBUO79+FZ5dYu2whSuAwNjRAa1sjK1au5nBXL4cO7Qcp8aVdszC66LZPabCKRKFl5nxaFsymu7OL0tggmtDwqiVEEDJeDXn2iVdRTJ1TNp3Jvj27GM+P0drSxI0fv4HR4REGB3uZP3cWoVIFUYeuC1RUlq9Yw1DvAA3ZJbS1n8Fg9ysE8SRBfw9p0+dvrruW777+NrF0hiNdh5m/6lxEKNBUBVWExIw6RvN5Fi9fw779e0kkkoS+TSqVplKpkE7VMzQ0QiKRwHFcFFWnWs1x/fWfYmRkDC/0kALKlQqtM1p47PePMH/BnCh1LaM0rCpCUnX1jI7l6ezo5ie/uJcZc9rINrbwra9+la984VP858//hYNv7uXg4V149hCTw8P49qz3nZd/FUM7CCXFconR4X7mz5zDvp276Okv0b5wCUVM9h/uAenxp+dexPXKUCPQIQSKCr4XoKCgxzVkGOJ5AZqhokiJW2MhK7pK4PnYtl9jbgu0WtuLlBLP9VGs6HJEiNMIuyosY9oe53kghEsY+sRisVpBQiR4WlZ0eodoOaoQThffAii1cISuG9OR92K5QhMeXhgQw0WjtvwS8KdH7uXk0y9k2+YHaG9IYekaxaoDQsH3XYqlSVqaMoyO52hubWLv/gOEISxYMHu6YWdsbIxTNqynoaGBwaFjaDqMjAyB1NB1i9oeErsa4DoeiowRhApmbckbSJ+KU6FcLlKtlGhpbELTNBYtbKtFbUNCOQNVNxkdmkBBUCiOEwQBvb39teAJCKlQ9ZyoDUUl4nL7IU5NuiuPHCT0x4hjEhJSHM+TG59AMwSeJzEsBdcO0fUU0q/5NoSCH3oMj/SjKJBKawhUSmWXMExw9ukLQIb88u6HOLB3O0fHspyx6QoUHWzXJhYzGR8fRddN/MCtoUTdaOWoRndTa05cwsIFsxgckeTLJlJvYrR3C7FYguf/dB8xS+dwx/0QFrn2im/Q39XJyy89zG9+8TCHjr7HaFEyOVKkUnUJRQhhZDUMQhvQQFFRkIRUUYScXkCqqhqVGtSWolPylOcF068ZRSgM9PcglHD6dK7oOrFklnxJId26iCXtKzjrnAv41i3Xg0jz7o5dtM+bwViliqYaWLE0qq5hmSkqboWJUgkUlZgpqFY9nEDh8ccfww8FR7s6OHhgD2effwEBLudfcDndhw+hq3FUqSEVkMKPyjGEjq81cvRIJ3Nnxdh31Oaiy29gdrbE8NEOtOwkIxM5lCCGG1Q59cTz2fneES689FpeePYRJqsCXa0QtxTeeauT9RuWs3hJI+OVQVobW+ntH2LrG09y0TX/wKuPPsN1H/scP7z9bQx7FDfIMTbpc/FFWW7uHaV5YYnJzlZ61u/j7EUriJs+htKM4/QBcPHl1/PzX95JvRqRG4UIGZ2cRKCx9a2tWIZBIpVEUX0OHurmMzd9lssvuwYpA3p6j/Gh66/j/gfvpaE+Q6VSijz2Vizy7oc6Bw708Pkv/ytnn34J55+zkZa582iuj5NNpfjoRz/FHb+6mx17HyIh6tGUMiYmunbwfeflX8XQVhQVTRFoikImnWV8rEBduhHbDXnsj79n/YYzWbf2BFZv2sTOXdspFovI+JR1LTqlhGH0fSKOiDpNXJtKLuqGgVQ1TF2t+WJ9ZBBSqVRq76ZODaCk1+LvStQyoakoild7nGAY0SWLZJVomReGURTYdV2otdXIUKCotdthtWZJ9D2EpiEUgefXYvVaSOhJdCUk8EARGqES0tO1naUn3IRm1eEFDnbBQTFMqtUyQlXwwsjN0dJUT//AKIsXzmFgYCCSdRyPEIlr+2QyGYaGhsjn8yhqxA03jTgTEzlSSZ1qxcGy4vieRBE6QlFwHA/TjMoDvMBjxowW6lKLaJ8/l/xkjmK5RLlcJJQeY6Pj6LpOGLg41YhDrmkGYc15EQQegoAwlARSQBASeiGoKm41DxBd/0oeGdjRNdVMAt9GIognDCplF1VT8Pzi9PMQBkHNi64ACuWSD/johoVT9dBUAz8scfd/fYcf/fhnnHbSN9D1BB5F4rEUxWIRanz0KCQjp4NEmqGxoH0uK1ctY6C/l/6jOeIN86lUfN55/WnssQEULU8+CBg6qKAS8oUvu5yy8iTWrJxFqNvs2tlLiEq2vpH2xauYO28eT/zhcUwjjuOWIg94rVTCMDVc24uq8sIATTMwDBMooqoCXTdrTUiylvLVowEuFAgCosIPCcJDihBFi4OuU6g4lEMV/BDTSnJsaIBMQxLLNIkl4siaM+rEE09k/sK5PPvk47jlEo4TlRPLMOR3D9xPZ2cPe/fsRAY29//+9zQ01bNs6Sq6j3REjBtVo+p5EIIqwJcCNShTFSFlAdd86B/p7XiBmRmLhrhD1fOY3ZJBcxSGhqvs2bOHtvYV/PxnP2L1khcY6T/KzLkWuckKJ66fyW3/fBcPPXYH6UwegYuCSblcppwb4d13O1m7aT2+Uq1ZPlK8vXmYS65oo23pJfT2PI9A58C+vWzadAGVik3rjAWgalSOdXDyuo381PkZeZlnTms9hWoRwzAZGoyATbqh4nkOxckJdD3BAw88SPfRTjQF1q9fz4svvkhLSxOKEIQ1robna7iex559h1m9eh2bNpzNTZ/+BOmGFhobUuzZ/hazmlt5/JHf8tj9v2Zv4LBi9QfZvffXaFqCQn7yfefl/3FoCyEs4A3ArH39o1LKrwsh5gMPAQ3AduCjUkpXCGEC9wLrgHHgOinl0ff9fyAIPI9UOsZDf3iQc8+5gL6xHB4+p515BheedzGxuE5Ml5iKgq4amEZkU9N10HQF3wtxHA8Z+MRNBSlr9V81u58ahgS+H532whAhIG7F0DSdMAiIWRaarlOoVKYhU9VqFYGJIgRBGKLr1PglkRc6SluKvygXiPzP8Xgc262g1EIapmlGbeWKQFUEAjVqDnE8JAph6KJVcoxWD6PGLBSngE+F9SefxZtvbsFQd5DP2ZjSwNQNAgkV16VUrpJMRRjHcrlIKpWoNc9UkROwYMEc9u/fX+vDlKTSCSYmJpBhhUQyS7nkoComgR/5gj3PQ4QRK8UPPVpam0inUwwN91HMj/PWm8eoVu2aJBQ1xGiKhu84hKHA96hhASLP/JQUFfoBoQgIRI3T4YEgID8SRXV9wLAaKFV7QYaIwEeiMGfBKtxKmcAdxDATXHPVFfzptccZ7B1j+aoZDA2OoStN5HJ5HL8U9SPaDoqi4gcVFBXOP38+O7b/kVy1yI0f+h5PPvtVilWbtnnzEaFHJptC1S0UxaBq5/Bdj/7hcfoGBukfOBJJd9UkZqaV3Tvewh0fRFcEfgCWoaCrEsOIse2lfWx9cTduUEYiWXRBML0AACAASURBVL5iCfF4jD17jrBz+1Z27tjG0uXr6Dp8gAsuuIp1p5zCmnWbOHq0g6987jOYRgLXK6OoKp6rEItnyTRqTI6NEk8azJjThq5ZfOqzt3Lnj3/CkYFuyOdA+LUqNQ0RSoq5AcxYhu5De2hPZlGCKqdeeinvvPE8M2YtxtcM+o4eRhcma07aQDqV5le//AXJeJzy5GT0RoZRCxMZXHP9xzCNJKVylfH8EP19YyhegZFijssy1zExMsGc+at46J57UVHQ0xYzF5/FinWrePiZI6xYFOcHd9/Jn5+/lO985Wrm1yUIVEnJLlKv6NTPMKmUi+zb+xrLFy2nlOvlmstu5Onn/hM1BF1PcM/dz3Kw4yDpeoMGS2PxkiaOdPfzxgu/oWXmJl5/6xnQmkAeg3KR+377K2Zv+hbXfuoi/v2f3qR1xmqOde5g6QkpxkoSs2CSSGZZvPRUZs+ZSeCWqEslqTgVxkYm2bDxHA7s209dKkXRniSbzTB2bJxHHnqaj33sRmTgce4HzmTXjndIJhKMj4+SSicolAJaW+ZwYP9eZs2czwMPPssDDzzAzZ/8JFY6ia6UKU/2M7etHiEdTlxzAudf/mGee/J+Xtt1D//7o2dy/6M3R2KYx//48X9D+XOAc6SUa4ATgA8IITYA3wN+KKVcCEwCn6x9/SeBydrnf1j7uvf9EERwH6EqqHGLH/zsJ5y09iTWrlnLSSes4YlHHuKPDz9EMp6gXCpgGtpfkPoiK9lUge9Uusx1owaRWCw23coyNVzN2oLN8zwqlWhRGdHd3OnPu64LROjXSqVa822D7we4rl8LXxz31k6lMIMAhBTTuvpf8kh8P9LJo+QlOFUbSYAbOkgRYrs2Rsykpiqgp+pomTubsCqIWwmEqlDxfcYLObzaLX7gSyxDTAOvfN+lUqmQySbQdZ1isYCq1hZfVbfWeagR+jIi2dVIhGEArh/i4eMFLr7v4to2oyND+I5N6HlUKpUaCyN6g/S9qCml6jh4gUNABG+Prr89zVAWWs13DBCI4794ItK0TasO3UhDqGElWli97kLWnXEVX//ez/nw390MMs2cWYtpaWxhyfITERICdBAaa9aswfd90qk4QSAQiqxBn6KfafeOvbz+8lYeeegZbv/mV0jXNXLK+vXMaGmlri5NpVJiZHiIo92dHDlylN7eXlRVYFlxDC0NPrh2lfzkBH5QReISElXKOa6kVJFM5KpUfZdq4KNoJiGCvfsO8e72nbQvnIdl6WzaeDLJuM6Zp29k7SlrqMs2MDw0FJVWEhUrSHmcBzM4OMic2fOob2rGrroM9PbRceAAn7j6Qu555jnIT6KbjSiahaXEQPgEwkWGPp6dJ6xMMNnXxdZXnsKSFWa3pjFUl66O3SxduIDTTj0FQ1UY6O3mwN5dFHJjSMIoSyA9kD5gs33r23R3HqLz0G5Kk0VKlVEUw2LVsuVce+313HnXgzz4qztoXX4uVtMqlq+5kKbmlfR1mNz35Ct8+auPcvX5H8Mp6Vxz3Zc4OllCulkyVjPjeRsTnURKo65Op1waIZVI8Prrv+eKq89n5pwGWmY08olPXM2nPvUvFMZtisUiuckqoRvZbuctXc7bb22nfuYqkoGBrmi8u30r1VLI0hULsBJzsatjZBrmMjxWxLEVsOqpSoX25YvJl0toehwhQpAOQkqamprQtAjfnEzGEEKyas1JLFu5Atst8cGrLuW1117HdULsahFTt1CI09TURDypsnzFidz1m9/wD7fcxNNP/Z5QOihOicCxcas2Y5MVcpVoX/TqU4/w6DNvYftlvvjtjyHtEE2b+77z8v940pbRdCzV/lGv/SWBc4Dra5//LXAbcCdwRe3vAR4FfiaEEPJ9eJYylHjlKpoiWLFiGX9zzbWMjRY5dqybec31XPXdb1CplhgY6sdUFcqVPIaZARRkKPHD6FZOCIkfRGWoQejgeFM6lUAT0cncqJUDTLWOm2YwTfETioJj2xiqVosyS1TTBOFFp0pNwXFCVLXWUhNE5QiR3uhjWXqtj0/i2R5aMmqRMQwLx6uQiJkUCgXi8TgyAKdaRheA74ECuYlxsg0ZRiZGMTD40zMvcsmlV/HbbzyEGdMIVIFQNeoyaVzPBs3D91QsE8ZHC2TqBfG4RaahnsGhodrPZRB4AaEUFKqRpU9XzUgOMSxKpWo03Et5Ak2JWkWkghII7NESgpBKYRLN0JE1Z02lVEETCiEafhg5ZyrVMogQTUiEUAlldMr2AzntxlAUBUK11pUoUcJIQlm79jRmz11Cw9w59A4WmMx5ZDJ1HOoc5LWX3yBeV6Tn2Fbe3urTOOcMFPkCpWKAqliMjQ8QhjamXk/9XBOVLP19E9EpH5vdO/axaJHGpz9+BWZsIStWr2fLm6/T0tRIGJYJfZ+wBoDSNXAcj/LEOGEgScbrsEvRYy9ODOLmOpEUo6UfAlWJ9HAIwahQVxfDMjSWLFmB7/tRKfPIGKtXL6C7exd1dQ0oSprX//wW+3ftozBZRoigJn/YNYZJgGXFsB0fIRJYVj2lfA7PrWBZBn9zy4955cEvgBrDE1ksLUAlT30iSTyRpjhu09qa5Fj/BIzvotQ9yYHuAzQ0ZOjs6SeRMigUS4yM7ubEk07FsqskExqTk8MI/IgzIyCs6es/+O63qUsl+YfP/ROdPT2sXrmckb5xhoMhxoZznHTa+RQUGOoo0bJqA70TJdxSlYZMnIzSSJj1STefS0dfgWce+DEbLvoEH//IDXzt858gnsyCUPHc8YgD71cxFEhaGr9/8BWSdQnWblrBWH4L7e2L+K+73uOfvvIBNHMSXREYiuDQvpdYsOpi1p1wJo99/zlEGOL3v8s//+u3+O13vsrJp13An599iBmtZzBWVFl+0omM7J9E8xSuu/ZK3tm2k+b6LK7dS6auAVNroq19Pptfe5MZrRl8dZKuwwd55tnN/K9bPs9HPvy3bNv2CtmsiSZUCAVCFwTYHD1W5N+//2Pu+tU9nHPO2STrDNqXzKQ6OoJlNqD4DoaWAiWNE6p0j/Ry4SWn86HLziAMHYpzPOrab8I+/ArQ8z/O5P8rnrYQQhVC7ARGgBeJgvE5KeVU/rYPmFp5zgJ6AWr/Pk8kofy/v+enhRDvCiHeLVUrDBULYJl0Hu7iqaeepLtrN7mxXpxSnl27t7Nr5x48O8TQdAiC2ikurEWwBYau4rg+qqojVOW/9SFKAlQhiNVqr46fpj1iiTiBDHFcN7J7TckptX6/qe8RDekQXVemca6R3jgVj58K6IAMAwTgVMq4bkixVCJAUq5GXvBSqUI6YUXcEGEQVy3cioMRKKTNFK4ED5d9r/0n+Y5uvMxMlHQcZIBie4TVEBmq+IQIJUQNBQnLYnwsT2PzjEgvDwV9/QN4dkix4BB4EPiCIBRU7ajhxHV9PBli+x5okY1PeBFC1rFDbCckV6gSqDplV+IHOqViBXwfz3GjImHPxLF9Ql8QujqO49UWtP5xHjeR91hKgaopWLEYVjLF+pM/AMBTf7yfgwffps/NUoq34idN6men+fPLf6Rr11uYnoesAmqVRx/8HqEQaF6FmAbHerprz5FJMr6Aw0ePEIgcQnMIQug9VmLP7g5mzWzCczqY0bqAWLKFweE8Y5NVxibKOK4kXyhTyHmU8oLAMQh8lUI+jxOE+MKjWs5RHws549TTWXviCi679DzOPXcj119/ORddcgZnn76Bk9euI5PO0n9siEP7j9DZ0cOWzTvoOnyMTKaRZDKJbUPaULELg9Q3OGhGMZLsUKLCBTRUVZLNpAiCgObmZmLJBBKf1pYM5823+fq//TudHa/xo/+4hIamIap2iaRlovgen/n0jXzhS5/nM//wUea0tZArDCEMk2RDK/VNrWQaZrPnQB+dPYN4ioWNRqlUYnx8vHYIioo/BCqKBtmmRnKVCV55488gdLqP5cg2Z5hdP4Ou/AiLmjT6x0ExW0n+P8y9eZScZZn//bmftfaqrl6zdPaNQCBAwo6iAyKIiqwqLrihIuKMy8zo/BxnHJlxBrcZUGdGXNgREcEFERAChCUsCUnIQpbupNPd6b27tqee9b7fP+7qxnnPO8685z3nPdY5OUmlu6uqq5++nuv5Xt/r8zUypNwMvekUjj9JXD1EEBxlohZxZNzgjAu/zKFde/n4+95E1Rvht7/fw+kXXM1MxSWbmU9HZ5GZGQiTIj1dgowT8OQjz9Bd7OW22/+Bb3z3Y4RGnsEBl8gM8SKLyshhhjb/goVda0iUTWwqHOnR/9M7OK7X4a+/+WaEEnQuKzDxmuINZxzPdZ+6jM27bmbvQJpHfv0wxXSCY6cZHQ859eyzeXHLFnJFh3o4w8G+w3S0z+eZJ15k+PAwTzz2MIbZQEWBjjLL5Dk6Uecd7/gAF154Iddc815UVOWcszZCWKM2NU42nWHCb5JtK2G7Do3KGM3po1z85gvZv3WYxeXVfPSzN7JKCZ7d/i1yx6T/aD3+XxVtpVSilFoPLAROAdb8b77uf3jM/1RKbVBKbbAsg45CCSOCPVu3M9p/iO3PPU86hsd/9VsG+w7x7FNPttCmDpZrYdmvv/RZCcJ1038A/m/5X9Xr+YvavaET32fDC/4wbmu2u46juAW81/7tWW+2ziM0iSL+CyVPKUEc627dsXUKjxCv0/H0a1BzdsFMyzpnGAZhpDcWY5mQTWdQSuG4AgU0GtO8umMnjSBmYrwKyiSJBSpR+gyP05JhUnoVHUhUQjqdQhjg++HcgLXZbM7haaWAMEiQiU4CSiTEkcRQFqr1XhqGgWFbcwQ70O+BkpAIgWGZGEYWhUMiNUBLEf2XVWzDsNBGNhOhWilAZhrLTmEaaV548XlAzySefOJhSsk0a7rSHL+8k7wdsHv3S1Tro9h2RO/KAn61zpvOOZN77r5Nh35JOOGEE+jp7qGro5upqXFMQxCFUCwWMUwNcpqaHmVedzelQplnnn6WE9dvgESRhDG27eJ7AabQfHRDCIQRAgldXWUWL5nPP/7T3/PlL38R21J09cyjrdxFo+lxZGiQF158md8+9BTjo1X27Ooj5bRRbptHW6kHy8wyf95CFi5YRq0WMTg4htdIUEKQKJPpmQZhMIsWkCQyQSFpNCp4XpWDfXvp7CqSzlh89CNXccftt7D+lFOwQ4s//8xn+bsvfYNifglnnHMsH7j6/Zx19hls2bKFb33zu9x95/0MHhnBEA4TkxW2bd3O5OgYg4f6cSwbgSKbytM7b9Hr4DBAopBKtvC+kM22gzSZnqozMjKCbUcMj48yVWuSyeQIMdizZxInXyZJPKKgQRyEyMhBKgMlUhiJYGpyHDefppDtoNzdQ2yanLx+KWee8QaOW/dGDh+eZPBwlVxniqbwCBUI06KjVGRy7AjrjjmFfXuOcPNNdwKKRJmAwjFMAm+UXMHGMPOgUljKgHiandU6i1eDSTux6TE+GdOsJfzuoS0c3j+NnU5Ta1QJvAjbNLSUaFhMjI1R9yaRJEShyeWXXslDv36I/r7XKBQzVCt1vGaI5bi8tu81vvkv32Tt2uO4585b6V3Qg0FEdWqcFcuW0lFuIxaKWEk6OzsJgoC2tiJXXnkpW1/YgtdsMH9BJ7f+5Js8MzBMZ1bxhb/86h+tnf+v3CNKqRkhxBPA6UBJCGG1uumFwFDr04aAXmBQCGEBRfRA8r+9yViCn2AGPs3JKToX9aJqHhOHRimaLvtf2s6q1WvJWDaWsAgjCcL8r9wGo5WDaJpatogkwrERRqLDE+JgrrjPFnIpZYtPIkhnsjqDL5Ol0Wi0dHDdJbqu7rLDUAPubZs5V8pcqIJlEQR6gp5KWaRTAqnQSR5KEIsYpELpxGEMoYhinbIjVIRpGSjLRglFrugyNeGjMNj6yjbOfMdlPPfgjzDyaewkRlkREmhWJUpI8qQwHJtlK7rZs2cP+XyWXC5HHFVoBtrgnyQCy46JDRNDOMRAHAQoYeqILKVI2xZKQKwipIrJZxzGGxUtZsgQJSWZbFav36cKvPWq67jy7Zdyy63/ygu/uY+YChYpZhGqjp0iQvOgW9cvpNLtSBXr1HfbgAROPHYlURTx4xs+TGd3O8XyQrZve4HOQsjyeS6V6ZCPv/MiupesZserh/m7L1zPuuPW0TNvAaef+QZu/Ma32P3aKy2crpattP1KkCSSJIZDhwfp6upi794D5HLredeVl/OLe39MPl+mmF9IOp2m0RinszvLF7/0WZYvX8mmTZt46cXtfPs7/0Kj7rGwdwWPPfEopfZOurrLLaRBmaUr0mDniZVPqTCPsbExxscbOE6JsZEKo0dnKJVKTE1XidtNepddRFvXLibHDmvHCNrpJGbjzEyD7nklBg4P43ujLF3SQVtHnq07t9KouDyzdTsLek9mxVqHSrXK5k3b2b39PkJ/GsOx8DwTI64QSsHkRAUTE1NpfrcBKBXgWDY/v/8nLFu6kvbOJVRnxhGErazLBM9v0jbvODLZds5927U8velB2sod7Nm3m1KxTLZzEcvmLednm4b5uy/+B/O6QSUNcll9UpdJg3o9wU6ZdLR3E4Y+od+gtLCXgUPPki+ZSLfAP33lswwOHeCdF1/Nu654Fx/56PtoL3cRyQkazQZOEtORT/PaS88QB9M8+dQDTIU12h1B1i6SmBVSNtx78z+y9IRLOfjKD/FMG0MFPHj7KJ/7VJqoK4dKPDZv3s3KeREvPj7EGcd/juv/5s/Y9crT5G2FtGIc1+JQfz9DQ/tZtLSDoyODfOD9H+fNb7yYW265hQWLFjE9PUlnZy+vjuzAtOvcd98vueyyS3BTNmvXrKJer0LiMXCkj0wuS0dHl64xsSRWcMHb3s4dt93GT3/6c07ccCLezCRTU30sKuc55/jjGKxUue7qc+FD/x+KthCiE4haBTsNnIceLj4BXIZ2kHwQeLD1Jb9s3X+u9fHH/5ieDdBIQiZLFi+PH2HjJW/HQrGgvYsdO17hrMsvYJFT4PDhUdK2A1K1EmEyr3e7MsQwodkMkLFDLpUikNXXcw4FmKZe4PlDotrrmFLzvxTzlluNIADXTVohuT6OY7fIgcnc1xstGSVKIO1aLdKq7mgVumgIwyIIFK4jcF0XxzGJo5B4pk6Y6G23UDRJIg2zyuYc6o2EuGkjVZUli1fyLA5JGIFMkH6Ek3FInLS2eEkLPwxJJIRhTGdnJ/sPHiAM0GjR1o86jiKMOMYQBo7tYlgOopVgLxQ6p1NK3JSNihUzMzPESdwiIurim7Qe1LIsPvj+T3Dc2h5+cnub9h7H2q44+4yadWJimoo40SdaiT5RpVIpgqYeleSzKVA2Zm8nxfYOFq9czJHDO0inLAYHZvi373yWIGhiZxw2PfM4S489lscee4re3oUIM0WlUmnRCuMWuVDgeU1SKRfQPv1KpUKpVEYIyXPPbOKCC8/FTmU47bTTqcxM0tPTxdCwjaTOnXffQz5X4uGHH2Zk2GftMcvIZX06Otrp7Jqms3s+IGlrSzM9VaFSaWBaacIwZGDwMEmsSYy+7xNLidG6oFUkTE9P0dHTRaZQZGJUtbRj/uDqRB8/caS9rPV6nYW9Hex77QBbnn+JffsnaetaSKUuKXfMw8l0MjPdYPxoH8gAfA+kS8qx0E5VhSIkaeU3IkyU1M8R1Krs27ubpUtWI5MGU5P11u8D2E6KYrGIF+VZeswaHvv1jxiemsHNdzIx2eSs3sXEpqQ6E+A3fIwwwDAVxAoIEOhloERKZqamcVI2YRhhm23EoYlDjiCpUvcmWbx4Pg8+8BPsVMyH3v957rr3JkIvpJDL41p1VBQThDXWrFnKD77/T8yfPx9lGTSiBiIyyOVsXtvxGO//+Dc4uO3XGGIUafns2PQ0Q1cs55QL19F3dJhM1OTFlx4n5yQIJ+Lw3gGEYbJgQSevHXqNhYsWc+DAfjKpDpp+gzCM+eQ1X+DZZ18gk2pHiQblrgxDw8OsXnki13/6z7n22mvp6elBJhHV6gwyDhmfaLJsyRL6jwwwODjAxFSdjGPxxj87l2c3byaOY5YuWUr/4SN0Og7lYoGaiIkbNbqV5LCS/LFR5P+m054H3CqE0MZkuFcp9WshxG7gHiHE14BtwA9bn/9D4HYhxAFgCnj3//QEphdx3KTBuStXcf7nryFnQiWBDQt62Tr0c8o9ZbaOjHHjv3yNnJPCNF2qnteSGwxM00AIOdf1zjKlwzjCslwMZRMGEZhgW+4calUm+r5h6oWY2ZBbw/Bb1j3dzWsUqjVXoEUrUFinuWvZBEMXt2bDx5jbvtT+7SiWWKZBHEuiKMD3E8IA7f5IIpx0hhCfoF6lkC7gNy3a2kwmowYyztOea+fCK97H5t/cBlaEHSrtPHFMwlgSxxGNEKgFXPS2tzMxOYYhDpByodVoI1rLG6EfYBqQdvKks9m51PYoaKKEJImaTNYmWyc0zS7u6CgzOjKiU85jrddHzSpXX/p23vmed3Nw91ak0EJIIhMMYerlHdPW3XYUkcvpGLaOjg5SqRSTU0dpL2Xh8AwTwwewTcmKxWWaQYWjR3aRy0gGDk1z4zf+mvnLj+W6v/grBg4N4Romr+05SDbfxuhEhTvuvBvf9/UMQ8Btt/2QLVu28N3v/ifNpn79s4spBw8eYMmyRfT3H+KF5x/jLee+ga1bn6PeqHDoSJbBIxOsXL2A0dFpzZFJz2PxIkmSuExNVbEdj8lxHz8YJpPVIQXpdJZGpUYQGPjNOlPjI2SyaYLQp/9QHddNEccxM7UJzVFXcO+9dxPHIUoJnJRDFIQt10grHlho37Zluhw6eITh4QE9xBQOx64/jZGJBoEokoRZCp3zueDYN/DoQ7cxMbyPyDuKaUn8MMY0tUNIqdYymjQwRNzasgQwSKKIAwf2ooSPaUiUFAjDJuXmObp3D/NXr+Lxp/vo6T2Pwzt3c/nlHyCdKXHOW86hESZ87zuPc/TQGKW8j+MKbFHASoUkGBiJgWXqpSXHsRmbmmBp7yISlSOqVLCpk9gKmiN0ZOG5x55haPznzFvYw9dv+iH/fvN32PniJnq6ioQqJBgfYOGCHv7hK9dTjRIuOu9antt0G7WGh2CEU086gb43vJNnd96CmIbHfvkDrv2rK1h/XhlzSw/PDezhEx/+Aj+76285dX0Xj29+BENqG6pCsvqYY3ji97+nlCuwfNlqgtDg1b3b+csvfp4Vyzqx3CqH+o/yta99h7vuvJtPXX8NvUsW4TdmMFAkcYSMI7LFIkHQZGqqQW9vD1ddcBEvb3mBXz/4ALbtks2mmZgcw83lsWxFFHo0vZBli5dxy4OP8tG3n/9H6+X/qGkrpXYopU5USh2vlDpOKfXV1v/3KaVOUUqtUEpdrpSmkyul/Nb9Fa2P9/1PzxGbgmBegd3RBKcumc8j99zJ377/Ej72nsv5s/PP4DcP3sMn3nI+xUye2lSVONHdr1Q6yktJ0ZIvwpZFz5tLGp+1/+nXJgCjdSCLFkfDRGAShglhqLVbsxXyO9vJz4b7gtZRQYOQZn/RTPN1sJJpCuI4af1RLS1dL7XMYlxnO/QoDua43giNyUwSRdiU5DJpTEt3YJse/QXrjl9PvRlhOTaJkiRKkSvkMW2XWtPn0ivex+IlazDMNHv2HkAlEEXQ09NFOu2ilM6tREYkMqDhVSAJaFSnqM2M0qhPU5keo+FVkTLCbG3ama3wYtc1MUyT1oULKo5oTgyydsUyQq+BiGnFcOlbkkRzP48kSRBKb5XKOCJuxVsFvn6/S4UchUya4dEJ8qUChpmiraNMJit49JGneO8HPkF//xCFfBtCmHR3tNPW1kYQBHprVQBITj75eL71rW+wa9dOVq5cwplnnUo+n51DB4DAcU1Qiv7+frbveIlafYq1a9eybNkqTEsPa6cma9hWBplYhBFImWoV7imkahIEAVPjU8goxkRgmCZIRSFfAiTC0LqYkhGJDEmSgCTWx6Bl2/Tv2s7QoYN6Ld3X4DEh9EyCloVVCINSoahnMKZD04vxA8HYSIXJ6TqZfIl0poCbK+BFMSduPIvuhSswzbSWWgyDJDHnjvFZCqQhTM1ft1IgUkhlI7FQiYlsAdBQGgYWZ3sJCel7/kdcef01nPLWi5nXu4ZcqUgQKSw7YXy0CsLBMBRR7FH3fLyggSLSpgGpMExJHAY4bo5Ko0lb10K8sEKxWKars4v6tCRtd+J7I3R3pTk63M8/fu0G3v3u99E1bx5HhmeI0bKXcjwsW3HLzT/j05+6lhVr30Qmm8Zwsmz6/b1sOPlMVFNh5cFS2/jJTx7hreceQ+/SxaQti/59U8SNhON6T8efPEA2m2ZmZppsNks+n29Jni57dx+hu3MZ9//iAeI4plKtsXvPfr73/VuYnJjhhZd+z7wFSwl9j3TKwveqqCQmn89TbXj0HRrgjW88g7df9A7uuOMe9u3v04EtQhGFPpaAdEpS9WpM1So06jFJbHHL929l3PzjYdx/EhuR6VyOI5PjrFq9hHKhgGPCI48+wb6RaT586YX8+w3/wpatL3H2FZeSSacJY4Uf68tK2zJIZIRra260ZZg4JoC26RlpB0wTQ4g5Kt/scE13mQkgSaVsZhNLkiTBcV3CMJpLYZ/NnLQsiziSNJs+2axmaAdB0NK9E6JI0dVdpFppYNmCZiRxDUEQ67SVtD3rRtH5lVHQxBAOhh1jWhpaJWJB5CkCT2CIBjte/gWGbZBYbUxOT5F2od6ABaU1nHzaOprNSX7200c4+bTT6esfpeFJyuU2fN+j1qgSthK9hZS6IsgYEhg92tq8ErrImKZJIhNQBlKamJbAddPUZyosW76S3XsOYFoOKg6xTZBqBhlGdC5cyPihXSgjAClb4CNLnyiE5rNIFeM6gvGxQ+TzRfKFLCLRnfDkxDSGCil2pnll12uU5y9gaHCGdcevpVhKSqpHSAAAIABJREFUoZIQJNQaVeIowRubQCUTLdyAMRfUPDg4yMkbTqBcLjMwMMArr7yC67q4iYvn6bCK/a/1s3z5ItraysjEIu2WObDvCOVymWwmT72a4DUkMqkSBpIwrJPNelruCMAkRxIEpNI2SSxo1GcwhInvTRI2dQ/UqHkIQw+840jLRYZp6/xHw6Z3aSczM1Wmp6c1q0ImmBYUikXdIEjdbJhCD7WbKiSWCUuXLmZ4skbXgqXMX7IMK5UhVejAMQXlVYvIpHLct38flqiiZKSvrnCJZQ6sDNlsm25CsmnAwKvrwbGK6kRRhbg5AkQYxKRSGbzGbna/+Az5XJa1F3yeBQsWkbhZUmYGpZqUShkO7h8jX+rAdKvaamu0E1AniiW1RoRlOQiZIlImTqqNyUqNjWdfxYFdBcaGn6LoGBhOHsN2cA2Lqj9FLmcyMbiHr3z588xUp7nobZfS2VnmrnvuITeZ4BrwuU9fyXnnv409O18lW1pCZ/c+Hnn8t1xz7QUQmiR+GkmTh35wM1+5+R288VTB726ps2TtCnbt97n8E5dy079/krZUCYXHqaedweDgMCetX8/S3sU899I2Nj3xLG3FFJDwkWv+gnVrT+DK955PZ3sXpUIHYTiGJWMEBu2lPHXPZ3DwKGee8yaWLVnO7bffyeanXqSUz+FYNmEU4Lo2piUJQp+cXaLqFhgcnaKrYx633XobF1xyJTf8n2/wnT9SL/8kirZjmtjViNXpLr7y6l7+5m++TDEIObe7h6mBCb7w8Y8S1MPXAUsCHYLQ0gFlYtKMEvIFQw8eHYFKTMxZfTlWGJbO+XMc7biYlTd0QY7nmMmua87JLLPLDsAcQCkIEi2rOALT1F14FEVzMCr9uYIoimltbRNGEBtgtB5PSolt6RX3MAwxTAta/AghTIKmdi/oHETdge3du5fLr3wf993xXYIEVq4+lvk9Kxgb8xgdHeSEjWeTzRVJLJ9Fi5YwdnQ3tm0zU6mjpJZiDCEIQ19fAcRBy7rY6o5bK9QIHaqllO44fN+nvbuLSqWGk8/r4WWiu+f2ntXkchlybZ0IArBs/c0iSWSk3RDSnJsVOK6htyVViIrBbQVXtLe3YxITxBEnbVhBsXM5k9NT7Ny1j20v78dr2TRlYmunQyL02rCSrYGwfi7QP6PHHntMB9UiNPKghVpNEoVhQrU6Q6PuE4euhmwZCZZVp1qtUxchhmHiNXwsK4Vl5AADw5SEgYcpCsQywff1z0efzBWGmI2xMyiWyixZvJKuri6SRFGrVeg/tJ/JyQmklBwZGiSOZQsOlVDMpRGOiWmBVAn1ag0w9AyHmEQExIlFw6uRkMawLVKZNKaTwkmnSIImQphkskWQgkRAJp0lk+rESReQVg5lOhhOBqVs3JRDGCckBDRqVZK42eKiGJiGiZQRlim47+d3YaTTDImEb3z7/+Bh8ewjWzlu1RpSKQevmjA9VUcJUxMjozphEpAqO9gYWNLEUIJYxSAFYVTDcS3qTUVb5wkc2P1bZioR5VKOejSKJTqwLJ9iOY2aCan6HuW2bn79m59z+eUf4us3/itf+vSHSQQsWuHwyO8e57ePj3Lhm0ssOqmN0cf34Po5jadNNzGaeeK4nwVSsGqhoLJrgPAiRU7GegErruM4Fo26Pp6Hho6yatliduzYwQ1fvYnBgRkwE45du4burgVc+Z6LaSusIJsxqMqjuE4KB5ck8PC9Bl4Qs2jxYnoXL+GBX/6KfL6IoSQCqV1kImnF+mkpb6B/iHps8JYLL+Kaqz/NT267lcCr8qtf//BPv2inUim2He7npakqX7//NoZHR1nc3kEDn7GjdR7ICaxLzmUiFRHnXGyhUF6EqQRKSqQp0aEwBgKDKNTSSBSEOIUC0tThBUkU49gQhAm1WoTrgm3aWFaKVMGiOlEnbysyeQvf011gIhMs0yWJE5xMithvYDqCOJFIZaHwkIlF0AzIZAWuazI5OUM+l6daa+CYBtlMmvFKHcvR+rEpBLFMSLkWcRyRzQJ+FtuEQs5GmCFIxdrl8+g/MoJlufiVXXS1Xc/Fl32GkaOTHD7Ux+GJI3SUiigjwon3M7RrADtbxLX1ycKrNliwoId6tUqSQBj6CGEiAFM4RCqeK9xCgLIEZqJwTFCxRAURWSulP45LXA8QIsJ1XIIgYXzsCKedfxFXfOIiVi55knjwNRwnpS2PSCxLYCGRhkUSQyIlmYyFbQkqlSrzFy2EYXBci3K5nS2vvMwr9x3gxFPr5PNF2tqbHDk0RqmYp1qtsfqYZRw8eJAw1NuolmmQShusX38K2ZzN1q2v8Mzm5xBC0GiEyDm1ZnYObpDEBuNjHlDHMh2y2SyVap2xUQ/TsEikJtxJGRPGTYQyaDSqaNu/QSz11ucs7+Z1uc3FyRTZeOZbseyU9rDbDo4Bi3tWsfGMt7D1pWfYvWsH+VzUktL0voDv6zSmZuDrk4sEIWLCVrqRDAWYBn4YYtoQ+S0NNZIkXkQqnWbSmyCTT3HRFR/iN/d+nzCq4kVZkAfI1E8hlgkq30A4OWSsQ4gdNwciRUd3L9KvMHF0hERqNnejUePKz9zIgfMuY1EGnh98hcvPO4vxwwt5edfLnLDhrUw1Eyb6ttN7zDEEjRopsx0nm8aUCqEMpCkIkxhTWhgxRJFEioAKKYJgMWs3voNLLl7Hy08/ze8f/z1mMk2hy2WmEmD6AYEPxVyD1at72fL8b7n/5z9m6aJlnHPOOfz28SfAPMw/f/1aBhoJS7IOyurg8S3/yrKT3kHftgdQbgMzgH/96Sjnv7EHGKejXbH+/JNYd1wWBxs/3k8SS9asPAU/sNjy4mMkTcGq49ezbv3x3HP3o3zusx/mxhu+RG93BzV/kiBO0WhUEQSYmQLjlRonrT+BbDbPSy+/wnNPPkkh4+LFR4lCSRKliJKIrvb5eM06E1WfNatO5MYbfsw/3fiXPPLQL3nisV/T072IzoVl+nb894s1+oj7E7gZQjAzXUOYLlte3MrQ6AibdjzHcy9uZWRmkr6BQZJEkuoqEpmtvEcFiZLI1iWy0QI3KaFhSto/PQuUUuRzmZaHW5FEMcVCno6OTmwHlBRUpmtk8wYLFnYzPeWTSJsoBNMwMQxFOmOSy9jksha2IcjmXIKwQRwJTCumUBT4nqLpJaTSDnGiKJfLRFFCHEss0wHDJp3Kkc7mSGUzKAGeH4BycOw0uXyGujdKGEaYtkul3iBJFFEYYAihu7VKlUbokyrlKRRzGEZIszpFZawPW9SxzIhqbXLOHz4+NkkQthCrSuDYKS3xyAj+wNSj9VTtpY5jENgUMx3YZhrfTxGGutjbptbyDVNANsNtd9zL1R/+Fqe889O4TkfrCsaaY5MII8EPGti2QcrVNsmmF2CZ2vYIUPd8du/bx9GjNdavX8eGk4/FFJBJF7BTFpWKLpSdnWXOOut0XNdEKn0SeO97r2TlqqU8+uhTmqOS6KGj+n+UBaUuloaJISziJNRRXsQIMbuwpV00pila8XDa8z/rNJp7pD+4LzCxUjm6euYTRDE1r4nnhyQKEqWoN5qMjo5iWRbd3d2Yts63bDTq+L6Gcs26l+Ioae0QODT9ENOwW99TRKU6Q9a18OsVVCiJmxGFdJ6UZeNVmlQqNY47bh3d3fOIbQnpDAQFMGyypsAwfKLYo9xWpJjP4bouqVQKx3FxHKelq+uYIctySIYPMz8fsd+fwssoXt6+lwvOXMLyhd2U8oLKZBORlkzNHCGJoNHw8Op1/FbU3Sx0TTuyEtKuiZuy8KOQQrGDI4NTfO1vb+DUjRv54c3fJZYBE+N1uktp/NCkUMozMVJnoP8I0q+xbPkCDg/08ePbfsK7Lr2Sd1/1Xp585A5+8eADJCIiY4U89+SPqTdBKUszhoyQpzZtJgrA7C7zwK/vYfmijfzi9p0kJBhmgtdM8H2fXbt20mzGlDq6ePLJzdz8vdv42Mffz9BQP6YQRHENYeihdzqt378jg+NcccUVLFuxksc3bSYImggiorBBfSZCJjaFYgpDuPT1HWLk6BS3/OfdfPGLf8O1n/kgzz3/JOuOXUtXezueN4UIAzo6yn+0Xv5JdNoySdi7ay+jowMsmb+QMGpQ6phHys3TrMWYGQuBJKhMocIGtUaVnnnzMG2DJJbEraGjRNAMQjpKRYSREKmYhARhKEIZYaYV2UIbqSSiVqtR8wL8KCLtWqSFw9hYSMqdwHG1fY8kxLYsXFtfXkeNBiJKsAztcU6nbaRM0fBrJEaaNevXMlOdQaLwGgG1KMHIljDdNJ1tGeLAJ5Ex2VwGJ52i1gQ/sggTCwuTfD5Pv7TwI0FSiTj9jNM5p2cBd959F5DioV/dxNsv/Th7du6hVC4y3tdH5E1RKnShInDSebxmjZTtkM8WkLJKGCT4foBlazZK3dMFcHZIOxv2qzAQiUNCQiJACoPT33wmjabHk0++SL7gIPGQCmzXIYlj8oFk1+YXWHXS6fR0l6muPp5Xd2zGtpzWkFH7s8vlAp7XpFbXwC7bSpNyUghbH37bdu7h1JPXcczyAJuQof7DpAyD1/Yc4Ji1x3D22adiCJtGo8nwsM7J/NSnPsLTTz/FvffeSxxLkAZHh8c1l9ow5s5Hf5g4r/9OtF/ZABKlQ3gTTQoE2Vq40kWmkM+Ckvh+QJLIVtborJ1Rtmx6WtYqtxUpl/I0poeQStBseFRtGz+ok8iQRmUKVBOVxJp9YxjEYeskgo0w5FzhDn0dfec6Bk3PI5EG6YygOj7M6tUnABm2v7iNJcvX4OUnsV1Jo1Zn2zOP8cBIneULV/DZj93HRVesZG15Pc3CMFL0IJwqrmlRq89gCi2t6CG7bOVFamlLSZNIKjpWzuf2h/dyxVvXceGZ5/DTe5/l2nUxH73sWA4OwuSBBGnUUMQETc2jD4MJwtjBMnIELfZOKl3AEgZxpL372aJDvTnNuW/5OPv3rOHm79/FzOQYmZTNt2/6N17dvYt/+9bNUPXJFQSuY5EgCWs1UmlwHIPv/dvXkcD7PvM57rv7Tn73+wbnv70LsPnqP/+Ar//FB+kf+A2xijjyu5t48a2ncsH738evf3Abp3/hDP7qi59CuCmmR3ze/54Pc8c9PwY7xnKzfP4vb+Cb3/oSoyMHWbP8RCpmlUwmAcMmbiY4rmB4sElbdgnve887ufPu23Eci3JnnjD0wUwQtkMzsqk1QhbM38BnP/tBDvUf5Gc/+ynXfOxqlBAsWDCfefOKTE8MIZMQE0XoTdLRNQ/G//t6+SdRtOu1CqaAu+64m7Z8GmF6xCokJRwCaWPYCssWdHe2MTg8xpJVK2g2m6hYYioIQwVSd5Ku6zJdqQIQh5IobCCkllujEIJgEiFMGnWpYfXYCGUhIx/TMMCwaHoQ+Z5OX7dMGrUYzwvJZEyCQFIopYllSCzSxMonJk+t7rF9936mK1VWrFjGgYERDMPgmGOOYXh4BOHVWLhwIRMjQ0zXfTrTefJtnQjDBaGHdtu37cA0UpTaOjlh/UkMHR1hcqaJnSoS+RMgYNf2F3CthMbUIH40g60ihGyiZIxQtna1YFCtT+N5AaVSgTiSmJag6QVIGc1pzH94E0rzwE0zaaX/SIRoMDk2gGUnTE2PY9uCKFREcYJSJjWm2d/3IitWdzI0nlCb6SdRCU2/iW07rQKpWlFsYYvKqAdylmPT168vA9cddwzFfJ56JUUmk6HZ8Ei5aRb1lvnIR9/Nf3z/Vvbv70MpWLq0l49d8wF+8uPbmJycwXUtwkD7s3VIQNiCeb1erGf/DczNMXS6kIHrplrvi96ejOOETCaPm7Kp1aaRiZpzzLx+k3OPDQIlIFssEKuYaqOObdt4fg1XuQReHRn72IbmmzipLFGYECeSRr2pX1srSCNqsd+TRId0JInQejwQRwGGCSMjh1i8aC2h53Fgz07Srk3Tr1KpNZgeP8pZZ5+HsKZ55KEn+djH11IoX0DAb0iSkESmsURM2nEwhTMXbj1LY0TIOfqaZToYM1W+c8NNLH/D99iYsRjzawjp4FgeUxXY9WoFvBpxFqwkrz3pmQhTuCBjpNIwuDgOkSgco4jn+cTmUZTMMjyiyJeW0uebLFrSQV//INdd92kuf+dVXH/dn7P5mcfZtm0Hme4stVqDlO3T0z2fWr1CLgM9C3u546ZvsmzVIjpLFYTXACF4YcceVp/4Nvr7f4WDxcDQDrZv2cyCVefTuWQtVlawa9fzrFq2jHpjkoMHDxLFDZAhDz/2HKduOI2//MKHWdDTS6M2QtQ0ODxzhHwpT6VWZWK6ytlnvIHFCxdzz113MW/BPJ352qihjJggiTk8NEahMJ/zLj6PC867kGefe5If/eh7CAw6yguIoiZ+MIZjCFIpl1pd00W9KKKp/gjijz+Rol0oFElCn9rMKP/w5e9w3wN3s+HEkyiUs0xXYoLmCKlMmkCGzOudJvK1XJAqZPHqHmnXwkLS0dFBR0eZzo4y+XwO0xJ0d7QThE2UivVAwLTnLtuEEDS8aYJGQmdbDtvJaFpaaFAs5zhyRLsKDOHQ3lZmx64DYAjuf+BBDMdhfFIxNR2zaEmRZqCIaiGJdNm7b4gg1G6WF7btIp/J43tNhkenSKccHMehmcwQBAHJhE+toXBNh4MH9iJSBhg2ew/0cfYb38Tw0TEWLob+vRM4KsPA/pd59weu4eFf/opiOiHnZLBpUPNDPExCkZDK5PX3b+rvM46aVGYaWoMV9twQTxhae1QkGvZkJpiGTZBECASPPPZ7mn7MsatX8YY3XMYHP/JeujuyLJjfgeU4NJkhiFwy7nz8isfgJ9/JyoVrMDA5PHCYq97zHrZs2TKXAm8giKKIVCpDuWsek0f1Em0SxQyOjZDIiJGRYZYduwavGTB8dJqv/f13mJ6Zpre3h3e88yKeeeYZbr7pByilHT+BH81py3ogbDKbTKTJj8Yf4AbUXHGeLeyNRkPLZrFk5cpjOfm0U7jn9tvwPB/TEnMyy6yQpP3u4Lr2HPEQBSYmMxOTWIakXplAyAjfkzTDOig9fLJsPfhUuERBSC6f0ZgBFH7Tx3VtlBIkcUzazSCVgWVLwsgnimNQgqHDhzhyYJBVx55AR2c3fnUfYVjn6V89QSxn6Hv1BawlJV777df5+SNvY/FilwMHlhEYfViVRbgLaxiRpaFeUgIxhmOS0CrYzF6dGJQsg53bdnHZOz7L+GM3snbtBhKrSToZpd1ZyrPPPk+haz523sMUJU1AdAXNeoRrC2Qc6ybIr2M5NqHysEQeM1bUm9OIaB6dpU48P8ELAiwg41i8tOUJ9h46gkLxta/+DVLG/P3f/zO+B7l2H9NJUHXJ8NBh3BQ063lOOmU+X//WrazecD6XvOHtXPrVW3DubyfkKGYc8PBDP+MbP34Pr56xlEsu/msMlXD1J6/j1u/fxu7dR/jOzTfx3NbnsewO3n3l5+npaEOEFWJ8TCfCtWwmJqpc+p7LsF2bO2+9m62WS1dnAROFTAwaXoJpGnzm+r9j0aJFXP/pz/Pze+/k0YceQIgcPd2dyDhAqCqWEeMaNoZQ+H5ELtNJo+6TkoqpkZk/Wi//JIp2lER0zWvn6PAkd959Ny+8+DyXXHIJY2PDtLeVUO1Z6o1pFnT3EoUHiOIYwxIYMtHNQSIJBUxVKyQovMAnm3OQkWL46BhBs4mSTZQUf+AM0T5sO+WSsh1276ohlKQZBpiWRb3eZNmSxby09VXKXYvYvv01hKODDipNQd5J04iaONkcA4cnyRdyxInGn3b39DAxPUUUhsxbuJC612jZAm3iRFGdnGZquqYT05tVAq+BaTooU7BiyXIwTPoOHebFF7bS1dVDEkWcccab2fL8s4DJwIE+jlu3lrGB7RiGi1IebtYBx0L5PrEfcHRoHNvRA1Lf13Fnhmil5li6+JTcAtP1KqYJppEhiRrERkAmnaF3fjsfuvrdnHLKBjactBFpKiZmakip6Bs4jJ02yBczDAzUqMwcZnLKpHuRy6HBJ2hva+fU1Sfy+KbN5FyTXFs39coEhgEWjgYSqQhh6pHKMcevI5t2qEwM02g2KWQLTE4epndRD4f6j3LVVVdQLrfz41t/Qq3WJJdL4TX8P+ioZ7tp0QqdMJDS0BY7S7LmmFXs2rmXFcsXsWTZYqamKkxNTXGofxDD0NuZvu+z/8BOSvMX6cdLpZB+QxdpqU90CSEoG4g0sqB1E4aBaxrIjIvXqKLiiET5JCi9Nt7yGIdBg1iCY8tWwVc0mwGurfcApDRaFlQ93JRKu6DSqRzKtPDjJipMsCwYGTzEzOQEw0cO4Hl1ZHQEM9fNwT1P0ltZzZbdmzj5mEV86LwbMO0/w+7qwkn3EDQ9EtnANBIwHT0ctBR+FGKYJjKJieOIREWMVAV0rqGybRszicuxa1wMlRAZRRYslNiVCCOVZnJsnHQ8imlq3AEtuSeKIrJZmyCJAR2HJpMGhpBYTtLi4Cvaeo7FSg8RG+N0dhcY7Juku70Lz6vzlb+9gXnzO/nMX3yAl146wNNPP6szIx2HhJBGCJWJAeZ3rOT++35E1wsDfO2B20mnl/MrWcGwcyijQWXnLzjjZInjnMSfP2jSueJc6jMRrx0+zBtPO4lHHtrMQw/dzjvedh1PPX0XZRsyGYNYpUlnezg4cIiNZ5zE8OBRNj/9PIV8CsdV5IsZ9h0YQmHwvvd+hAsvvIj7fvEQ9//8r0DU6OqeR7MZkMvpxbNYCqRqEsURtWkDFeoTZSIrCEyUYZHP5/9ovRT/w4b5/y+3np6yOvuNp3Lfzx7m/vt+xrPPPk25vUBbucAr23aycuVy8oUMflBnZHSUcrmD5StW8YGrrqFe08XQsg2KxQLZbJaOjg7ctN5gTLm2fpIWbArARF8Suq5LrCAJA2TkAxIMzd62bJffb3qKYqnI5GSFfK7ETGWG9o4OJicmwLAotbUxMz1O2km3PNo6RURK3YlJFFEYas93ECAMo5XyAqVSiSAIaHoehUIB0zSp1mr6QC+W8DyP49etI5/Jsmvnq0xOj3LmWRdw+PAgGzduxFDwyo7H8JsN0srGtUCYJtNNX28cVqZQSlCZ8bFMB9uIMU1BmEjiONFBskpDUj/64fdw2ukn8t4PnEfKPp44nKHRaDI5M45pmsxfWGJ47BBBmKM6Ldm2pUKlErBz90HWrD0GkGzceDqJPcjiVavoLkObGRMKg4wwMew8SjWQiSSbKQAGPfMXMzU1wcTkEEsXLqCnu4N81mXn7l1UGwGeH/Peq64kiBPu/+l9KKUTbnzfn5N2Zv32syvgQpgIkbRSjHQx1uETRivkOca2TeI4aS1Fve7XX7x4MUcO9pNkFnDle67kkYd/x/TEEElYgdmlIaV1b+0PBykVQhggTLoXLEYIQdwMkIGP59UwXBNB3HpeG4VOBZLKQCYxlqU3bG3L1Y2E1As4EhMwwbQxlMfGsy5iy1OPYrlFhNBsd0O4GIZFFNVAJKBCEGk2bjifOx//BSnTo81OkzFiLHEhyilp3ocaQCYGUrlEUgAmhYwkSmbwJnai0K9BSMEnP/cd/uObN1JccxIf/8y1/MMn3sxD2yd5+wklUC5PbR3n/Lf8PW0dGfzmPlQswNK/W5aT16/TtBCmS5wonFQay7SxUiYxirzTgykNMvYU27fdD/5ByvkcuVyK4eER2traMC2J59X1klzT4qqrL6S93M2/ffs2pIgplW28IEd7xubIxFHmL1zO5MgEYWCycNl6jvQ9DU6EFbbjZpbT8LbRse5TOI1DLJ/fw3XXXcc115xDpV7hn799Ozd86e+oBnuZ19FOEsZEiWDDhg3MVCbYuvUViqUyzWajRfSUnH7a2Vx88cW88sor3HPPnQC0ldrI5QoopWgrZ1mxdAlSKPLFApZlE0U+uXyGynQVmYDv++zZs49qtUoQai7+0PAgAl5WSm34v9fLP4mi3dXdri694m1sf2Uvb33Lu9i3/1WOPW4VtgPTEw2UjHEci86uEkdHR2hrK7Jy9So+eNUnmZlukMpamMJowfk1E3h2QDR70/1YKylctSKrWsnhwgCrdT9pbaSl0hZxIoijiFKxoDfEYj24K5fLTE/rxRTbEUSBxGhdhpumSaLk3KW4Ulo/NW39+jKZtGaVRJEOVPUTPM/DstAhBlIP75RSZJw0+XQKr94gUrBs5WpmqnX6D/Qxf8EqJif7WLNmJSk7xdT4IRQhfmLiOC5+M2yF93r6dVqasXD2GSdz6sb1XHHFRXT2LEcmFX77yK/Y8kIf999TZWKiztiUj0kWZUQopli9ejVvu+gC3nnVPCYmPY6OjFMolJi/vMTw4AxeI2akv8DUaMBLW59huH+Kgb6fEssAw3aQ0TTZnF6ZDgKJaTnMn7+EOAkZGjrE8iVL6eoosXfvXmzH4kMf+xgvbNnKpic3gQGFfJFardbS3XUkW9LS5mfX82dv+UKaWrU5hySwrTRSShpeDdAkyDBoomDOYw9a8jjh1DPY/mIf6VyG9175Pn74w69iKKcVtCs1KB9T/7tFkLzskssJo4QXt23Htl1kM6YyM0MQNBAGRHMUSVsnFiUJQkStY7EVnqFiBNpumEo5pHNtJFIjCALvKM/uGuOMdb04TgcWELeOqSgMSKcsmn6NkzeezvR0QN+BCmtPfgvbn7sR7D68Zi8v7qxw4WlfRnQ9i5FY2G4OSGPYGQxlknFi6vURZo6+jDBbJ6hEsnDN1dSrNRpTL7DohDN5+fG7uOxrP+ORf3wXfmyRMiXCej9OppN05x6MAKKkjCBBOBoNkcsVkIYFysC09OBT4ZIoQSZTxjJSuFbC0YEX+MzHzuX4tQt57oXf8q83fp9QhnR1pmhvb8NvAGaIF/hUKw18T3DCicdz5jnL2PToNg4eHCVoJkgn5ENX/5Cp5n4e/OnDEA5QsKeIE2jioITDqRcQZ4YkAAAWsElEQVR8hle2HaQ97XLi8av5za/+ho++/3quuf4G3vqmYym2SQQmx6/bgG3B3n17OPaY9UxOTDE+Ncqbz30T5557CZs3v8T3/+PbrFixDNOAV3dso16rkHIFUZS05EhtTQXIZUsI06CQL1FrVJFihp7uBVQbHjLSg2jb0HVrcGjyvy3afxLyiNY8E0466Xhee+01Nm48jUp9kFQ6i5SSfC5HGHr4vkcc61SVKIpaAQezOqMeqliWwDR05z2bmu5YNplMhiiWTP1f7Z17dBxnef8/78zsdXZX0mp1l2z5Gsd2bOdi4thxLiYhNk0aKCEkdWnapuVQAqc95XKg0EJ+BQ5w2iSE0hRKKW0SSiBtAqWnTZxLcyOO4/tNdny3ZGm10mrvl5mdmff3x4xkNaeFAklko/mcM0cz746kd57defad532f7zMxgSKgtbXFLXzgjdLCER0hBENDw+5jtzeBEggGyeeLKAJULxkkNzEBuF8CpiHPTm7ZEst2yz+dzdRzr9GxHARQq9TcSjI21CpVpFS9DESLcqXsrZ8NAWAYNWLRCPliHhvYtesVL7iqUC6NYtRr7Nm9m47OHsbTacRkLXFVEg5KOjrb+LWN1zJ//kKuueoS+vp6uWDJApRgjOxQnoOHh/j83d/m6Wd3ks01UMWl6LEEsaYQtqlTrVkoVBk4tJNDh07Tt+j3Wb1mNasuupZXXtrJPZ+5n4FDL2FaMHjkBCgOevwG2vp63J6oCopVBFXFqJvYjoMEEokEdaMylcJvNEz2Dxzi2qvWM2deP/d/9a+p101Xm8VpUCwW3RUhjlvF3LLNKSnd6UqPsVgUwxNb6euZw+LFi9m7dy+2dGhJ6li2SSYzDkAgoGI2TITiKjG6HSmwcEGSE0eO8Ny2l1h53a3sefLfCARCNBo1wiEFs+F+BmzbZv6CeeRyOcbGsjiW7WqtRyPUTYO66a7S0YKWl8xlIRSHSFSlWrJQAyFsqbjJTY6DpgraOzpp2JLunj6EEAwcOARKgJHhUW+EITHNCpbdQFVcES/LDiCEwsjp47TPWQycZGDnDlQNRvIttMUM1l3UyryepRQiZfLlIwhFwbFtzHodbIUgCoZhwLQJW00oDJ7Zy6qVV7JnJMrRHbv52+9v5cTBw1gECIo0ZUtnfv8VHD95CjNfJhHooWFXcSyIRRLepLdwdcKFim0pSE1D1YJuURJRx1EVUBS651zMZz/3AZYsvIiNN2zg7i99jVxunC9/6bOMjo8QCEFLrIPMeGWqHOCuXXuoVk3Wrr2QQKCLPbt2gAX/8Pd38oX7H+OHD3+bcGsrxVIZIU2Siflki4cYPnmUpu4YxvAJyuMOV9+wmXff8WH+8+nH6E91kLNHuP03f5uf/GQrhwcOoes6j/37Y6hKlAfuf5BAQOG22zZSLJYIqUG2v3wSFYiEA7Q1R1FwIKwSibRTrhTRdZ1yvUa95rg1J02FkNZEQA2S0NpBlMhk02iaRrFeRtd/up72OTHSjsUS8qabr2blxSv40ucf4I477qBvbphwOETDcOsragFJJBpg6MwZonqExRcs4UMf+BgT2RLRmDtxYjUc99FYuE4bqVAquTdPQIOmeIxw2BUwMgx35j4SCVGqGJTKBqAQjYapVquAm7EIZ5eLCVWZKpJwFveReTL5AsCRDqoyOaqadCpe6fPX/7bQcKRAVQykhEAwgt2wprSVO7ta+fJX/oJLViynqSmAVQtSNmrUGzUCIQ1EAEcxaY4kUZGUqwaaIqhWcpiNClajQKJJR4s2k0lb/N23nuK1w1mOHtRobV4AIoDpxMkXcyhKjFL5ONG4Rc0YxzKOgzNM15w+KrUTFDMV0CpetEAAOloggC1tWuJRli2+jFXveS+hpiX81R+uJmprmFg0hOY+wjuu7KgQAj0SxkFQLpW568N3kclkePT7jwEWQsWtCmO5k8f/7YlJTK4pP6uMFwqFMAyDtVesplAoUC5XQQZJp9OkUimamuKUazmGhoZpbgpTrbl6MG9beznVap29u/aCI4EAfXM1atUWxseH+YdHX6bmGHzo9uvcupiWgu0YSOCKdWsQQvLyS68gJfR2z6U11UYmVyQcDjM6fIpqpUQkrONIC1WNUK25k5JCUZBqiOaOPiqlPK3xEKmmFo6dTlM33QpJ2CaOUaB3/lJ+7ZbN/M1X/gLQUWTJ+3K2EYqKdAKgqAQdk5a+hUwMZWmkLuTlbd9jdX8K4dX/PTKY44LFdxPpHUAxG2BrCBmmUZd0JkMMp1+jUT0E0g03BaTKssvfx003/xb/8sQPOHTyDPPaezk6IvjGPb/H5t+Yh240UQoESYQ/QqIfahMnSLXPp1QapFwtk2xro1wuo8eS3uqeBIqiYBiau+xRDyBlANUJoQiTHr1Ef9cZAoEq2ZzN88+9SLwpQVsqyebNm4nqOv/40IPs37OXerVMqjWFY9fI1SpIA66/4WrSg+OMprOMVtLc+/WHObbnKA987bME9F4uuOQqipUqhTrUaiWaq+OMjO1h2VUf4cIl/Tz6jc/wibvuYvfpo6xddw1HBvbz6ze+m0ZDpa2rk0ceeZB9u1+hUTcol7IMjwxSq1ru2nZA0SAWCxOP60hRp9GoY9QF8XgUaUmKhQqhsFdgpO4QaQFZh6BQSDYnKJRLJJPNlCs1hkaq5/ZIW0oolktoAUmpVKJaMaiU3Ecqq+EQDYUxrDqlYgXTMIjFYgRUNwHBtiW1qvuY7MYwLa++ocCWbnwoFNRoikcJBjUmsgWk4xCJ6N5oBVw9KMMVc/FinJM1IScRQng39utxHbG7guGsUz6b0j75O9bU33HbJh28t8zL8VLiDcsTXnJ46qnHWXfl2xhOH2PwVJ59+4qYjSqtrUl3HbpTIxx2bZCNnHQrYTs2AS1MKBhHj7eQiF/Ca0cG+dY3v8e+gyOMDgv0UAc9vReTzVUpFUwcpQioWNVjoFWolg4irQlgiLetv46LL13EM09XUWWBRiNBpTjqCRGZWI0iSI1azaBQybL1ub2cOf040g5gCVdDGOmKcKFOTro4VCo14k0JALZs2cKRw6954lxhTNPEahje++AWU3Acy4tDa65Qv+V+IYbDUWq1CpddugKjYVAuFOno6mP7jj20p9rJZNKMZdNcfc06Uq3NTEyME9NVFE2lVm1Qq7qfp3KxBKLB0KkGixb3YVrdHD2wg9/94J2Em5upT4zjoAMO4UiQet3k+PGjSC/elstlUQIBmlpc/eRQtAXDEhhG1dVaN8sgVYKxJC2dfXTPX0xu5DSF0TT5ehlpNKiVskAARagY9RJaMMCGa29gbGwCJdKGUy3iYCMQCNwSe2AhFIGpaJhmFYcKXU2CRx/az2WfWUu9BiKgsbg7DkYAaYSRDRshQkjLgaDElCbYJkgNsAmHFGp1i5WXr6JvcT83BW/m4Mc/zKCE6EScSmkCrb4SOyLQFXjXHVfx7JPb0EIOucw2wvE5BGxJeXwMu9GgYDaIhiLU6jYoDt1dC2iYFjWzSjSeolKStMTaGJ3I8fLzT4KYQFEchK2haTYD46f500/sp60rxXvfcxtXXb6e/YcOsn37K2TzFXeOQYWxTJ5FFy5h/fVzSbV1cnDXXoLhEKvW3sjBgwPkq2VO73yJ2IrrME48T7alld6+Vbxz7UX8177DJFoX8JUH/hIc2Prs82x6500cOT7IP/3Td6jmJ1i7/kre/a7foS3ZhRqAulFh8PQx0ukxDMPgyS3/xvjYCMVcblKzgpZkmJiuUynX0OMxopEYw+U0tgNOXSESCqMoCuPFKoZhU89kcWuj/++cEyPtQDAqb3nfdSxe3MtXPv9tVq64jGuvuxTLrpEvVImEwuixMEuXLmZsbIxqvcLy5av40Ac/xsjwGJFIyNO5dmf0w+Eg4UiQZDJJNpvFqNWI6xG0YBhFOSu3mssV3GxKRcGyz46qJx3r5DbJ6xM1fhnOhk885+1l2Ang9ttv4WMf/xP2H9hBc4tOMOTQnGyhVrW9JWAGqiqIR9qoGRN0d8+nbuVpTXaSz3aza/tx/u5vX+D0qRz5PKhamLaeVvK1CfK5II7lflBK2WMIcQIptoMsozhF2pNdpCfGuO1338+mjbfxtfu+wY6fPI+qqMSbq2za9A6y40WefGILQvM0oHEzHYXazO2f/hY9fXO4/wOr0aT0Sv1qCCEJBt1wFcCtt97Kk09tITeRIxKNUK/WphJ+zhZKdqbeC1VVz74nArfWpAK6HuKiFct4+9vX0tnVy59/+v9RqdRQ1SiWZaMqNoZhMLe/G9usupOZDUi2tjEyNoGmBUnoUUbSZ8hlx1FVt16jpoaxbAtw0JtTdC5cwrHtB2hNavTN7WXP3l2eaqG79tyyHALBCMsvXgsobrFo20FRdcrVGn29c2jt6Ka5JYWqN1G1LBqFYXZvfZrX9mxFFRLbUentX8jQqYNgO4RCKpFYK9dsfA8vvPACVrlAKXcGR7pzKG6sXXhVrQMgFdo7UmRGqvRf+g6+ePcfc9PGiwkzhlRjLJz3WU6fOkWiu0DDttBkE0qwTkRzSJ/Yj1DGQDQQjkMgHMYwOsDJsWbT+9j6H98lFO7CrB/l/R/6HF+/76OERB1LgQgphPpbzL2gwbqb1/BfP3qOFUsv4OToMOWJHFdvuJa9e/fR2tJLS7KZl17cRqq1nVylgRqIYcsoUgqqpQyL53UwPPgaE6e/hx6KMVEo49aIcBOgwuEYQqi0t7XS0ZFi6bIlFAoFCoUczz77zLTkKoEUCmvWXcXyFWvI5yo89t37sJlDx/KLGD34HP3LLsAyo1haEx2hCPt2/YCnXjwAqGxYfyFISVDTCWohHGy6u7sYGx8lHm1iJJP19G6qKML9f3o04U6eBuM0Jdq45T2b6e3txTSr1KoOlWKNzOg4P9n2IoXCBJn8fvLj6an7XkpoSiV46KHHuXHjhnN8pO2Aaboi4p1d7ezfv59NN67HsgULUh1UyxUQknQ6zehYBl3Xp8TjAU/+0x1ph8Nht2qLXWdkZIRIJEJLaxKkjaZqSKlgmia5XAGJG09nSuznZ/Tzl3TWkxl0MPnBcicfFBUUFRYu6OXee/+KRYsWMTg4SGdnJ5FogGg0hCUNorqKHgvjSAiFIjTpHUg5h1isk12vlnnhyUH+5oEvks/XMcwmtEATbd39lKsNRkZKSBEhoStUi2MUssdQSCPEIWxnFBSFcFQlkxvlh08+zvz5y9mwbhNj6UEgjKqoJFtS9PXN5fuP3O+uPrFc0X7bkajBCLfe+n66+/upVqoYMoiBgypsHKEgHTfBpqenh9WrV3Ng4CB5bzK3Xq1NWwEyrRrRtLZJZz7ZrqgCx7Ho6upidDTNrl272Pfgd8nligSDAaIxnWKx5Gp3SIf+OXOQjTq5XJZQNI5j29Rrrs63oii0JtsYHxvDdlxFRKSNioXQNIzyOGFhsGjtddSHdzI6OubGwVXpJcU0AAXTcJcCNre0Egrr1MwGeqKVJtOitb2bhqKSr5sEA3D85BlWLe7ipne9l3v2voqCRG9OsmDBIoaOHyAS1DGtKvlsBk0RWGaNllQLhYlBgCmHLRT3CwLHABkmEk4gRI3evjj/+PAWrrlyAZGmOpaR5J77Psgtt/wJZi1IRE9iNqoEhIbVKCJUB+m4j0UCaJg2hEJodLH1qadpbllIPn+AeLSH3fuG0ANRhG1SpkRIaSHS3E8qbjKezjB66ijlrl6McpahgX2Y12+gXq+xe/c2rrzyShrGBImmdvTmJk6eHqV7zkpyhQqRSAcDR09ywfx+rFo72UyeYKiJ5hadZcsuQk/orFt3PRPZAvv37OSVbS/w6o4dSMcmqutc/45NjI2Pkh2bYHw8Q61usvXF59GCSQaHRvn4lx7lhWefY3C0QoAIJ/ftQUVFxFfyzSf+HV39Jl/98gf54eOPoMgQiXiK5mScWr2IqjiMZYbRRBCjUiGVimHYJsFQinLZXd3SwGEkm8GqnQThsGf3M15WloYeWch1G9aTakvy+3+wGSkFpiMZPnOE9MggldIE5XKZl7Yf5/CRIjf+ND9yLoy0FTUqb7x5LXP7ExQzAb778GN89BMfoVLPkWhOUC4UaW9P0dPTw9DwIEIIli1fxZ99+gvs3ztANBqdunkcx5kqWDBZe89dE2sTCmsY9bPFel0d48mCBT89C+kNvFoANA0QDuvXr+ULX/wcqlbBMGoUi0VamnoJh2MEtPDUKhjTUjlxMk12zGDHtmHOnC6xY+cpatUGTqOF5pY21ECERKKDRqPBRKmKCIISMjEaVerlDPX8GWIpi1gCOlM2gYDg1ZcewxUJgL/++n2suvTtrF2zCai5wVBRAOEqAgZElHg8QamaxTTciVWkgqIEsB1B37yV6BddzxVXXcN3PnkjwjLBqxi0evWlLFt+IQ8/+JBrf+Em1RyXkv63yPI+PucLg5rGHMs6d5f8CSHGgAowPtN9mWFS+DbwbeDbAHwbAMyVUra9vvGccNoAQojt/9O3ymzCt4FvA/BtAL4NfhrnhDSrj4+Pj8//Dd9p+/j4+JxHnEtO+5sz3YFzAN8Gvg3AtwH4NvhfOWdi2j4+Pj4+P5tzaaTt4+Pj4/MzmHGnLYTYKIQ4LIQ4KoT45Ez3581CCPFtIURGCLF/WltSCLFFCHHE+9nitQshxP2eTfYKIS6ZuZ6/cQgh+oQQzwohDgohDggh/shrnzV2EEKEhRDbhBB7PBvc7bXPE0K84l3rI0KIoNce8o6Peq/3z2T/30iEEKoQYpcQ4sfe8ayzwS/CjDptIYQKfB3YBCwFbhdCLJ3JPr2JfAfY+Lq2TwJPSykXAU97x+DaY5G3fQB44C3q45uNBXxUSrkUWAPc5b3fs8kOBrBBSrkSWAVsFEKsAb4M3CulXAjkgDu98+8Ecl77vd55vyr8ETAw7Xg22uDnZ7rGxlu9AVcAT0w7/hTwqZns05t8vf3A/mnHh4Eub78LOOztfwO4/X8671dpA34IXD9b7QBEgZ3A5biJJJrXPnVfAE8AV3j7mneemOm+vwHX3ov7Bb0B+DFuwvesssEvus10eKQHGJx2POS1zRY6pJQj3n4a6PD2f+Xt4j3iXgy8wiyzgxcW2A1kgC3AMSAvpbS8U6Zf55QNvNcLQOtb2+M3hfuAT3BWGrOV2WeDX4iZdto+HtIdRsyKpTxCiBjwL8AfSymL01+bDXaQUtpSylW4o823AUtmuEtvKUKIG4GMlHLHTPflfGSmnfYZoG/aca/XNlsYFUJ0AXg/M177r6xdhBABXIf9sJTyX73mWWcHACllHngWNxTQLISYVN2cfp1TNvBebwKyb3FX32jWAb8uhDgJfA83RPJVZpcNfmFm2mm/CizyZo2DwG3Aj2a4T28lPwLu8PbvwI3xTrb/trd6Yg1QmBY+OG8Rrrbq3wMDUsp7pr00a+wghGgTQjR7+xHcmP4ArvO+xTvt9TaYtM0twDPe08h5i5TyU1LKXillP+49/4yUcjOzyAa/FDMdVAfeCbyGG9f79Ez35028zn8GRoAGbrzuTty43NPAEeApIOmdK3BX1RwD9gGXzXT/3yAbXIkb+tgL7Pa2d84mOwArgF2eDfYDf+61zwe2AUeBHwAhrz3sHR/1Xp8/09fwBtvjGuDHs9kGP+/mZ0T6+Pj4nEfMdHjEx8fHx+fnwHfaPj4+PucRvtP28fHxOY/wnbaPj4/PeYTvtH18fHzOI3yn7ePj43Me4TttHx8fn/MI32n7+Pj4nEf8f2GwExESX/HCAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "{'boxes': [337.73, 0.61, 499.0, 95.78], 'image_path': '/home/rajath/work/iisc/data/coco/images/train2017/000000412151.jpg'}\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAW0AAAD8CAYAAAC8TPVwAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nOy8d5ReZb33/bl2u3ufXtImySQhnRB66KFYQAWsWEABFRGxe2woomJBAfUg6sFCFUVFekISwCRAElImk2QmM5Pp9e59t+v54w7n8Zz3Oa7nXev4vrrOfNaaNbP3XGu3e/++9+/6lUtIKZlllllmmeWfA+X/7wuYZZZZZpnl/55Z0Z5llllm+SdiVrRnmWWWWf6JmBXtWWaZZZZ/ImZFe5ZZZpnln4hZ0Z5llllm+Sfi7ybaQoiLhBBHhBBHhRCf+3udZ5ZZZpnlfxLi71GnLYRQgR7gAmAEeBV4p5Sy+7/9ZLPMMsss/4P4e3na64GjUsp+KaUJPARc+nc61yyzzDLL/xi0v9NxW4Hhv9oeAU7+rwZ7vF4ZD0XQbBNPNoMmQWgatqKg6hLLo4Nlk8+b+L0eYovaUQUMHT5KRPegoqLrOhXTRJg2RdtC8XrwhsMUpzIoSBxcHAGmAMeVeKNRpCJwFRCAIkAIgSJUpJRomgJIhJBIBNIVtYFIkBKhCKSUuK6LpukIoSClgytdFFVFERqqouC6DlI6WKaLEAqmZaIoAsu0kYDr2IDEcVyEoqAqKq7rUiqXcV2JYRgEAn4UVcN1HHRNx7QqlMpFmhqbsG0bFxfFdREo2FKgaSrZXIZCvkQwECQcDmLZJkiBz6cBEq9XUCpWGB3NEvAb2JZDrC6CqqiI489AAqZlI0Rtn+uamFUL27axrSrz5rfg2CVyuSJICAUDjI5m0A0dw+NDUQSabiCQmJaLRFIyC+iaSsQfwNA1pC0ZGp2gtamZdHIG13URCEDgSBtV1zCljaLpWJaNR/di2RZm1ax9XqqGggLSJZZIMJ2eRgW8mk5bcwvpVBLpSmzLRtN1dJ/BVHKGaCJOMp3DMHyYhRJSugR0A91nIDUNFUk2m0XXaiZiuzbCqyNMF9txCfl8uFaZxsYgxXIFGx0VFY/PTz6fQlMcYrEgpllA0yRIF8f2Uy45CKFQNU0UQ8OVClJqqJqndp22hVBUQKIIgeu62JZFJBJF0zRcoaGpGpoqKBQLBPxeJibGaG1rxXZcHMcBXJAKiqqDkCAcHMdF1zxkswXy2Sytbe2Mj09hmRUSiRjNTU1MzxQZGuxFKCoBn5emtrkcPdKDwGLOogXY1QrpZBpd12hvm4PHY7B79yES0Qhz5jXVjFlUUBQDEEgJCI5/nn89o1dAUrMVRaVStjnY3QUoLOxYQCDgRdVq9iglCPHXalE7lkQFHMTxv13bQdVUQLBn9xEMb4CGliCaDpWygyIUpLSwHQsJeHQNxaygSRfbLBEN+TErVRwMhOGlqnvwB4LkSwUkMDo8QcDrR3FcfF6d9vY2UBRc6R6XhZom/EfkX13z/3NbIhDSBaGwb/dBNNUDem2MbUtsuzAjpaz/z3r59wqPXA5cJKX84PHtq4CTpZQ3/NWYa4FrAfxB48TL33Mm7eg073kFVXrpPPuDzHgbWHfuEvzRpRiNQUq+CvWBAKP3/Jpnv/5tor4iebVCb87FH/RwxtJFpLpHeWVkhNOuuJjG972N7c/vQjk6yMhzL7PkpJU88ZcdDJpVNrz17RDyMpAZJR6vIxCKEI2F8RoK4XCIpoYmolEvSIV0bhpH5hgaGsKxFVzbx9HeQSbGUxTLJcwyZDIpAlEbR5iEIxF2bDkCUnLaaStYdkIH8cQ8DF8FRehIV0U1kuiGxC13oAibspnHdVQss8zY+BSP/f7P+AIernrvO8nmi8xb0ExjVCcchJ///Hcc7sngC0yRTSosWd3MOy59Cyp1vLJngGR6kob2KLteOcj48BQ3fOxDzF1YM4T+/leolAf5128e5Oprl9K5bD733fMy0USQppYO/vz4s5x/4RuRisqCRQsZHh3jUM8oDfWtjIzuo1K0eeNFF7JkaQctDRbxOpN/++Uf+Pndr7Lxkgibnsxio/HdH9zKwkVzOdD9Mp2LVzK/ZQGG7QFHR63z84eXnmN4aohYYz23Xv85cMFwwZQQTbRQTGex3SJChfNWnUK+WMaVJietW8bclgRh1U9dNMZg934MXHR7nHRW8rXNvajVEkUqoMBHrrmOoyN9LDtrHU89/RyHtx1icWs7a9av5eDuvdS1NXFkag+r1naycHULO/+0n8VN8yh7NNTGBh792YPUGT7mLl+MdaCf7mIZ24Yffv8krnvvQu696z7C8+fy+6d1nAmH9111GSPj3QS9HRQLJuecfwXNjQ30925ifv0FHDzwLHmnD3TJnoOHKFYEe/aOs/XFXhQJDfEIY6ksCuL4lxJIKdm67UUMwwuql7lz5/PZz9zA+pNW87Nf3MVnP3czmt+L4Q3g8fsolmcIeBqZSeYolHN4/BCJhsikyniDcd561Q3oI6P/7XY/y38fcu5clMHB3VLKdf/5f38vT3sUaP+r7bbj+/73RUn5U+CnANGER/ptF4+qIGyVFZ0rOPUTV6OMD1JJjjHwh01MZkq8fGAn+XSOajpFpTBFa9lPwNSwpUV/0UKZ6sJbKrIGg/FHX+CB3z/FG9/9HgpIRqolYoqN1pCgQSr4vR6kqtHW3IbPH8RGYXomjaFaTE6NsG3bFpLTKZLJDKNjA7TPTVAqSFpa2hg8NszqNStJ1BvMCYdobWsmEmjEHzJAmATDcXY8fzNI+MQnPkY6M8XoeAbXifDnpx5laGiAu+74BYVcka6JZxGuB7+nCaE4FHIp0uk0paKJ4RFUy2XOPnMDVnkYqzTIn7Y9z+Yto/gEfPD6c/jFT7ZRnPJytOcohUIPb730wySaYgyMHWJmKotPDfD888/z/gUb6drXz/DIAXxelZu+fAJnnXoqn//8r3nDWy6k98gYP7tvM1e/71LeduVVWI6NVMEbPELV9pGIN6BpOTKpPMcGB7GsKqkWnU/e/AmqVh3z56xianyKizeuZO6CTuINEaYm04RjfiJBlYbmCOVUmbit0tN1gJMCAbyuimGDaoFjwMo3r6Up0UKj0cBY/xDW9ARBn4eZkREWzVvCuSefwDlnreRbP/g+B3qOccst3+H3z05xxukbGBwycec5LFzqQxYFq+IdeLBYnZ7krJZmAsMZLl17FnPPuZRDr3aheYPcl3RINCd4qbfEs727MSLzWLVwEcmpNNOjM4zsOoSiw+LlS5gzp42dL76GjQDFpetV2B6vp6XuvUymLP5w/69BCJ584LOUkpP4555IplBmdMZlJHWQPz/5Y264psREqZ+hoRFst0oqnSWVLtIcb2J+8wyDY2kmM1lQNVTXRjM8xGIx1q1bx2t7DpDPF7j2+ms5erSbttYGJqdGufzKt7B8xQoO9BxBcR3sShkXhVKlSL5YRNN1NEWQSedrnmOxiD4yypRToFGPAQbCdfnYv3yN+3/xG17Z9SIhPcSpGzYyPLKDLTt7WdZZRznr8OnPf4uO5tPQvBa/+e0P8Ck++o5sJRqJMzo6AtgIdBzXxKnmECqYjo1mqGiKhpQurrRQpYFtOqAUEarAqvgRqg+PR8c2Swgtj23qeDweHCSKoiEkSOEiJCB0LDGK4jaiujpoOUqlNH7fQkxTIpUUQvGhq34+/ulvccm71zLQt5tsStDW1sbo8Agt0QrpLU/QHvbQ2R5k9Ogoa1afwyXX38WGd72PpksuZmB8kAWLmwiGfVQzGiMDY0wNT7PhtHUM9fYwNDDI1k0v0HfoNcDCskvomoorXaA2yYHajKEWiXZf1z6kgKqr4lVdFCvE8vY3YQckPf1PcN0XbuUnt33xvxTXv5enrVFLRJ5HTaxfBd4lpTz4fxpfHw/KyzecRTwY5prL3ks+n4e4FxnyEmlqJ9jZRFwNoua6SabS9Kk2pXyB6rE+Hr/zJyQ39QGQd8En4Ay9FX9Uo7+5nr31QaaP9TA/GGPbawcpo9AQSdA0vwVVV9GDIULhMLFEHYlEhGAEggGDYDjEDdd/BddR2LT5D4yPj5OcThGNRrnrrjvYu+8wt9x6EytXdyCUAkcPJymXJIqiEIvXc901nwHgK1/7LKqqUnbyqEoFJ9+KXdbpGdrGli2bWdJxEmtPa2TtylUU0haaR+P8jecDKgeP7GVmZoLduw4QqesnHJ7Bqzh4nXb+9e7d3PWTz7Dtpd3cecdm1p+/lNWrz+aicy8nlvBz8MhOPnLdJ7j+us/Qe7SbK952PsPDI5RLWVLTKdLZEcqmyuRogc7OVcQSfg4f3s1zm3excPEKookoHYvn4vP5OLyvn0SinlR+kKmpGTacfgYPPfg70skcigI333QNhq7S0FDHE09sY3x6hO4DQ0gksXoFNJ0bPvRxTttwMh/92o2ccf5Gtm17gXnCTzhZYMlUmTmuQXp8lEVLVzGQyjM0NU7bmSspKBavJifwRBsZw8OXbr2Vt178JloXrOXuH97DzR++mk99/FrqG4t07exi8qk+9h09yImLFlEwS8QXz2F4ZIB1Z5+Gr7GZglFPrCGOJ+TnYNdekoN9hI7to61QYnlmgtGC5CBVVDvEvrKNsnQe+wsZpg71gV/DKKnUNdVx3ilxTl8S5vs/+guTlsrdv36U7Zsewx54mEvfvoA7fzrCs3/J40qHnr4hOhbk2Lf9EYoFjScff5ZEPMKTTz7PwoWL2L87yZKFC7j5M58jGI0RaWjk4N497Oo6xNDQEONTaa655gaGh0c465yT+Pbt3+Dt73grP/jBd/nKbV9lfHySqnSRQiUYDlEsFlFQMZQA2Uwex62i6AqqLkDx8O4L38ETu5/FKYVob2nlyje/k2SpyHTvLjKqym9/8iRfvu2HTI/1EA9bXPH2SzjlDacipI/66LmYpTxbn36GQqlMKCg48MpBbJkim8wRDAS49bYPc9bGC3GsMlI6CN3FlRIhFIRiI5wA0pSoRhEXG0X1k89UCYXDICSlXBHNIzF0L6jH026uqOmelCBcoADSD24YaWWoVLMoehDXBaEE8fgFihHk4V89xaFjBzk4MM6Gs0/CLmdoi1qEAjM054/S/ZetdC5cgOLOJZ016LZbufqrX+K23z5EIhEhnR8nmZ3ipBUnEvBHSITbMHQPr2zZwYeueCNXvfMG2pr83HnH7ThuCUUB6dqv6+D/SRtxXff4LSloQoeKzWVvup0/Pv81LMfh6FSKJY31CPj/ztOWUtpCiBuAZwAV+MV/JdgAJoIBWUALNiM72/GpZbLZAYJ1Gq/0PE3/9iGmR0dZ1NGExxviqzfexgevfifrYx08s7WPD5xxMm6hyCEh6ZzTziub9tNQFyHSMY+nH3sUXQPPwhgtC5dT19zKoUOHmLtkES1zWjnaO4Cu6+SySarVNJ60QyQSYMmSZccfrsb+A69SrEzi8xgkM9N87vOfZvOmrXzp8z8gHgny/g+8ndNOP4VMdpyZ5BTFfImly+Zx5PAxyhWb+fPb6erZQzwUw/AmiSUkphLHNB16+/bz2oESzzRvZ2nnQlavO4FMOs3IyBDlaoF0MsmijvkUbC++qsLO13bwuz/uIWAILn/H7eSK0NJUx0c+cjOKG2Hr1q2gVcgXRvB7dSKhMPF4gn0HevjJDx8gHLFZtGgxdY1RPv2xmzEiQX55zx/IpYo88cxraKpCqWKSGx5n+aolxKMxUjMThIJektNTlMtlNm/eTDqVw/CBXVX47WN/ZPmyVZSre5memeJQ9xBSgKoapGZMVFFF1/xIvDgZjTZPK2LcoOA1GJ+xSJy2hv70DBd+9L1s3bmLCb/K+2/5JN/94feYM6eNgeEy83wBwpE2gtoC6mJLKc5IckkbRQRwpQfdK8krZfKr5lMxsqy65p1cduVl1NfV8cgD95PJpFm1ZjXrV67iK7d/l0XrVqEGDLyhGEMHp9CnC8wlC5bGXI8guLCRccPG8nmZerkPhIK/YON6wLSKaP4S85d2EG8M03skz3suvYx0sY+D/fczMzBFMl+uGaa0SWcmSSUHmZnoJV63iHy+SHt7K9WyiWO5HBuY4D3vfgfPPf044+PDRFrnUiyWsRSNSCzMwqXLKFWzNM9p5Ikn/8jaE1ewc+dLrF67mkw+g+rxYCBQFA3LdPB5Q1hVE8NQCAQ0yqVacNl1BIZXB8Ay82QyJoVSlcvecxWpbBJbVZBOkeuuvxjvvASP/uxOBrt62LxpOyevv4Qqgh/99hZS08cY7O4nGPXi03Vy01VamhspWWk8bonbbv0+Z228GFXRQNNwZeV4fF7iuqAhEELDto7niWSRYFgHKXHtMl6vF1wT13EwS1Vs2z6eY3FAagjFRPd4cN0iPkXHcbwYmkIqO0V9czNSatgVlVu//APeduV5uMpZfOyme2htm0PvwT5cs8DmnU9xw5vOZP7KZYyOTTG/rZGJ0UmuvP4DPLHtBSanx4gnAhRyecLhMONTYxhGikKuTChUT1dXP5f8/EPMbU/woWveD7goCjiuhcJ/EuvaNOE/7hIC26oiNBuIcGzyEJ1LTiVXlchS/m/q698rPIKU8kngyf+bsa4QeAyTbO4IVXGEI/ueYV1LN/5clqVC4bXnh1m/Psryhnb6JjKcd+EyVp+6mplsmQ3vOZ+HHnyJpctXUTV8/GzXPuqVIl63nmD/CO9ds4wDxSrbuw+y4IQzyE6WOeWCC9j0wqM01TfRte8oZ2w4la997SZWr1xKT2838WiUV3bt4oaPXcWWTTuYmJhC+iRHj/XQ2tSMqh5m2fIYn/7U2znUO8kvf/Vznt/6OHv3T+HaGj+68ytcf9370D0e8nlJQ91c1vlijMw8x7HBbezfNMLZZ4b5yc8WsvelpezZ00PL3CZ6e4/w6IMDrFl7IkLRufW273LLLbfwlx3b6e8ZR6iCgH8Rh/b9K66AnqPdzKSy3Hr7d7nsTdcjcEBCx/wWbvr4O5nXXse3bruNQrnExz/xAYIxmJwpMrN7D44Nj/7+eRbOa2VOUwPRWIi3vvV0Bo8m6e4dRCqSzHSSOY11yEoar9ZCIVtB1VXiiSjNzQWyWQtHsbj66hupa9Twe6LEEiGqboEbPvwFpsfShHwx7GqB+niAuG1hJE3iXpNkJUlFz2KEPfQMDPP+qz7IB2/8KJHHH+WxRx5hUHORdQlGFYe+bJqTFq0g4jVoSSWJe1yaEo3U6UEMjx89ECRTcnEIMpA8StFK8+tHfsm1N3yEbG6Cn9/7Y557YRdIyZUfuBJF82EfDvDi7r1olk3Mo6DF/JhTKQKql2MGPDV+hNHFLRx6qZuEq6Dh8tk1p7N7bQIz5/D4Y89ySmcco5qjKd7IhZdcTdfAn7n6jDDCG+WcC8KMTw/jCov6mI5igjmdI97USj6VZ3xoCLtskJ7OU3BUnt26iTXr12H6DPAptLXNp6GhHaGqzF+4DMc2mT+nnUd/ey8vvPgct3z9+7R3tDI0OkIg6MORAl13EbZCtegglBwlN0fYoyDwYCsGqhIkWy0CUCiatLQ2ITU/V77vraxprueFfa9x7qo1IKElEmDXq/t40yXncd3VN1E0NR584C5S0zvpXLiKkIjQ39fLyHiJgM8PqkZz83ySqWOY9gwIF8e1UWwXqdYS/SgCXA0FFSkEmgghsRFSIm0JQiKkHyllLfkNGIaBEAKPx1crCDALKGocvAGkLCKqJqrrQahhhJIC189Xvng3D/z2j7y885fYziiCVr5xx0d4z7Xv4P3vOJGA3cuFG5dyaGyQlSuW0TtlMYXG5h1dLL2sl6I5zuqlDfhEhVJdAllywfVjWhamCZnxHJse/zPXXfMRdDPF4s45FEpJAn5fLYnP8SQqDkiJgooraklH13WPJ1gFqqqjKCA0m4d/8306l7exZf9O3rz2bP6WbP/dRPv/Fa6Dksnhi8YplhWKTpCbbt2FlfdApMCXPvANMtlh3vL+eymbFooKl11cIjeWZWZ0hO997FrWLVjJy+OD/PTxPFd96nJ0DOZ5NTZ+9NNo9Sr+RJRyIU+xlGLTc938+CdfYN78NlQtzB9+8yve/pZ3sfHNp3LBGWcR8NUTCoZZ2rmEC84/h1d3HaFq1XHpG86lkMvQc3gLdfUe7rj9d0jN5Suf30jFqVLM6Zy34QweffBhlq3o5MST17P4xNVoWpjtu7axZ88h1qwJcMopUeoaDX58+yCXXn4qiZEWHvntFqSEJ5/5NYe7ehkYGGDB/E4qZYftf3mVPbuP/nvyWREBkqkMA30DeLxBpsYrxOIBzGoFqyIoFApkCzkKJRMXhXg8SiY7QyjqIZ2XrFy5nJe3dxEMejjnvJNYOLeNj3z446xYewpDg0k6ly+lrrGOSjmPaRWQVoVqIY1ZLFCxqyRiQTLpNK4TIBqNcs45Z/Havs2kitPsP7iLRCKGoXgQCDRFUhUKYT8UCv3Mb0ijp8dYHzeZSNtEYyo9h3r5wY/uZMvOPTz3wjNUS2kGJ6bZ/tJO/FEf6A6Kluaeh7bz1OZ+8mUv9W0h9IiGbacRbgrDncQtD5MItDJZGubFrldBhZ/d/3s2vbQHI1aPbblYgRj1RgjHErREG7FKBYygHylLSEVFjcXYaY/RdO4ZvPj8i/gUjbDucrbRwEB2ECvjoe9QHk21sItp6ho9dE+UePa5B1ADVQrZi7j3Zy8wXJQYvii5dBldeJEyTTozRD4/SKGQp1wO4tTMGhNJvmrT0NbE+g2nI/Hy+8f+hEk3p512Gic3N1MplsjkSkyMJ7FsyYZzzuBQz0Gq1SrRaBQhJEgwq1USkTpymSmqbhI8frwigSNsTE3HMGvhBrNicWy4H0fzc8KC1Rw+lsGLC66DCZx3WieTYwfp3tfB9Te9k2uuvY6L3nw+qUeG2LFlCGHF0PRmWuZWKOSTIEJYbpHJoRBfvfU9ANi2iebRajNWRUHBQAoJOAjFBhSEUEG6COECLggHkAhHASlQFBet5sIihI3raKBq2E4FRVGOe+8STVjEEk040uUb37qFseEZYtEqpjuMQPLk1ldpbG/hxVe2c/5Sm6Fjk7TPnct4eoKVp6znu994kKaGBez6y58ZcwfwLl5Px+JTGR9KE6r3kytmkY4kHgzT1zXIuhUr+PH3v82xvh2kpiepr48gqaAIF6SnZqoutZmE69buVVEQQh4XbgVd+rGdNKZtsXhZGw88/AyLWz2YwvyPxTb/iX8I0ZaKChE/lm4QbVhJo+ly0UX7OWHFQs678B7WvWWG9rp6OpfaNLY38dwLFlawjuZFbTT27CMzz8cBkcRrpohXSzz18APc+IUv0/XAfbSGTWa8dVTGcjQES5x9zrm8+11vZSr7DM8/+SJf/vLTNDQG+NQXr+DX9z5EwmfQ0tbBSevWoagZ7v/1szz88B6+8+N/o21uB44zzpa/7CYYa+fzt6wjPZ5jYmKSQKSFI0fH6Tn6e376w69jygLFYpG9Bw5x0vrTWXvyapZ0ziPZO4kRVJnoPYJPfZmn/7ifZcuX8t1v38Kevbu49OKrsCTcdNOH6TrYQ+e+bhbM72RiJE8uZ1IoltiyeSfNjQmWLelgw1ln0L6gndtu/R7hSAM3XHs93d27MMsZhCtA2CRTBerrmgmF43i8goPdE5xy2tlcfMFGbvnql9Bw+OEdP+NLt97E9+94gEIhx/BIPyuXd9B3xMGjSQzVpFoo4SouM1NjSFvi8WlUzTzHBnuJJcL0Hhlh2dLFNDW2Usj/CIHEsjOYDjS1jfGnP2+lbl4duidNUIdiOgVKmZwjmOrv573v/TDPb3qefFogCxoqCl5FJ1E/F6UY48QFp2Ebc5k88DShWBNVx0FT4ggnjl1xkTJKqZzE8AhiUT/ZbI7OOfW8+12X8dK2lxgamqLD58fKlEmE4uQ9QVJFE7Oq41MjFDwZ/ug1qSxYzCOv7sTFR3OlzHvr2jlanmGrU6Fn6zSancDKKmRzSdoXVqkcrBLU5lMsDtCyYjVvv+AEug9N89gTT9LTO8raZZ3s3/NLNKOKI0voAoq5ApWqRalYQeLSPz7Ill07WGU73PzRrxCpW0i64nDySevp3reHpYs6+MynbqYobT71lX9h38FuMpk0Le1zmE5OETS8hEIBhCuxrWlawjZGIACBMjMz02haE4VCmUA4DIBXD1KspFi97ESK1Sw7d+5l0bw4KCqYJqpu0Ny6kO27/0TDnBa++Mk/0ZyYy+Vvu4JzPgKq7sOydAoFDU31ML+9mZZWg1NOb8WVBSqVCh6fgW2bqLpa8zarEseWSK2IUExcR0cVwVrkQEiEUguDgABHQ7puTcelAkIgLQWExFUqWE4JzQ2iG1FUX46yOYOXdk5Z/0Yce4a8ncN2Q2j6Qj552xdZcvrprFr/BqpTvXjVo3QsaYTsFK+8fIR3fug8VpywnAvXbSCdOczGDUvprTSy5ek/c2CsgreugdPO2YCoWPzqrn8lrETZ9ucn2LHjKcxSgVBYwZVFFKHhyuOJSPe4SEsXF6UWOnFsFEWpPWNUyqrAa7v4vF5mZrIsP6GZzX94kB9/9ovwza//l3r5DyHamuNSLkeoj9ahizQ+V+GxLd08vG0PFVXBM2zSHEnQtV8wnpzB8M3Fa8SY5/NxWNXxlEqMz+SwHdBaE/QkxylVM6S8jbjeAJnREiJkc8U7LmBuu5d0+mUWtc9h+NAhPvfhhTzz9GHE9Ayr2k9i97YjNFxQTyhqUOquoCouQi1SLudx1SqHDo9ywfk3kZ7MEzJyKGaeRFszfiPBHx+9jN6jY3z9jttZu24dW7a9yL/8yzdpaGjg7ju/wVPPPM+8RXOwbJWVKxaT0lSKM3n2/PZxiuWHaJ9TT+eqeXTtO8bOl18mm01TXx9nanqYk89dzjnnXoKi+uja38UJCztIDR/BqozR3T3Ows55hAIR9nftQFdVnn78JYRQUIWJQMFn+FjcMY89u3poqG9heirLSy+/wFe+/kkWNLXgMfz88Mc/JRIJMNTVg8dn0NMzwtEjA+BKhncdIlW2caQk3hyiShEsF93ro1hS+OV9D3FgXx9t7Qk++akbQS3Q8DAAACAASURBVFFxpYYjNRQqXLDxblzFIhg0eOCxp4jEfAjhJzXtYugqZkXllu9/DgM/0uNnx+5XOeOiDby0bSuJlgX0jIxSUFvwalHcQIz6hgSpqQK6alO2j1GqzuDacYReQvUHMAJREj4/73vXNSRzeRTpIjxeAvE5vNC7lVB7K8JxqFSKTFanSQid9rJDoSLYv3sQXZd8MtjEWk+EH6YP8Wpc4p/UqFaqxJjgijaJtnuKllWNtPqmUeo0DnV7aG5uxoj68Kxq4NjgCK/s3c6p61cwNeWi+0rkyhMoaFgVgd8DxXyeuphOJVNm9FiB5PjLhPQHaWpfRCCW4P7f/J4PvvsyLr9sIwe7D3DPvd8hVh9gbKxEQI9RKJZxdYmSEEwXTYyKTmvA4v7DD3JGi82bW1vo2jLD/f+2k3f95BcMpUsA5LMpNpz1FuobYjzzxHb6BodYvCCEi8QwFI4MTTM+NIglC9z942e46fq3IhUQFLBtFxWBECpVu4wiAihqteYFi1pds9cLuA66ruM4Dq5jo2jieD+DF0UxcGwTKWwkLkhQ0JCyVl2Bx0E4ArPioHu9OA7YwkFVBapqQKlKxUkhvSUMGvEZYa5+3w3sePlxHJknoPqoKIJ7HnyQNSeeRiafpRC2UBeFOTiwmrVNNr7Yi7QtgC9/+16uvPJTbN/9NKOL+ziTFMubV+K79ExWyjj9UymafHW8vPMFlrYs4ttf/yauTFKtFvB4FKQMHk86OjiuiVBUBCpCuijHPebXk49CCGxboqoC260wmfaQP9jP4nNX877LruZ3j91HEZdr/oZe/kMsGOUqkrRToKLaWG4B16mQnhnntBVNNIYMUuFxBp1xou2wYFk7mkdnwQnzmNJt3DlNbN++hznNbSxavJozTl7L7l193HfXT2mt97HxzecQTAhEWcF1FJqa5rFk6Spi8QZa5rTzrZ8eYe8AfO47z3D/s7v41Gdv5G3veT/lqknZtMAB6bhMjI0SCSfYtnUH0lXo6x+ktX0hH7r+GhpCGlMjx/jQRz/Ppz73dVwcHv/js2STZWZmpujt7aVsm/hCLpFgFM21eOS+P9D1Si/56jSxhjhvu2IjJ5xwApl0GSkhGAyj6zp+vx9N0/AqPrq7DzM1PUPfsUFe3bsHbzCBYkSwZRjDE0EIH4n6egyvh/3dvVRNBdWoNVgYPi9z5raiKbXsdaGcZXpmnPntc6gU8pjVAitWdRAOBmlvb2fVqjVkcnny5QpTyQrTMxaOI45P2zQUai+gRxd4dImhS0qFNOGQH69Ho5CrxU4d6aKq4ABNTfUUciYenyCXKZJJlchlbHwBB6E4lNIO+VQeXdhgFamL1yMclWouS9inU8nmKRdy+KWOlDbVahm/L4bfiKC4EVxZRGLiuBUst0DVymDoLkJx0A1wrAodC9uxpIslXRwp0TwaGBrSq+JD0DwzQ9GuUilbBFyd7SLJzphLXVMTadOmA5XTGkNEHYlWsTG8HlzDpVqtAjrSrmLm0uzft5eZmTHS6SSu65LOlKiUbFzLxpUS25FYLkihYtsWlTI0JOJUqxXCoQBzO1rJ5GcIRbx4PZL+gcPoBgSXzueYWyCnWmQrWfK5DJVigVBVI541WWypdFRVTn98Em0mxnggzp6XdhKvFyzSx4g0HAVq5w0EwhSyVRZ2tIBhIXUd03WwHY0HH3qBeP0qunqneOT+h0GxqVZKx5vJVFy1hKuUMTw6ip5DCB1FtXGlA1Kplf3h4koHVVURilLznIWLFE4tsSgltRhC7ef1bSEkODW1UxSlJvR27Ti4Ntg2uqKjCB1NDVGs5PjYDTfyi1/debw5q0TVttjyyn4OTveTIYvPo2MXQJoqIhqg36hSqhZZ2bAQbyZF8blNeO7bTMefTI695HL3757lV794hP0He9DKBqMDg/QdOsTel1/l5JPWIF0br8eL6zjYloXrukgEmqqjoKIKBUWqIJXjX0gC17RwTQvFlbi2g+JqPPXwoxgBD8vmdHDy8tWUhcLCufP/pl7+Q3jahguNuSrLY0GCFYu2UJxVq+fyo3sPUc6rTBxLc8aKEHrOZYkvyjBjaJM5RNWl4jpEGpsZzs2wLJGgc/48cig4kShmIEFmzwvYpQrSdrDMEpNTOVKZHPnMDLqSYODwZiamJ3nkiT9xaGcXo6USgfQMsaYW5rcvYKR3AlA41nuAzU820r13D/tf3ollKvzrj36BqmkEAjqtzU189jMfZ8GieVx73YcRCmApzExNEw6Hufbaa9m6aTvlfJZ4vJ72BTku3nghS5cuZWp6lNGRIXoP7yGdTiIAs+pg6H6khGrFQcXGi0pQ9+MzwlRNBUtKKqZK2nSoOhKPx6Vg2nh9EUq2JJxoIpk1kbLKnj1dCMVG93gpFIpYVpIFc5bz0zvvZNWSefT0D9G+ZCntrXPYsvVV0ukMXk+AfL6A169TKVmoQsORJppee0kVrYRf91BNj/Led19CW0src+fX4wuU8PqgXLKxAG9AxypYFKo5OH5vstYqhxAuk5MVAPx+FdNy0YSGhYeLzruQsbExJvqmidXXUeoaIB5NUKwkaYgHEHaVUNCDYRik01WqtgdV8eI1Ijj2OAFPHAVJJATFYhlch6WLOxnvHyZwxlkM5fOYpovXFyQ/lSaUCPIGy2Cxp4Lb2sQTx4ZIhwIkiga51wapl3Bj81o0OUS5rBFUvHiD9TQ1DrF3WBJK6KQq0yxpncspa5aCCwf3diEUhdde7WZlYwPjpBG6QSqXxxWQK1cJ+v3MuFVUVUdVS5xx1jpc1SWdHGTR/Lk89PC9fOFLN9LS3oYcThErhdD0PKrXz4xUqJQMDg6kaI2EyJf6Gbr9B7z5e18g/7vH2DMyxvvu+SZGMMLe0WeY662luE5Zv47psSksy2K6YBFUHXr7R1nWOY8DR0a59bNXUjAdLr/6s2zd9CATM2ka62JUS5MYPgMpvSBqFXjgwZFVNFXDdmwUxTregShrv3ERmoJjSVzbRtO0mnetuCDsWqevYeA6Vq0sUAiwah3AmqKBK1EVEHhAMZF2Fc2bIJ+yCIT93P7lb/LNb99G2SyiGVUUGcNXlewt7Kfz7DOZ6B+kwavTEm4kV63gBhyMA+OsO+tSRjWHjW9rp1mCXmhnTaiDA997lvm/+QHunIVMZAr4qhE+d/P1fOHTn6D1jUEuvmgjxVIOTbHQdR1DU3Esk2qlWivpE6C6Sq1MEUADXZEIRK1BVQikoeIOZVGCcOuPb2PDCWu48bYb2fvgcyw/70yo9/6XevkPIdoWkkmrTMVvkBeS/ulxNpy/kVM25vnAlQ/R2NxEfeMc3AjkXS/LVrTQ2FpH79gAuuonXRpj+7Zh9j3/EkUVQrgEdZe9u3ZSyJoIWctETydTnBQ9EVWVhMNhErEYX/rKN9m+8y9UrAqJQJw5jc1kp2fY/OIzJKdnjhfKu7Uyvs4lFAoljvX1I/BSKlbx+Fy+9MXPM3/eHDK5NNlslkgkRLFggqvS1dXF5PgUjW1BvF4v+w920dY6nwULFmDbNkePHsVxKyQSiVorfsVGShgcHCSXyzE9PU2xWCQWjeLxhSibFpFwkFxqEl2dg2bopLPTWJYFehDTcjAUiRC1FnQpat5KKpXi5FNOxDBexTIlsWiYeDBIf3KEh57YSS6b45fXXsNzW14mEgmg6TrlSi0hYvi8VMpWrWVXCCzLQhW1l9J2s9Q3+rnv/rt4+olJVp/YiEuRYgE0xYc36GBWJZG6ID6Pl3yyiqF7qFar6LqOZVl4vQZen0GxWMCxQLoVdN0gk8kQCoUYl1NUzSInLF+M359g4dI3YGguUtam35bjYDsOhu5FVXR03VMzGKlQKucRQuDz+bCsAqqq1roMbQe/34+jCWZsB93nIVMuMJabIRKLMV22ybfUk55IYRXKVBS4Qm/EU8qSLaQwcSmPZ0gUCgR8XqxqBYFJX+8R5jXHCPgNAh6VyclxQMF2VMKhBDP5Wvt9qVSqLY2gqGiGTrlUYnx8Eq/Pi9fr0jPYj66qlMtFRkfG8fpsFi1ZShkdU9ikTRtp5/HqQaK6jqa61JVmmNj/F7L9Q9ipbgaK/Wy/vRenrsBhQ3DV286F6hgAS+Z0csc9v8IfTNCxqJNyGerrE4T9YR594Ec4KCg6nH3mmWheBVFxa+VsSm1yLoRACLdWBSFBFQrScdDF8RZ1UWswr/mfCq/71IpaWyJBUY+LuqLwv3tFal2gr/etvz7WrlRQdQ2hVihmHQJhL1IWEEqQn979a269/Qvc/JmPYgQtzFIQ6Tf40S/uZv5l6+gaGSUWjzLWN0S80cavqgSFjhyfZNcPu/i3fa/wk3ue40jv4ySNKqrIMTHPwhYKPa90sbBpMSNDR1g4r507v/8d9u/agW3V7qZaraJp2vEWdgXD5/33+xFSAUeAqoLiIl0XDaiaJp6gF+EIfnzvT7CokBmZ4qVNz+AFmua087Wv3cKX/4Ze/kOItqup2PEEgeY52BUVn+Nj7HCGupBCnQK/+802Jo4VOToGFkd4+8XnkhwZx8jk8UyOU8q5OJUSazpWsG3nNhbNq6PnwGusmbcaN18mKHyMiyzb/7KTil1lYGCQ5uZmhCvIporc9PGvcdqcdn72y3sJFk2O9ffy7a//klBDgI4F7SiKRveBg9TH69l43kZ+PnQffl+cK97+Tk45ZT0z08Mc7e9DCBfLrmJ4FHx+nVK+SndXF3v27GVhOcb01AQt7Q3k83kOHz6MWa5w4rq1OJZDLp8km08RCPgouSZDQyN4fRrlkkVDQzNVW8XCS75ocuKqpQz1WMTdHKVqmbrCODM+H6YEy3Wxj6/7kEzncaQAoZLN5zBti3K5SDgYQygWW156gWuvupyHfvUosRC894NfRBNVMDTCsQRr153Ck48/TqVqgVTQdQ+mVWT9+lPoO/Invnvr9/ne7d/k9m/fw74Dg4BgbGyCO771EJGoQT5XppzzIjSVbLKAFXBQFI6HEhQcRwIKTU0t5HIZVDx4/R5s16FSKbF/7wFCgSg+v4cF89pZsuQUurp6KJTHuO5D17F9ew9CqRl+2bRQlVrsM+AP49guwqviOIJyuVwzLmolZH29R3Edu+YlSRdvJEqlPE1/Lkt/ZyP9ZZv5a5fT/cgmfA0RvKkC53gNOjxlKtUszYl6Zuw0aRxM0yYSDrN6SSc7dm5lzfIopZljDA724kiNF3flcYGJ8SRyXiPjgyMkYnX0941i2V5MR8Ef8+PKLP/yxav51b/9nm2bXyEYjXD1u97Fjh07EBhsOPs8cuU8fZPTBP1+coUSiYYY+XQFTMmGtjnsfOpBAhP9BFYLgp02C+Kncstla/jFWx/j5DfO41s9z7Jo4TKuB77zrW9z8ZvfjSMEkjAjU8c4138md/3oN9xzx9c4+w0f4qvffITbPn8l+w5PUF93fH0eQ8d1nVr1ngSQ2MfX3JCve5FSor0u1q4EV+I4DoqmoSo6xXweTVPQVAOEVtNoKVGEBqImgq5UUDwehFVF93op5vMEgiE8fodSxcYfjrN1y2aaG5ZiOw4vbXmBjhXLaIx7ecNVX+CC6y5gaCaNR3MQWZtYayuT5SKB3BiNg1kuOK2RZBh+deoQO3/3M7K/fBZlpJfxNgELN6AkOlkclfz8y3dSzecY6d7FwEAPCItiKYtHV/AH/Ui1tt7J62ItAaGqteehAKrEEqDgIT2dIhAK0tc3wPbNL/DUH57AK6ukxlPc9L7rOOvSN/HBr38JQ/f9Tb38h4hpG0JDzZoYlsDw+3END/6IQff4ISxF58T1J/Geq67n9HNOImNn6Bs9huZT6BvopWAJOjo7ufSSC3jzG8/lM1//Nvlkku7+DG960xt4x8VvJO73gIRwKISmKPQc6eepxzfz9FOb+PBHb2DjeRfQu28/mx/fhM+r4fUaxBI6jlshl8vhujYzyUGampoIh8O10IBQGRkZIZPJEIlEsF0LoSp4vF78fj+2bWMYGoV8nuFjgwSCfrx+D8VCGbNqUyiUSCbT2K9PF6WD7VSxrNe9GQXbckmlMkxPJTGr9r93U5UKOXRVYpVncEopMlMjaFIipASp4PcHAQXLsTEMA9dxiERiRKNRKuUqmWyWtrY2IpEQttdmsuySt1QUrYojwecPEo7G2b37NRACwzBAuJhWbfqXzWZRFIWhkWHqmiLs3tcLmsDBIBj04w1CKBQACevWraOurg5/IAAcr346zuvJGV1XUVUV2/5f1L1ncJzXla777P3Fzo2cSDBnkRSpQOVIZdmyZMmyLHkcxnKQPY7jOOOc5PF1kD1yluSRrWRbVs6BCqQsSqRIipkEAZLIQAONzv2lvc+Ppj1zfxxXnR/3ls9X1QVUAdXV3WisXvtd7/ssRbVapV6vYtsmb775JgcOHKBSqeA4BoIqpqzz1rdeyJy5nZgypKUlQ6QaroNQBcTjcWq1GobRuM9SscKihUuIx+NIKbFNi5htU6vWqdfrlKsVyvUaXqQoA6OWxZL1F/HyljdxUzFK+RwXO82sj9I4yifh2IznJynUAzxt4dVDent6mc7lqVZCxoZLVMs15nb1MKujFQAvqjI5lcOSDvmJIrbh4nuQiDdTLnkY0gJMXDNGIhYjnUyQTiW4/NK3cN6Z53DyyacwPDRKLl+i3YiR9hROGYpDeTo7u3HjJgfy+7AyIZd+4i10Lp3Fn99+F82FMve+8BLvfeCzxLPtfP+0G7ng3HcB8JV/+wqxWJLC1BSoOulMBq0FxUIFFUWce/4FvPKXF0ErPvbxG+lq7QTtIKUJSLQWCC2QGJjKwIxk46YMLCzQAqVAH/sqhIGBgfIjXDfeOA1piV8PG8VaGRBqdD1E1UOEluTHJikXK1QKZaYmpxkbHmVmKkSFNvfcfTdXXbOey65dRf+uCp/54udpbUry7MtvcO3V7ybTOYtarYarbZK2ixmziDUlSRg25eF9BFuPMPrwRnb/+aMsbIPzvvBOVl98PA/sep22NaczMTZBR7KVV597irQd59EHHwShUMrDtARuItZgw/wPa17j9CFQUYRWCiUUkQ7RSuBHAU4yTsxxaUllaO9oZsGypWzbt4sj5Sneev372bB1N2XTZLLw98M1/xBFW2lFvDVF8+w2orSFypo0Hz+famszl3/+RtadvYi2dp9bvvxpnrztZ3zzE5+kVB1hd73CKyJg98wUfscsXt5xgF0TE1Q8TV4qzK4kR8anSDYlEEhGh4aZ09tDUyZFz+wmUkmXHZu3cLjvEM3HL+S2B36J3RnHkx7VWkBlOiI/Wmp0DFqSbkoTTyapFKo4lkmlMINrQak4heOYQIOy1tbWQeCF+L6PkJIdO7axdetW6hUPx3Fx3ThhoKhW65RKDW2zq7udTCZxrDA33gC+H9LR3k0ikUJHHob2sW2FNqFrzlx+ft9j/OC2x3lx3yhxx8UKAlToEwQeCE0qkSTu2ggUfQcOUpgp4cZitLa2M53PMzZa4Gc/+TNNzXHcmE3gm0RImls7OXx0sPHhoQQtzVnEX2mIEsbHx1EKduzYhmWlSTUl8HyNZQuEmUAaFiPDeSzLYe+uQ1TyeTKpOLZpHJv+C/7nAErpkJbWJiIVsHjJ/EYBDn127dhBPp9n3tzZLF8+n0jlGBzcTq08yCmnrGXjxmdIpCSmpYiiAIBUKoUhBMVimWq1xmc/81l+85vbmJrKY1su5XKZRCJJuVgkmUxhWQ6xVBpsi/kds+nYNc62Z57FlR6thTw3yRbOlC5xWWNJyacS1sk4NnbUjOMnqA2XqI/mGRw+wth4DsPI0rcnx45Nhzj4xhGEhldf247nxeltX8FIf4HO7Cx0TZJ2mwmqEYYSSAlSRTSlDRYtWkZLtolyuYw0NIbyqHtlIhlSSHqUMwFBupsZsuzbvZfOZkVx2yOU33iaDV/4Bt1LT+Cq713HI+99gKuOO5U9r25i4JHteG1rWDDnQgAs6XLbb28j1Zyltc1icrzK/n19PPzEo6w+7RLWrVvC9ddcwct/2cHGZzYgNFRrHigH00hi4GBIBylskDYYDsJ0G98LC0HjZ4a2kdpGKAuv6BPWQmamyoyO5BDSAWET1TV+NSLyBbWKR63igZJYhk2yqQWUJJVsJtncQuusLB+56VMsXbIOpQOaUr186+ZPsvGFV6iVNOvPPp7j5yU59PRm2s0spqcJoxphtU7W8UlkJDd+5GI633EJL9+/l0c/+HOaYyb9YT+Jpb2c+cVPET/tOAqTo9x95++ozIyzcG4Ti5YvJtKKmlfFsv6qVVsoAaGKCLVCS/E/bhopG7KRLQ1cYZN2Uzzz8BN85ZOfpjI4xhtPP4J2U+x8ZStDBc19D7xIymgiqP99tMg/hDwilKIp1ESHR3hz7wBeIWRJT4Wzexfj1y8naW9n23/ezcHBUYKJSYYO9bFnOiI8rpk5i47DXJTh7rt/zvrjzybY289x5y5h9NBhvvP977N41lLi2W60bMTVZ8+ZhenYlApFhFTUSzVqVY9pnScpPBJGGSxNFILUNpY0kFIRKTh89AilUglpCBKJBKOjw5TLRWIJi3q9imHaSCkxDAPf11iW1XAGeI2puzChVCrR0tqNykMU/vV3fKpVj6amJjxvDLRJFIFhWAwNDVGv1/H9OjOFKWKpFJVKnda0y86+ImCx4tTjaGpqQkWSnp5uuju7MSyLMPKRx6g15XKZaqWCVoIoikgkUsTSGZRRoOz5JBJJtFEDJZieniYeS2IYEqRGatARWEaje+/r60NIyXPPvIAAOjpm48YrtLc10d7eydj4FDoyEKaFUmWUChkdLpJK2TRAt+KYK6DxWOLxOK7rIAQkEgmkhCuuuIL3f/BDbN+9m/t+ewd79+3k2aefZt68hXz8Yx+mUA44fGiaCy++BCnBsizyxSniqSQxN0EsluCWH/+Uq6+8igN9+wFoampiw4YNBEFAvV4nmUr9TU+t1WqIQLDUTNBXmaYaczlxxULmeDEyozOYkYFjSrqFgy+hyWlCtLiURI6Jco26V+aVza/S2tLBxNGDXHn+eSxYPJ8tP/kNO3fsY+3xZ+BaWaJAkEpkSSXSCC1QQLlUQumQ8y94D74H3/jOv3DJpW/BidmsX38epfIM8xfM4dDEGEml8YsFqLQSd9KE8RobNm/g8xet5Y3KOEuMTtqPb+Xw8BGuuOMmHr7pVtZddxlPxzTWuhP53T0beTcQhSFXX3klE+PDdHa00NHRxEy+zOT0NBdcsJ5SocQFl6zle9+4FYzGsd9wIoJAY1smYDScEIZAq4hKpfK3k2AsFkOHIaEfEoYKy2j8Hyk/IFCaRCxGLBFHWg4WCh15aKUwTJO4a4KU+H5jHlPNlygUi2SzrcSyFpesv5qnnn+YO+/7OeWyyanrTuOO3/2KYn6aZCZOqTDNmpWz0bFLeWLHM8xa2s3wQB9KJlDFOs1ZkyClOVoc4N+fvZXNTzzJL37/M65a9zbadQ9j65YR9sznmR/eyZzmTs475VRu+dH32Lu/j/mL5+LEXEwEOgxRhjiGY2102H9NqhuGgVIhqAiBIFQhphFjx1+20NXWxYZnX+CE+UugPMMjdz1F+4nLyNb6KMyUSWmXCV/x965/jKKNosuoMPb8c/zrZe9ANmm2/+Q/KQuTINrKRHuCsYFD+EWPQtVj0jdIOzH69xs0Vz3WLszyUsHjF//Pb7FsySlrjqPLnYeYLLP51Sc4rCMENmMTBQ7s7QflY0iXeDzB0OgAMjoFKxpg//5J3nrVNUwMTWNZBqHvU/UE0rCIVEA81cqq1etR6icEvqRaKeEEEb2pDja9uYmZ6gEuungdfnkCS9vEk0nyhSIDAwOMHDmBnu555KcmcSVEfpWpXJUWu8hTT25g90AJbUDcSRIoD9NssJULM1OYwmdicpSxXA1pxkBb9Pb2AgaGLdi8bT+bnn8DaSnWX3A2ixctwbVNIj+itaODw0eGUbpCd2+A51VxEy4Tk5KUncWrh8TjTVTKRUxAGRLbkURRlWyqCSk0ge8DEESNIVp5JiKdStLZ2Uw9nGLeQtjykkl+apShI2MYpmDWnE68umYyN4pWEHdNbMuiHDXuCymPaaAGYaBItqfQGkaGx1AaZgpTrFi2iLPOOIWffO/mY1Cvbvr6h7jsrTcgpCbwJOnmGAf29zM1PUF3VzOTk5Nkmx2qpRyvvb4JrWtcf8MNGKakUMzT3dVCc0czI6VpVnf0kCoLLCtF3rfYqn06Y5IrrFYK4wGvF/qo9fawN6kIAhvZ3MKln/oQxnTIpnvvR/ke031JSsrnun+6Ft0huOiKS/jDr/uYMUZ5/NVdvPDYfTjZNubPSdDdE+fst12AG4vR09nLUNFrdGQaDC35z5/+M5ue247ntfLa86/xX7/5GVvf2MyWHZu4dtXbWJZo4+hIATedpb25g2KpQLU4SdfcJHe8+nuuvvFtbN+4g74f3cNHP/JhHvr97bz1kRv57Rc28k+/eZKPfOwr/OaX3+PdwIOPP8qe/ftJJNNoI05LKsNjjz/E1NFhDEPw5DOPc/UlX+fPDz3EqesvRgg4cmSCJb3dDaR85CERTA2PoYSktbmBfY6iiJlcgWy6iVgiRqgDTCkJfB+BSToeB+HgBQEzEzOk0gkM28COQrShqfkCIzQoFQRuwifelMJIRGx+bRPnXbCeqck6qSZBzOrlvHMv4vFH/kRQiUi7cfDBjQzqM2WOm+exetE1PLtlC6/0K84+czFhcRedUnHzL77F8sWLSV1+Jd2XnETXxedQDlvoG53mkAqRA9sQkxMM9E/z8ovP8cv/eppzTpuPJQVeEKAxMTRgSogcTDRa1xBGQKQjQh1HCBdPe8SEwjSTDOw/zMHxffRPlwgnI1747q/4+Pd/wLqrTiOqBMRSaTKJhcikj5P+v6Boh0IymUoxc3SChTd+nJSEHmUgEYwTUt4DaQPS6RQqFH9p8gAAIABJREFUa+J0tDNTLhAozZQcwnhDMeNpUvPbiCH5y+Budo5FVFRI2rIoBZqEtDCSNvPmzaO3t5ddOw+QirsMjY2ijBp3/PIeXvvLFJ/5xL/wzFNTOGZETQhKlRA7LkBBGNSIwiKICjMzR8lN5SlHOSZKHn954y8c7DvMgf5+dm8rEXdjmMJuaLjap1bJUylNEYV1pvOTmAbE4zZbt+9nZLyEQKCVpu7XUFHjE1oAmaTLrh1vMnf5MmYvWkQmPZewbrBo8VweuP92It9nzfFLueGqq8g2N7FgwSKSySR33XUPhUKBqVweFTUWNLyy6TUA6lWfxYuX88qrT3H/Pc9x6WWncttvfs9NH7sRiBgfGQetmR6fRCuoVupIyTGNUiOlged5HDpwhPbuBK88PcbS5e1UK1PUE0kmclMoHVEPfDRgWga26+J7IVJITNPED6O/ddtNLc0sWriYl59/Fdd1+fd//wLf+c7NHL96FV/84heJVMD4+DizZvXS1NTKS5te4bRTT2fnnp1UqkU8r0Y61cLCxQvp6upioH+E9p42fvKTHwFQKBWJopC6H3Hfvb/DMSTpZJL5ixcwM5PDyqQx587ijCXLqDz/F8KgRLFQ4Bsf/QiZzhYSPV38+c67OW/NqTy+YycL0m0ETTbaE/T3DTP7xDWcfsl59Cydy9J4Mwefe469L+6kd147t9z6M04443w+/4GP8eFrz8MMNbGOCoOT42AkaU9lGRqfZsmyFB+76YcsX/gnVqxaQ0fXGiKpmTtnLvV6lfvveZ5CocjFV1/K9MwEpiwSM0rMmpPkhU1PcO1116N0kaVnr2a20czvfvkzrrnyYoIt/cy59CqazzqDRy97P4mECwWf7W9upXPOMmq1CmEYNmSvsVFsUyJRdHZ1ojRIy2R4eBilIdQaLUWjgxQCpRUt7e34foDnedi2i9YGMTdFuVwlZcQxTYnv1zAE1KMQV7jUvTJuMkm10vBe1ys53HiKWrVKLTQwpKamp5kcDVjaZOMkE5x7/kXc+L5/I5N16D80wYUXXshDj9yBF9YItY9hCVQocJMpiAyQAYSaC088mR1947y24UUuPaubID/Kx/7lE9zz+/u59eYfctzKNVx67YVMKoGvbHrD2Tz80G62b3qdr3/nx/z6rse48d3rCZWNCgOEEFjCIAwCTBonDgiPGV48JAqhU2hhUQnKuG6KbZte5de338GChd08uWEjyzPtvFjcxx2f+jS6PgnCIuFG1IMkIRX8qPx36+X/J2jW/9Ore1aX/sj7r8KKWyzt7iAUEdLWlLVHR28v6VQLQanMyMgExUKFwf4chZkqBwZzVP2QSE0zMzNDbbyIoUM8W1IQVbrcTppSGUq5CrsP78VQ8P4br+HVV1/j4P4h2tu6CA3FD771VTY+cwsbt+2hOpPh8KhHS1MCX8VQCmamppDSw48i/vjHh7nuHW9n+cr57N19gLPWzWHf7gkcJ8XsZS1see0AQkSYog1NRM2bpru7jWxTmpHRUWrVEMNwqFbqCCFI2S7VahEtQAsLDIlWPqlMmpnpArNndTA+Mo4di1GuBsSSSXRYwLIcSqU6sThEEQSBBNUILPT0dDE8OsqyZUsb7OYwRIUBQfA/tGQDhBJ84xs3cfFF5/DEE0/zhz+8yMjQEPlClUw2zUyh8lcjbsOGpaP/F27SdjR+HU4+dSEnrlmKH84wPV3FtJp46KGXMExJpez99X2NZVqEQeP4GKrgb5jN9u4OCoU8x61Yi2maTOZGaWtrIfQ9hoaG6GjvZmhkgnq9zhVXvIXzzj+H3Xv2sXfvfqrlRogn8BW2Y1EuVXBjDrv3bGPlypX09vYyNDiCEBaGNClMT7Jk7iL2He4nNE2kKajV8izs7eXxhx7H1bBuwRyahcW6uYv407NP8NEbrievS9RtmHxxN2vXLmfX668RSyeJZZuZrtfpKwRs7t9HXtoct3o5XXEPN+lSDVsIkmkMpUhMHSE/NY2UCaTp4psmQRQyOHiUXCmHYYCWceavXEZPVxcZVyKlZO+B/bS0dRIqyZY3tvLOay7nqrevp+oPs2KRoFLoJze0l3I14LRVF1JzSzSNT7P7+X088VKRrz26j6//6nYe/K/bUMUCO/bs5he3/ZKOWYsJlSDT1sKGp57hd7ffSXl6hs989YusWL6My846hRNOu5i1J57Abb/8Frv2HmbN0vkQBg1ynVIoXxFpheUk0KGiVvOIp1IQasr1IqYpsR0ToTTCdgk9D2lEaNkYuHtBiGlb1Os+idhfvcmSek0Ti8W48YYfc/vdXyfSo6AT2EYP3735P3jH9WfS2pYCWcMyDaKwjmNm8EONbSYJiaiXXbTUYPu4KB7feC+ed4TT1yxhenyIjmwrewf28vqWbWg3xbnnX8W99+Q4csTjrl9/HMuIsW3XKNte34yIyrz/fTcQ6AKmkGgVok2BwGwMZWWIwgPAEBlQAiFshscL/PjbX2JyYpRwMkF982aerB/k/oee4ryLzsaQGmnYjI3WuODEL3Dc6T7TUxM89fyD//+iWf9PL+UHFMtlKMNWv0xcmCgR4QU+e7bv4/k9e9DFKqXRSaqVOpFn4pgJDJFESpPIMIglY3Q1d+LEbBRllJGkq3sOszpaqVTKzJ6dYP3FFxHoKhs3biSdTtPR0cHBA0e47w+/5/wz1jJTc7j3vm0Ni9Z4CHIalIljZvHCkHoZTj/1QhAhhweGcWPw8mtjqMgjlbIZe33/MVC7gREzUVqj6rBoSS/7dxUJqmkQEYZp09bZRD6fpxyWCGn8D9imIJY0CYNjK89sg8GhcVzHQNNYF+baklIVglod24B0LMNUroQWf3ViWIyMjIGG6dwU1XK5oU0LhW27+H6IZbqEqoppaV568S/c9vM7WLyyhRXLV/DRm/6Zr3ztW+Qmi0izgdNEHAs4WA0Yve3E6Onpob21g9e2vsiWV/t57S/9WFIQiggVgeUK/OoxBLKiAbuPQkwrRhj4IDTXXv9OhNT0zO4mm82w8819GIZBe2cLyWQSITWLly9HBYIFi0LmzpvFwEAf3/ved1i+fAUz+UkEDkIIMtkkApO21naEhFWrl1KtVgnCkK6uLur1kEq1xooVa5gYHqKtqQXtmMSySZTRwbKlS3jy8cephYIXjg5DGHL+OWfQnknTNWsBLzz6IGdcdg6puXVWrTyBDivBtq1vUB0tgm0wf3YHl155MU/sPkRNQnnwECPDOfKiSLWusE2bwuB+Wlo7mBwbJKSxpkoLQVNXJ7aR5IzTTmXtaaezaO0qmrMJdLXA3r17WbhkMU4yzWR+hoUrVhHUphkcHGTV2h7GRl4jZnrYVoKXXnyT/bt+xtnXXkBzIstJ73onff5hcoGmrH2+fcsPaQvicMYq6vU6+ekJpgpFeqWgXqk03E+Ow6xZs0gkYnj1kDVrTmDHtu1ITBbNn0+9WsarlLFts0Gp0waBDgjr5YYLxFCEYQ3DsBCGwgt8bDfVcE9oBVIT4WMaDW8zEWjpYMZsFBGG0ESBT8xt4vCRfezv28z4UBGt4JGHNvLZz36eT33uXXieR7U6hTAFImEizTjlKMQwbbyoTK1WJZPswgs10nSoBxEnHHcWTz5zLwN9Pl41wIlP0dFj8M6lb8EPV7LjtUFG+4+w8cVnMczP89sHXyJhNPPAPc/z1a/9M+ODo7TNSiEECNtG6bCREJYaLQRKC6QwCQHCEMOw+fZXv8rbrnkbezZu57f3/wddUcgPbvo8F112IdRLEBN4pYB4KkWgIiKvjoj+L5BHtGXhNXdiG3HMpCSWjFGfKeFPTbNy4XEsP+s6XC2JJwxUUGdy+Aie5zFw5DBCCN72tvdwYPcBXtz4DJZrEYvFsGM2XU2txNLN2H4Z3yxTqkw0+MMSDGlTrdYpFKZ58OHNPP/kRtYu72LRyi4++5GPItwsExNF7rj9LkIVcORIkaHRA5j2MY8xATqy0MrHtm1KlSIYBqZroyoSI6Fo72inNJNjaGSQyy8/lYHDRxifqiMMG8NIghbkRkp/o+8GoY+sWwSRh6rXUKHGBEIvwg8k6WZBfmqa6284jfd/8Cr+8uzzhGHIvt1HOf7Ma3jwj4/x6utvYLvHgi+RzwknnMiWLW9gmDZBYCOkIoiqSCEJpOKZZ3ciRcCRkSpajHPfH5+kUWolOgQQZNqaSMTirFyxDMuycOwE5XKZZMLiqivfju1oIlXH9300kloVpnMVDh85wPjIDIIQhQYB17/n3SxduhQv8pgYHaKtvQXbMQh1yMqVK1BK/W2oZR4b7FqW1bBTGT7tHSewatUqbNs5lrizEcKiWqkRhPVjdkmFYSosu5Ug1IR+QKVYQUkDbdjE0zGoeGgiqqqGiDv4lRnOu+BMrr76nVja4ZYf/JBvP/goZ61Zy6U//Abzs00MbXkZB9jw3FOc1NEDC5dA3UfYJgNGlT37d3D8mrNIxlMMt7aQSCZJpDtJt7aStC1c4VELJXY8iadqKFFHGBZj4zOkMs0kTI9sezthskTkWghl0dk7i47QplABYfWQrE5RqsY4OFRhbGovp5y0nFTa4tDh+7j+PReRaqmx4fFdbEtZLF8suO4rP8IwDC645mIK/QdIei2cBBRLM3R1zaZj8SKqnuLI4X4mpydJmAmampqYO3c++/YNMZWboad7PhrZwAG4FlLGsR2HUGmksIjjgnEM8EQDjKSNGgnHRiMBD9MEZB0pNTrS+GGIY2epVesQSdCSUEuScYfbf3sbH/zQB3j91b089uwdpFIBQrjkp0e54JLjyOX7aGtaRBhmMG0bUwgEITFDoQmJpEki6QA5XMMGX6EDRVuyg/e+40v8+dGn2bt/hku6Z1Nz6xS8IXZtDnhl0xBt3c2MHNnJUzt2s2bdSbz6wKPMX9HF+rPXc9UVl/Hr3/8UaRt/O3Uq7QMNHGvoOzh2EhX4mFacM1eupn9gP7s37mHvntdZSBlzxSo+dOs3CasjhPEMrqpiJGzSEWRb4qiwShhEf7de/mMUbRVhC4Xj+CSbMhQLk/T0tGGaFebM70IZjUP96PQY05M5jh4epFQuUw4CbNfhgfvvB0LOuvhcnJhNfmyE5niMoh8wPjFKyo6zdH4Hk/kS1WKBi84/m6vf+UHWrj6J088+k21bdlIJNC9tm+SLX/5nuuYu5/LLrkIBhgWpRIww9Fi0cDal2iQIRSJpI6VJaayK48aJWyHZ1gSVUsRkZYru3gXUajUw4eCBCaR4gtyETxTGME2TYsnH9zzSLRmqlTqq7iOEplavgJYIAcmUi+/7hH6Dw5tK2bS2mBw4sIuf3zpGfvoITZk2nnxijHsf+iYImNXbyqJFS3jphU1MTxWw7GFMyyIMAgzZ6O+OP+EkDh8+imUEuG2CYq6KFtDWnaC1eTbd3d1kmppYvHwZSgswYyTiLuV8niiKKBTzSNkIR1SqMxBGKA1WLN5IHzpxkskslmkTRApTBxQ8n46uTizDZHp6ilqxyOJF84mnYpTLRcDBqyvCUJFIxv67UB8LayAiLMMhigKaWxMov7EAGS3QOiKbiaFFHKVDSqUCmWyKTCZDrVyj6nvEbAeQeOkE5lSFulnGEZqadsHRLJw9lxcff5pHH3gUCVgqYHlbN7ncBP/y/ndzqDCG1dFCrGZgS0F/OcR1bKRt4RuS9mQSM5NCNqVxUmnmd6zDlgLXTaK0YLKYQ0YC23EwgxqBLjBdmgJtY5ox+g4fJJOF6tB+LB0hzRiTIzlGBofYM9BHvVQn0oLrP/xenFiawaND5CZHufLKqxkZ3cv6029g/54Xyc5r4tLLz6JMkn1DIX945Alu+tgn+ZcPv4+jowcYG43gpzB/ziIyzSmmC1MkrQxB4BGLuSRsh2pQJ2PZTGCSzSSpRQrQiMBDuI2QVagCpBFDqzpamn/b1iJJgJFHYFD3goYfG4khTaq1AvGYSy2AmNPETKVCUzbTWOCMicbgXdffwL333MXE0AxtXRkQ8M7r3o2nC9jKpaYjmtyFVGtHiSVaIKpg4hIREuISAiYudV0l9EIcERK3s1gClDCp1TzeccU5PPNSD/v2bWfRsoWkOjQjI7u4/ZYfo1REPfL44+8e4D3XXc+2Nyf59a++xBnLz2d4dAQsQdmfIRlrRkUeQmo8oZDaxhY2Va9K0k3yX7fexmknnEFra5ri7jGWGynGTcUzTz1CVDcwrHhjAZl0EMrGDxVRaOBVK3/LL/zvrn+Iop2wbe68+RaqfkAloPFJFjS4s39tQzMxm6XLF5FtStHU5LB06WLmxjuRps3cWbMZOjLEww/dT2trM2etXM3c7m66unrwpMHg4BSPP3SIwdEhLrnoXLZtPcSp69YjjEbEWxNxzlnn894PXM0Pbv4hj9z/OD29Mbq75rF3757GUtS84ppr3sO73/NBVh1/Em9u3w6qjDQsZFimXgzxq3VqNZBIdr+5mznz54CCVCrGwd31xnMRDSCUaISmWLe2F0WBpkQX+VxAz5y53Hn3nzEsg3K5jjxmkJYSxocaCzD6DxbZuqWIbUksY5xQWTQ1uyBheCjH0JFcY6+eUIyNTCKF0dgqL6tc+pYrsN0Ua04+DSnrVAseppCYFghTYdsx4okEwjTIH+t4695E48FGDa5xtjWLEIJauUIymYEgwoy71EKfRCKBLQwq5QKmaRJphWMncOMuExOjtLWliSUgnsrguhJDRsRNAyEk2aRNFEX4XtjQCYVoQILMBmDINiykMAmCgMhupOxsu6GDBkFwrMgbZJs6G+6fKMBxFV4U0NHTTuQHlC1JMm4TVFwcQ6INmNXVTmWmyLe/8jU8YeEZgjDwEaFG2AbjA4dZZqxG+BFhqJC2TUGGVHWIX/Nx6wGxSKBm6uQm9jOoAmSkUQJyI2PE4jbYEGgTy3QZzw0S6RITExMk4i1cdM4VzG5N4MZzOFmPU1cuoGnWfF7YOsncee/hwWdfozWRZjqXo1CaoX9sD7N7OnjbFR9kzarLee/7/okP3XghVveZ7N/xCtKbwGw5jzNPvZ4WezEfu/Yq4kj6Bw4wZ+1iAGqlIiN4oE1SbQkOD/bhFetkW5twHIt0W5Lw4DDjIxO46TQCge0kkLICUqN8QDYIko0i04i0YxSRuMdQqxKlTUzDxg8C4lYn9XIO7WaIlMMLzzzF26++lh/+8AesXnIS515+Mu2JeVz7Tzfw0U9+jLPO+AjPPf8kD9z/X433HuAaJjU0CbcVzw+pRyYeHpWahSHrWG6SWlgkZnaQdSMcbaCoISyFV58kmUxQC+ucefp8Jqe7+dZXf82ll13PVz/5eZ55eTPf+87tfPnfPsdY7hBD/X14xTfZ9epOHnliI5/+7AeQEpKxY1F8baN0gKkVEkHghaQSSRxhcfz8uXz0wx/ntR0H0OF+BqJJDvsaWa8hnDGIUoBFGEVYhocwXZqyWQxHYvL3O+1/iEFke0+bLgUzJF2Xj3/449z7+z+wf38fSsFPf/Btdu5+jmKxyGBuEs/zyI1OsPK4Ezj1pHO48m1X09rchtYRKiuZmB4nqQz88Rne2HOQl3a+hpNI8tif7uXQgWmyzRaFqUYQw7QlgS2wTaiXGltf0lmT4nRISzZG75wOjh49ykxBobVNurmdyy+/mOGRITY8+yS9cyUz04p77/s8r29+CdtoZf+eKU44+QK+9NVvYDtxpiYrDX6H0RgYKhySyRSlcg4wMQSgG11b1fORkkbCMlCUjg3ZNArTtI+lqwzWX3gZyaRLhEcq6WKoNKZjkpsaZef2HZTLZXK5cQCam9tIZZt47w3vI9QhQxOHsVwDJQWxWJx0LEXg10EYSCuJFDUsy0GpkCDwsS2DeNwFJIHnY1kWWjSsXTIS6EhApFC2wI3FUDogCkIIG4OmSCsiW0AEcTfWcG7EExi2JGY71Os+YRhRKpVw7IbP1zRigKRSblgMY5YgIiKWSuCHCiUNHMs61o3rY754H9uSpNNJpAFzZ/dgWRblWo1aucLWbTvRQUiuVoBy1NB0qwVCCeOTU2STKUpD48yfPZ9SqYKZiBHETGJugqmZPC2ZLEGlAkkbVQ9JWy6peALXddFSkGlpxYxZiMgn4bhM5Qt4XkBUnkTokB/fegvnXvw2glDT3ewwZ8EsxscmSCXbuf2XdzE9VWLd6Une+65T2PzYw/RPpmD2CrTVRt+QwVe//DlkEPDKU89QKOaQZpXp/BhzehaTSXXyrW9+nxc2PEl//3aEM8T642/i61/5MbnwIK3L0owdzbFmwWn8/D9+yGhhml/d+hN8M2LW7DmIKMmnP/8ZJscmiaWybNiwgVqxSL6gGDwyhp12uOqyU7CkQooiUkOkbZBRI8n4t1VbEmH4oOIY0mBsLMeOHTsJ/IjVq4+nvaOFSq1MU6aJNwdGePr+B/jsv34UIS0MGVKZ1jz33CizjoMVC7sIZMiRQzle3VJkcM8hZpTgkT/eiyMPMjBSplKZzZmXX8mpa9o548Q681acTE93KxnLQGCjtQQihNBEeprAbyVCYaPIF4ZIxHup+h79RyY48fg5FPI+777mn3GbY+zZ9BTZRCtrT76A8y6+gC/f/C1u/fnNnHPWqagoaoS0YnEwKwhpEUSSvj1HWbtqFSd3nkZu6hDZYJAl7R286wvf56JPXQ9a4ZVmqGmNkYakbiPSeaRwQDnceO0DHJz6ETPlPG9u3fu/HUT+QxTtlo6sLtQLEMGF51/EC89tQKsAr6a54erL2LH7SYIIEokUhiEIlMZ1Epx1+ls4/ZQzWLxkDkPDR8h0JJk1ex4dzUs50vc6W7f0sXPvPqZmKuw9MMCGDRswZIhBhKEjFJpqAEKZnLxO0NnRRSqbYc7spTz44LPMmbWabW+8yXiuYcFRNDzG0mikFts6NCqC6665nMmJPYyPVhg6UmJgsE6EwrAax0YhQIQ2pi3wQw+lTJYsXUyhmGdyfAwV6WPaH0jDRkUN6p1hWJimSRB4KK1YsGQeZ5xxNolEG/l8DukEECl04BJLQSbt0tbaixCCgwcOAZK5c5fixJKMjvQzVRxh9uyFIOyG1UtHuNaxjta08SOJaRiYAgQRth0SRrX//ju1tAKSaiUg8CNMqZFIoigikhohNKYlMc1GRx5FDUuX1kZjYGSAGTOxTUhgYCAI6h6ZRArf9/Fl8piGbTTuR0o6Ojpo6coQhB7DA6P4nqYwXaXuVYmiqPHaKIXv+9SDkGJxhnK5zBvbtpCbnObw4BB+OeLjn/oQ5VIJbQkcIWltbcWJm7R0dBL6Ec2ZLI5lUyuUEKqxV9xIxzFCgS8aCAHLMsAxEBocJTGiY3q5V6dW86gbEUG5RCaWYGhsnFqlRn5qAtsyeHnjq2Tbesg2N9Pb1U4mm2Q6X2T2rPnc9qvfcun648jl3+ATN72F6f5NyKZ2HnguYKaaZmwqQVdnCyqo4hUmiXSVTEuSbDYLuMTdJl7a+DoH+/p57OnHmCrsJz/h8rMf/ZxoZh8tC7K0t88lm17CS0+/whvbn0cYJm+59i3c8L5/IpWZxac+8FEq/TPEejt5/qXH6GlJsutgkUsufivd87v58+9+TndnHK0qBEGA46SAYyseUQgEnh9g226jYBIgMEBrtDIarhLX4eWNO9i2ezN33n4Hq3qXMpnr49GNG/nJzbfw69v+hNnRxtIVZ/Ded72T887qYvEJV/LA7b9h9eqmBnxKGSipGJuUDPTN8KtffhcdDDM1VeOp7T7xTILzTmyhpdklk8gQj7dwyeU3sHJthqSqYkgbpSRSKlAmofIRpomhJadf9j4W9vQysH8/F52zku07XyY3laA6M0Pf2D4+cON7mNsznxNOXMVJJ52AED6h1tRrAU4sQ4vTREpIUr4gbUcsTNo8Pz3BmNIE1QpWLISqQS2ZxAJEVEDJKaTqQEiLy877EqOjg3TMNnnq2bv/sYt2R2ezns7lCRWsOnEVe3btxlWKiif46S03U6sN4NrNpJpjOE6Mci0kHk9ycN8AExM58mGEFwbkDu1m95s7IeYyPepx3LpTWbV4GYNHChjxhRwe6CP0q4RBH4WJPsJA4KNob8nQ2TyDZToow2Xv7gKJmMl0OWzEtyWo0AY0iJBsppWVxy9Fk8Tzy+RyYxTL4+TGio1psubYKiT1PzRZ6OqZx1XXXkPd9xifmCCRMJCBScKxCUVALOES+DVGhscYHR2lVPSZPWsuZ551AVbcYnxygmq1SDoTIwoUOjQwhMKyXMJjjAPXbmwLCSihRJ2mljSG7WDqNLVaBbRqrHCyNJFWmNLAMBMoERLak8jIRFclhAJbOI1IrkqTSDiEqoRpNXgTju0ipIvn17BcC44xhR0nhuHaWLaNV/NZMG8ekVdFBI3UnFerU5rKk6+VyZeK+Cpi2itTDWrEjrFHhDapFMt49YBnntlA5DVkoc/+28dIpTMYrkXcbejnyWSSWKzBgXAJyGabsSyHcjHiEx//NIeOHub2W3+GmRRYEtLZDOViiWS88ZpJKbGdBAIDr1Il1D6+ahAahTIIUUR+lSD0kKZE6AY9MFTRseSb+u/t2nUfX2qUZZAfGaVQKFCrVqiVq3R3LuGN7Tt49tlnuOuee3j00Uc557TzOX71av7ju19hdPAovYs83v/eqxnc/zpDI4pE6mS27pykpXkhW3Zu4PDRvZx+2slYlokbb8WNx0k3tzCrZxGj0wXm9s7jt7/6BV//zJfYv3crfaNH+c53v0wgSzz70kv86c6nufu+B/HLR9l2cJrtrzxJeSLHKRdexBe+8DneeP45Oub1snfPm1RDn8l8jIsufzsrT1rKdz/3r8yfY2JgNBbtCgh9g2qtAEIhsHBdl4G+GRYvnUW5VCXhmvh1DxMHtMl4qUQsbfDoQy9x2513M7J7K5aWDOT2c9ys2TQnW/m3r36TeWuXMW/hfDwJv/jiVj578wWc3nUSC9a2MDC4hYVzM3z5p39BleTOAAAgAElEQVTGcmysRAdeEBK6HjEzRsYSjcXBGrQIUFgU81PUKj75chWlDdIJh75Def70+/soF4q8sGkz48XdLFx5IVIOk4h7vP7cLjQLMKSBUHWWLV+Aijw2v/4Yhqm55u2f5NEn/sjmrc9x0qoTWLF4Nb1WguLAUWZZ40QyTvbE8/jNhgfQ5RK+DrFSIRAgQwdhBCgdR4oYaBNf1bHMGC3JVTz84GbOuCD+j2350zpqrCQSETpSpJMO05N1BAbVSsRMsU4UjhCOWCil6Dt4iFKpxPRMgZ1vHuT9n/om0q9T5yitsxbwxa98g5deeo0773qQuW1zyBclaUwyzQuoVQ7hGB2sP7ONZFrw5/tfo1ypsnPSAjyWLGpj4fIs+/cfIZ6IEUY+nhfhupK6F5DNtvLOd9+A7/tMTU+CStI9qwPP85BY+F7Ajjd2oImYnp4mkXDJZrNc/Y7raG5toX/wMJZl0drSjOvGCGt1TEtiGSFuLCTbluKEU07EsWPM5Gu4TpJDh/qpFzXJlI1ppNDKJwgiLDdCaAMpQkzLREeKiBA7bpB1WxFSYcUaHyChr7AtvzHYDBvPKZvN4ldMcHzqHiRTaWxtYydtUD6u3YTtJpFmC6aRwEkegCBDzasjJFjSYXh0BlsLDvX3k802M5o7QK1Wo1yu0pRq4e7b72ZifISYJVmxdAE6iGNYgnjChXiM0BC0dHTRYkha3RDbMOnq6MR140Q4lGtlXn5uG1dddRGXXnweR3NTSAv8aq1RrDVUqwXirouhBBW/yuTwIKJqUi2WMBTsPrCXs845iUqlwqGD/fT2zmJ6ZgZpaJqbGwMlAD+qIwzZsLJZEteOUfHqDYaGCdJQKBquFUM3ZJl6vY5tW/iRh7QcRLmOo45p8YBhmLS2d/L4k09SKJVo72xj+fI5pFKXMzQwzOGB3RSLdXbvP0BNNfPKpqPM7zkfO1nkkWf7mDtvMUdz42x6bSOOHVL1fEYHhlm9qgPLipEbz3P+eQv44zf/g5s3buJLX/4an//O1/nP73+How8OceDILjo6s6RjFkuWLMFKxKAMR3ZsY3R4mFk9vYzPjFGoFJgJyixONwJPNhLHaswWHGFQrtTQURMYx05SGEhLA00IQ1KrVHHtDIXiCEIZBJ5FyfMIAx/DiHDjNi1tCdyY5A+PPcCWPbvpbm1BBQViUwYjE+OcvXQN11x3OZEQfPOnN9Mz9yQ++u7jOWftHj73ow+wYWc/y2cvZs+ROjdc8hHaknP41x+9n2WLF5B2sxwNcuT8CAtNpEyarRheZZrOpjRNmThdsq0xItMmc3q7OPvcr2Hqhn78n7/eR7UyzPbtG3n4/l9z/oUf4Z2Xf5HHHv8dr255mNnLl1Ivj9K5aCE3XPcufvTDf2X1urmsO+EUOlvnUSsVkGjSOAiyjNdL3HnfPYgQvISFIWzQBf4Xc+8dLWdd7n1/7ja979mzs3tN74UkpECQEkAggYiAiA1BQPSoqMd2UBELCqgoYENBlCoQQEiABBII6QnpyU5273t6n7nnbu8fk+N61nqfl7Pe57zvWmf+uaes+a01M/f63tdcv+v7+Uq4QC6imyLoOoIsYFhFCgWNp/+6i09c/1Uic+0fqpf/MyrtOr+VzWcpl2D6zHZSqQzxRA5TM5k9fR6f/fw6AoEweiVHX18fl1xyCQYC6VSGTZveIDzjSj5yyVrWXbiYoM/OlevWE2lq49TJXuR8mv4RSKRraOnoRNP6WXf5LMb6nyVUa6NYEIknNWSlHl03iNQ2EU/G2LPrCLliif4z/ZyzdAldXZ1Mm95BKpMhX8himgZenxvB1LBEBUFUEAXbvzbEAgEfNpuNbC5NqVTE5VSq1TcGvoCfUqGMaVQjlv6TryxJEoriRdfzOJ0OcvkUwaAfTS+SL5Sx250IgkU2kwRBx+FwIIsCMm5KRhanQ0BWPAD4PSHsNicBv5tKuQCVCJZpIxmPoQspxqNHGY+dJFcYJ1cqo8gOfH6VcDjH3EWdOBwVJsYN+vtTpAteJKlMrf0jOJwyNpsDtzPE9re3c+NNn2JsbIzO9vazqSFn+8s2G5lMji/e/lUQJHbseJ1oJkHMGMWlOKhkVPyyC6FiYheq7zHsGpYATrcfxeaitXk6P/3pffz18edZvGgZf3ns14xODmFTS2RLJSKRCKlEkvhkFMPQqG2YQu/oKMeOd7Pz/X34gyEEU2L3nj00NIQpFAr87L6fsHTZQuLxKLJSZYPLsoxlVvkjistFqVxGEkVsWFhWNfGmCgPTsARHdf7eNBGkqsBppoFmaJi6gWCCqVcv2Pl8nmQigWFU2LB+AwMDwwA8/vhv+ehll6JVTEZGEzQ1TGd8fJKXX3mNKz56CbniOLLdh8M9hXgyhapr1E/x0TQlzOHDhylXNAKhGgYH+1m+dCWtLe30DfQjixLjiSTu1gimYpB6cws/sTdiyiVGIw42TmTZuXEveynz3Sl1hGvb6Z3ZSKmxk3def4fxwV7mzpnOrn07yFPCKLo594L1rFixnGsu+whXXrwUVctit9kAGVW1yGRKVAydgM+N3Wln/94xFi1ooJAzkSULy9BxeuzVsIWciWbluXbDTRw+uAW3o5P5S6ey851N+D0uyFUIo+DwB8hnYjT4ApT1ErlSBkfLDBwRhUe/+gMWX38Nu/e8i99fzyXnf5vxxGFsZoHLFlzBd++7jUWXzEWwJLJmBqOi4ZdBVPyYhQKiKKNKFQTJxIaHkiWiywIfufj7/PvXv8z1lzayfecRli+fiYTMvCVfxCzLdJ/+K57GDlzSKJrmoGPq+ZzTMo0DR/fQO/AOmUSBqxZdzeTASd5PnuTth5/i3DvWgyaSFMv4RAnHf4YamxYICsWshOIuIJh+jvYcZdHc5VSMYhVrK9j+Z1famlZBFMBmtxOLxcjni1VYryXw6c9+Cp+/QjDk4NCB0/j9Qf7+96dxOBw0NbZSzOVRS3kiNSFMXccme0jGY0ybMZtzFs1m49/+Qigyn5LpJlfIU1cXomvmTOLj9upImi4T9NeRzBewZIGSplPf3M4tC84nGs0T8NdSLseo6Dni8TiaphIK12BoGggmiqKAoAASkmzDLTrQTJ1sOY2gVoFQAY8fs6JSLOZxuZ1MTowiS/azm24uNE3D7w+QiKew2XVssgKCSVdnI/lCClnR8HjCFAolRMmkpbUJyyhjatWpCa1cwS4qoIsYlo5hCEzkogiiwbvv7iMaHSSbzmCU7dREFAJBF55wlvmLGwkEmuia0YTbCzU1GYp5O9HMSXQzxYxZc1hanEegrpXe/mMc3+4nUhNGlHQcjvrqPG9LC/PmzOGVV14hEYsjCBLJZJLly5fT2NjID37wbWQT4vE4llKiLRKinFHxNQWxTIFMJocnGMDQdBTdTlGtUFBVEokEf/vrT3nmqRcQEDl8cA8bPnYVls3Cb3eRUYt4nW5mdLTTEJnCxMgohYJO0qrQ2NBKXbCWnbv28Nobb3HRRRchCAIjIyM0NTfx3vuvUSwW0Q0Vj8eFroPdbsdu2qnoVZwtloHb5SSTzmNZBmBiUxSwJDg7iqhbVTfgWTsrst1BIV/EZrMhyzKiKOJ0uFFVmbu+9i0kEZqbG0lF0+x6fyeJVJKGxnaOHO2mVLCYOW86Tr+d+UsXYHf5OXryNDMbgnzwwXF8rjAO2Y7DKZDKpZniCtLWEeHgoffo7TmCJEG5XMYfClM5HWNYTRLJpehsngMlk0I+w88/fQvP9AhwbDvfW7AS59ylPJoeoDh1Dqn2BEPdAyQLOpIl4jCgKEM2U6Cs5skXytWPaQlouo4iSYiCjCzbcHl8lLUSlSIUyyrFch7DsiEKBqlMErvqIVjjI5dL4LBbvPXyS3z2E19k83uPsfPtfgR07IEO7F6D3rE+WgSRWWuvJF06AwdNdFsPRHspDYqs/cQGjJuCrLl4Ib94+K/s2f8wjY1hvnT9Uzy56R42XfYsIaGdBx++lw23XgFOE9EU0Yw0llhGxMRuhkDRMCwXTgHeO5HnoYd+yI9+fB/b9pxkapuL/skhduw8TO/p3dx11w+4/6FjHN2/hXQiwZZ3D5CYSJIYPsWMuVOZTByjUhIpWHlCLS18tqOT826+gYKm4RAU3FYZs1LEsgWqe3VqAVkxcflqACepXIZjB1QEcQ4btw3zibWr0T5EL/9HiLZhqhgGiIJOuejEYXeTLRWw25z847nn+dgNq0lnkkzEB8HUyeQnGY8WqQkr2B1lXnrud0RCEqsXT0cWdEb7jrGjkGJkYpwvfPYGjvbEKAsQCnqJTvTwyisbaa51M2/eYg7sG8ftaUAlic0u4nLZsQSNRGYI1UwzkexHr1QH6e12AdM0MCtlCqWqK0y0FGxOBcMoY1FGViTKuTRTaoPVbEe7C0mScLua0bQKuUyMhnCAeDxJIBAgl1cxLAc9PWfwet2c7u7Hqcjk8zn27NrFuUtXopZ0KoaOJFu4XQoVrYgoCkiWgNvnIpfL0NJQj81hp66xi/37D9I/MsSU+hq8/uN85ouLsJRu3E6ZSlnH6ZD5xd1xnnk6xuoLTS4XTtNUX8vomSROTxhDyaBqWd5/PcbzT31Ab08eLJEXX76RvXv34nGH0NUsq1et4fXXNhONTRCPRmlv76j2MC2BieFRRATefW8bwUAt+08e5q3X3sBnGixfsYIte/dgGBYNDQ0Mjo0TqK1ByFTI5/OUdB1E2Lfvfe655x6SsSGef+5p3t1+lKHxScZPDmIhYRDn6MFBDKpMDNm0OHGqm46uTixEYrEYy5Yuob+/l2eeeYY9e/YhCGCzuxAlOx6XnUqlgtvtQNMNNEPHNKpVtKapWJpGJpfF7lDwuv1YlWqwrNNRze20yTK+/0w3t9nQdR1sdjK5ArF4kkKpSCI6iWFouF0yLrsHRXEyrX0moRo3OTVBPJlkSlMbvX0DvPzSe7z15rusXNbEzNnz6Rs4w9j4CF+840uMj8aZP6uTo8dOMbVtCv39g0SjE6xcvpL6ugb6B84QCIq4dQmXKaLV1FJw1vLJM/u5YME8ejIqGwoKSV8IgEcMlUhyBGFWJwtWzOXYscPgVrGMNCYlkC1OHxpgzQWrmT9vLqOjvWCtrsbfqRplS0OrCJw+PYLd7UCSBdo7O8mWEpSsOkQ5y8R4ivr6RlLJHEd3nGTluUuwbDLLzlnHt/7tazz/9u/ZvX+Ib3/n58iKk8ce/gHHjiWrKU7uUU6fGeA3d9zN3/+ym6Ur53LsxBinhnZxYljnqW8/ysLOORQkABOMLNffsAGboPPE3x4Hw8efn3ySTHKUWmUJL27ZxGTyOC1dS3n41/fgt1fPMcuE7tgAt1ywEMnp4+0tT3Hp2stZsmAlX7l9A+tGribgM1h5USffves2Llu3AYco8tO778YQxrjxMxv42LWf54V/PM3mQ2/SUj+DntGTWGYFt5bDtIFLCCHKVX5RqSSx7uqvkVerMLt5s1fT0zfI/AWzmIjt57a7/khBHflXes//7vbfEm1BEAaAHNXcVt2yrCWCIISAZ4E2YAD4uGVZqQ9bx2Zz4HKWmJgwsDuLKIKrGu4pmAyPDtN9uge320tjUz2CYLFg4Wx0vUJd7RRqagKcGj2Oy2ZjdGSISMjHwNAoS5evYngsSiaRZ6C/h0wyTI2vlnlz5uJ2RgmHsuzZswfLbCMWTWNXAqjlArlsuiqOXgGHy0ASQPZ4MVQoFgsEfA4kQSYYrEdRFCSxGnxQKhdwumR0vUI46COdTlIuFOmP9aNVdAaHJ7EMDbtkEE9E6erq4nR3Dw6Xl2g8xdSOhYwPR2nvCGHqJVqaW8kmR8kkx7lgzaUEIwqqqhGPR3G5yxhmkZkzphEMO8kkS0yMDpDLZ/EGCgSD0DsIiuRjaDBFMpmmWK4QcDbQ2lKlCH71+9Noa16ApdZQSobJ5geRAxvJF5PksjnyOZiczNHfk2dK6CqisT5siofWpi4MU0GWYXx8kmAwSCDo44Lz1zAyNExDXQMLFyzg+eefp5wv0N7UguBykoxFsUyZTFngrff3UTElTN1isGcCSZTIDMb/85wiUhNArZSx2WUikTBHdr9Nz8ke9u79AAuJVocHQa8gCQphrx9Fkrnyo1fhbm3C5XHy7q73uP/HP+eub3ydaDTO4sXL0DWT4eHhKgArX0IWZTKpJA6HDUOrbiq6XC68bg+yJOF2u3G6PLjcdlLpDKWSit3mpqLlMSoaIyMj5NIZJicnyWWy5LNZstksh4+dIpXNMRlNnI1lA8MQKJdVvnnXF/B4YXxiELu7CY/XQyZboKxqOF0y510yg7pgI7moxemTMXr6JtB0nddfe4d1V17FB4cP09c3yOjIOLJsY9q0LgRTYaB/lEyqxLSZ09DzGrlMgZ5jZwg31SPMXsKjgwMkJqJMWu/z+M7X+Arwm8FhZqDxkdWz0CWD2q4p2NwmklDC0HUsyaCtvYX9+/dTqZTpaKjO5jsdbnRDxTAMPG4PnVOdOHwylZKKzQbtU5vwBV1Iugufz0exWMbltrFy1RI8zmpMl6ikufPuW7n30U7WX3ElzS1dvPDY45T5BXJ5mCMHRrjzjlWc29bFqlemc6jvfU7EK8xZPpsFy68CFL7+ueuIqf1s/7vKww89QU90M888+wJYCq8+GyTc3My3v/FVNlx+E6K3ljnLmzCsCpNRF5defD2G2cfC9nno4QiP//b73IKN0JR2RAFi0Tx33HYxhqSTTmf47vfeI2m8zfyFU7h+/Rr2vFfh6LFTDA3v4fIr1vDyxhdxO+H799zL4EQ/YgVS2Ry+cICKVsZmwY59B/nyrd/FrgQ4Z+VH6R/r5+6fTMc0vDz2p8fRyjpXX3ENe3dtZuquFxj8EL38/6LSvsCyrPj/8vhbwFbLsn4mCMK3zj7+9w9dwaLqAgTUcgXLrE5qqGqJYimLy1GDrqkE/GGSySQed5CxsRHyzhINdY0cOvI8n/ykj7b2qfSc7iWdFXjhtR3ccevNdHR10TzjHJ5+difZTJFKPoc/MElnu8VF56xh+9vjmKKNQBCKGZN4skC5bKEXTRKVCrlSmVRqP6V8ApcrgNvtxrIkUsksiuxEkgVkxcImS7R3NDN12gy6jx/F6wlg6gayrmC3eXDbU5TyKtffcDXZdJTegX4+suZGKhUZFIk7br2bcDDAO29M8MVv+zln5Tza52aoCQYZH3scQ1XY9M8xBAlWXTCFptY8h/pexT4GkigRstkpqirjJ09SVp0M9aZoqpuOpkNBrdAQbmOkR8HlnaC2zkO5GGdk4gA+2wo8ziVIcpBY7gSG6mAiuh1dhGmzphPwSyRiOSyG8LjCHNz9GrZADTbLoFRRCdf6Qagytu2KA6/PRTBYz7tbtnDhR9by58df5GPXXUz3yd5qLqQlcNHqy3jgV7/kj488gtfjYtHsuYQCQRo622iZ2s7QcDfhSC3fu/tHPPTrRzFN6Ghu5v4ff5dbPn8Huz/YzYrVFzI8NkC2XCQajTMwNIRDFPnnpldob23hxVee4rV/bmL58lmsu2YDrY0dvLdjJ+esXMnOnQfJp2KcGutBLZUo6yqGYSFXVFySQd+JbiYyJTRTZvGiGXhr62hubqVl6gx8IYWg10dtXSdCTRNKMIxTlPF7fThddk6dPMPGF19i8SInH/3olZimjqGplEtZdKOAblSYvaAJj8dNvmAgSy7a26ejGdM4dvwI4XCYk6UzTPbFmLd4PkNDI7j9DTzy52eZnIyx9Y3N1NX5cNkdvPLyJmbOm04+p1JbW8uOHTtYtmo5u/cf4J5rH2bszAiT8Qx1QT+BcA1Pv7mVr85dBl+/iZkLFnL+uYuZ7g2hmDJttfW0Ku30RBPIioO8GafW7ydfSONyeUhEMwDVi5fdQlSq1m3NLGKWXAiyzmhsiM6uFp55fhvzl6ygFE/icJsE7CCIOkOTJR7/y++4+vILWbnyXNauvZhkJsvSpctZf+3FZLJDdC3zcVHTTA4NDxAJ1BKY2sJFM5vQdJPxDDjtRYpimZzHomjqNF2a4YXb78Jv+wFBxQ4mRE/Asy8/xZZNPRzZ+k/+uflR/HUOWu12+sdOcjqXQBBFjh48yc2fuZ07b/sZXXVLOO+cWby5611+9ssfcevn7mX+gmV8598v5+Ffr8dkPb2ne9GLJWKJfaxcczFzZnXx+lNP8+wzf6Cz/gLOO3ctPr+Nnz78Wz51y5385pHt+IM2RKvEdZev4MDxTZgmPPH0uzj7LTZuPEBNOMSSJbdwZv8eZs9fQaR2FCn/Yc2R/3/aI+uANWfvPwFs478QbdMwcHnsgPovB6RlVfuMpVKJWbNnEI2OY1oyw0MTBLw+tr61jWVLzqnOjCoCwyMDqJUKmq7j9/uZHI1jSQGa2+fy+qsv0VZfz/FTk7TPbGPx4hlEEy/yzNNPUMw0k0iViReHMTUTRfCgyG4wdXyeWpxON81NrThcLdV+mNNNIpFi3sI5WLqFXQoiygKzZnRx7ORBhgb7OHH4ONlM1U24f/9xTMDp9iLJFsODPaxYuZi9B97nzS1vMXfubJatOhfRrCMU7MIgRTpr58Dh47gdRWLRMebMbsesNBEIRUkmdE4dS1DfEGHRDD+6VqBQNnDLHlKZHHv2j+F0T6G5s56pc5pRu53ohonlGKZkWmzdnEFHZeasGubPryFXOkZKO4ahimglDcmuMa2xjZJaZvBUnramIB/5xOe5/7c7qKgijc3tZFWNSiHLlClTaG6qJxYfRdc1HA43v3jgQQ4e+AKzuhqYs2AelqCRT6dJ5JOIJixqauYPv72f/tgQ9/32XirlMqlcFofTzemDR3h311bsbhdFtUh7RxMP/upenv3jk1x+6WWsOWcFr/3jZbKlDImRSfLFMoViGUG0KJQTeDs7SCXT9PapuD12FiycxyVrP4qm6hiWicNlJzc5weB4L9lUkQvPXYEz4KBFClMUNBIVcDudzJndTMUwGThznMGRGHZPgEjDVNxuhYH4GGNqlmcfupvaSBvX33QjlWSFbDZGIm7Q1zvEZDSNy6URT6TRzQp2m0gsFiUYcOBwOBBEN9FkEhE3odowxVIOy3Lh94WQJIG6Oh/pdLUnXiqViMfjnL9qNXv2H2B45Ayb39jHjGnTiCUGWeDoIJFMsnXbTuKxBJKyEI/H4s3Nz+EOdpI4PkK/zaR+WhuyZTGvtQGAz3z1iwQ9DoZ6evC7Q5TiFZyiGz03hoFCQPci2AT8nlpyuRxSJQPoyJKFKJqYllT9B28KSKJBsVSiNlxPNBZjyeLpfP6OO9i96RFky8ZwLoVbdvHgr37M+Mg4v/z5Q1x95cf58h13cdFFV3D+8vX85cmf8sTTD6DreVKWQBAnueEkdm+YYtEiW8gihS3CrSEkS8YpuCk6AngitQwNxAjXWgyqWUQJZs1p5YtzruNLpkS5UGH+n2bxna8/yJgVY0bjCq6drVAx0kQLBls2v07/yAAuwcPpbhsjQ2c4s/cEl130UV5/tcj3f/gMX/nSpwiGBJrbvKSzdh59+LcsnraAgycOEQk4MEqN/OXJx8iLGosWrSARHWT/obeYNr+LhsYaZFPkny9t49ihfgzV4MxwHxVd5Otfv4MrV0/jK1/7Mz+8/14SsUECbjdTaqfAA9v+H/XyvyvaFvCmIAgW8HvLsv4A1FmWNX729Qmg7n/3RkEQbgVuBXC7ZRxOhaqzSkLTKnA2xsfQTALBIPHkBDU1fuwuCQuVcK0Xn18kny3jcegcOvguTp8HSxaRTQGns8SOPW8wc14b3hCcOLyTy9eupXeonze27qCzzYNl1ZEtxKmf0sbFc86nVCozHpskl8vhcUvMmNqFy+4iXchQVx/h1Vc3MrOlnvbprZQLRdR8EUGI89STL3CiexDBrCa81EXCpFIpNM3AtEpVyL/fjVqAU6fynOoexTQFFLuTYx/s4IVnduLy+bCcI5QSTtw1EWobFEZOVbDZJ7HJzaSKvVx/4xwUayqR2umkc30c6XsGyzCJBGuxSSaNtS4czjxObxHDkaIoNKPqCvG4SU0ozPQZnSxc7MDtjGCoTvwOH+VKFNlToGIvM1k8jC0j40i0YFNtzBZb2VbezQWXzuPY5MfR9QqGAmoyyvj4OIlEgnwmRU3IjWwTKRSyfOozn+bLXwsSj8YYT0a59vpLke0OpgyN8pcXnkQtZdjy1ouMRifY8fbrKHYbouLG5nCwZ/9uCoUSTU0dVLQy0Wg/4ZCHi69dw8EjB2kcmUlZFIiXCxiWk0QxRWdHG2dOn8Q0VUYGT9Ha0kUoHAHLZHxsmBMnTrFg0UL8gQBTGhvQ0hkaZjaxIOCgtHEjS9rmMro7ytYzJ3F8/HNkO+fQ73WwuL2GSKcDd0BDreSxRCevnTzDvt4DlFqK/PobQfa9cZBdWxqZ4q5DdExis4eYOWca11y3gaMHj3H55Zeyefs2jh4/hCUbNDbWs3fPHh586G/MnzeLeCzPyMgIn/nsjWCV0fQygUATNcEapnbMpLdvkJkzZxKPZ9m1axcrV65m3vyl1IT9jI0OM2vOAhLxDKlElki4BbstQvepSULeVpKTKdpaFHJNdi4/bw1+t5PevmNcfsX5AOQHT7NqxRVkrVEcmRJtzQ1kXWXcMqTScWr8bgQTSqkAhVIcj13EQMYSMlR0tYofFUvoqkk6WaC2LoJVFhBUPz5Xhc3P/IrXtx3m0d+/ws3r5jBv6XIczmk89dQjOOxTUW0y735wEIfXZNqyj/KVH/+Zu//jj3zjli/gDZiogQiiLYcuWLgCCqWEjZqQj6yapqIVCHvK2F0adW47LeEQgujCtKotHBWTXKaIzybichvc+OW53PTVFxAxEEyF733pDfrHd/LBW4fJ5E/R1D4XzUyw8+RW1t2whr7Rzbz07N/59Ce+yYZ1d/L4I9tJ6++y9uJlNLrnM9qbB8PD7MYujp8q8MQLv8EwJKl0dBoAACAASURBVG647T9wSgWe/NubCJYNKX+UZGuEyy7bgGfeUj5541psioBlWIiSBiWNj13zTWat8HLOuW5OD4X5y/N/5t0PJvjRh4juf1e0V1mWNSoIQgR4SxCEU//ri5ZlWWcF/f92OyvwfwDw+2XL7/cjigUM3UIQz9LCdB0E6Osb4NChI0RqaykWVEKhCG1tnXjcASRRoamxjv6+bqZ2TCUQ8pNLl/A6/cRGRlFM6DnTj+D00X1mmJkL5jI+6WA0ehCX08GCJTPZufMDNNmkp3eA06ePUCqVaG+byiOP/hULMHSNttZaIpEIu/ceZv7CBVx++aUUhRyZZIkTJwexu8BptyFYIrlcNaDBEuGdd7cTCdeCIWPpxr9odzaXjUqpiN1up6KpyKaA1+ujrj6PaoxR0GRSxSRqQmfLOzvwu+zMn76Kxtrl6GUbxXSUOR3txCZHGDgWp7XeiShMhXKBsqhQzhdRCwIOW5h0Ampca2gKXkHAH8YfqEEwLfJZDd2VJpWKUcnnsAn1YD9JznMcTc7R33OM0UKa118/xPatQ/zbzRXcbgUlHGBKpB6ny4uhq3i8NjL5BP5A1dm4ceNLWLrEuSuWMTw4gmizUREEzvT1MbWthZiQwdfQgG4a1YkYC3QTzrvgQuw2J5MTE1QqZerr/aSTMUxVw6xoDPb3Y5lgd8tkinlsbicoIqsvWE2lVGD2zOkcP3YKSxBxOBzEE0m8TgeiLDM2OlqFR5UKFEYrODSdhOZktxBitNlkd3+a2p73CKUO8fsHd9A/MF6FHZ5l98iWgo6BrcaFb20DybZ6jh/tgeApZp0/FcmmUBNq44033ufVl9/k8cf+yob1V9I+ZwbDE8OEAzKDNhs93T0snD+d/r5B6iIt1NfVMTjQi91up7mlDsOwqpNRTQ3s2r0PtWxgWiI2m40DBw6wZcubrFgxj107t9Pc3IYoOHHaJTRLwO1z43a78Hm8aIUiybKKw5CRRAfpgo4sOohnKtQCQW+YHEVKpkVR1dFNAcMSMSWZ7r5hVi1YCKJZnV23QlQMA6iGJciSjKaZKJKIy+VAEnUEoUQqUSIez9HY3MCZ4RhXnX8Oa+a044/UIljwhz/+nU2vv8rai9by/DPvcMXFV3HzLbfw4y/dTk2onmsuO5eECel4Ba1SQCuX0ATIJCqUSxY2u4S/wYVNBhs2RFHCQkGsZslgWtXwEEkA0Qc2AF0AoYJmqaiqE7cd7v3tWmAtPd0Z9r0/yFe/8WVsbjumamFmWti68SCHDw2hGllcksjXv3sBhrWQpedM5+YNP2f9VZ/gez+4iTdfe5sf/eZBtp85QU3Qw4H3jrB8aSux0SPYbFfxo4e+hihAqajR4QxiWFAoFPF4HGiaiuLyctGVS7j9zk9hr7mQR5+4j9HDgzTW136o6P63RNuyrNGzx6ggCC8BS4FJQRDqLcsaFwShHoj+V+sIgoLN6UeUxpBkuVppW/wLuF8qqBSyOol4lngsw+BQHIc9zPt7jjI2NkZBtXC6FOpqwxw/dghZcOJ3OankUtz/kx9T3xpBFR3kjTQz583A2a9zuvs9BgZTPPLas2DKCOhYiNx+583YZIlf//p3aGaFdD7JvT/8Gb97+HcM9Mb4/g/upr21jS/c/AVMQwMDLjh3Edd99Aqee+JvpOMZ1t+0nrkz5zJ39kyK6QyTA31EJ85w5VVXc+nlH+Pxx/9KPJ6kIthRixqiCYpdx+mBID7y2SKSVUvAXUP9NDv1U2zYRRuxeJTJ+KsYuoooZ2hxy8jlEKePjPPak0UE52EqAiieCrLhJDVZwOecysjACLPnrKbn+CT9wwOoWp6GSBMeD5i6i0wmU02PdzRRIcmZyX/iC3hwdjSTNCfYtvNJ1l81k/37dvL800/hDLr58u23MTKWRrQpZAo5EAUymRRf+uI3+frXvoU/EGJKfYRyyaIYS5It5pksqWx9+R/ohTJujwtBEnG43ASCNYTDEUojKdrbO/D7anDYFYqlBI2NDdhEgQP7j7Fq5RJ6B05h4WDvgUP84J572X9gJ7pm8tyzL/DYn17gvR2vVoMFRkaIROoYmhyibWo73uZm8vkch0ZP0Ko6iETaeWDzEbQdI1SKAURbO6e2xlDMk8xd2ETr/Bq2vX0MCjZu+bev8cHug5zc+Q7TO1aw8oIFiNpO1l91Pl/43lZWLbwaTY/S05PisksuYN+endR+7d+IxibpbGkjW8jhdwkMD4xx7EgvqTwoUgDBcpHNxhkZTqFqWTo62shmcwQDNSgOJ63NbZw+009zUwdnek/T3t5JJpVD101C4VokUcE4m3ZeN6WOYlGnUMzjdMjURALomkpTVz2pYoZyvkJbUwejEzFmAkuWz+SDD45gGQXGJ/twed1opkZtUx0j0UlSxRKKy8n8ZTNx+cqkkxOMjKRobRTRNR1FkTENgXDYSSFfYTIax+320tpU5QDVOl1090SZGImhmQYgkoqWGRvKsmd7nP/4j29wonc/Rw4NccmV5xGPF9i7bwvRpIpR0bn8ohWoqgtLN4lO5HDYFSIeD1Y5j93hxDJMbAhgFatgKr2MLMoIiKi6jiSVMABB8WBqErKhUVEKVAQTmTKZLLS2BGme3spNt+1ibtMlfO7mG7E7yhzak+Hmz9zEikXncXKohyuuvZDr19+EU/Ly+e98mkI+SSyukHWFeHfvZq7/zA956De385tfPMzOQh7BgkvPuwzByCPIHixRwzRFkEo4XDq5YgqPy45pmdx2+8eppFX++dyTuNIqi6ZPQ1EMPmwn8v9YtAVBcAOiZVm5s/cvAe4BXgE+Dfzs7PHl/2otWVFoamohEplgbCyFIAJm1f4tCPDggw+iVQw2b9qCIAjs2XkYyzIIhYK43W7qWxrp7+8nGo0ya9YMDuw6gt0mM7VxOgcOH8AQZ/LzXz9ENJblZ/f9iEJ2Eq9LxeN2gwhBp5MpUhGHJ8hjv/0jpiRgt6rVVdhZQymZQlfLCMAPv38P8+bMpaJqfPKGjyNg8K1/u5NwUy2XrbsEp8tFuLUZQYfR4RHGh1LUtXTy9pbNLD1nEd/9zvewgFAoRD6fZ90VV6NXKry2/VUqWhGXzY9aKDM6IHDZqjtx2k2a6uop5hzI9REsIUM0uZtiaZTR8fcpFwzWb5iDZ4OOIAW47Wt7UGMaSkhALRfxeprQRRuG6cIXcDIWG6W9rYFQwI5VtnB6nSg2ELDh9tczkjpOg+Ajlc2Syic574KlFJJzePrxh3jgF9/l94/ez5p113LfLx7g1i/cSTKbwzR1HHaRfD7P2HiU++//JXV1dRRKeTxeH06Xm+iJOGZFZf1VVyGLIqFgHU1NTQwMDNB7uo9KSSVYGyAaneT73/sJCxcuYNV5C5EVC7/fTyKZxuaUcPttnDw1yp//+DfefPNNHv7Dg5iWzmN/eoFIXYhnn3+OW2/9PKWSSjqdQnI5sCo6sWQMxSag6WXymobboRAvqVilIRAnIG9HFFMUTdi5bwLFVseliz+HJyDwp1/eB5aF4AwyOjHO4Bkvbx06gN3rxR30c7rnAww1gVq0E3IHuP/+BxkeybH0nCV8/MabiGdS5FLD5Itlzl15Hq+/+R6aUUG2i6TSCVaft4yJydFq391up1jKo2fz9PX1EZuM0VDfisPhQtd19u/fR0dXBL/fT00whCCYFPIpEvEUkuysBhQLQQqFMmVThGgCQfeQyhZQ3EE0tcqSycbS7HxnKx5fE1PqwzQ3N5PJZJgxYwZb3nqbrtZ2wpEGcsU4Y7E4DkWvegIqMqIkopXLSIqTTCbFwOA44Zo6LMuiopaw2QXqO/1ET59iyaIG0okMPreHmohCbSRCJpHk8d+/iqFrLFjQxKc+/V0e/MmvWDZ3KY/+/WlqnGGG+iYolAu4XQEcbjvDQ1FCIRtuudpGtUQFwzSQxapOWBZYejU02i4KYPlBqn5ndlFHrRTwOiVUdCzTgdvnIZowaHD5EY0Kd3zhYxw+upMVKxax4o5OBsfaGOyO884bb3DNNZ/gnp8+gKnrlNUMstNGoBWubZuHhcBla+bgxM0jjz3J7Td+khef28h5F66gIsSwdAO304ZJuVqIWgpOmxvTqqCrOUa78+Sj8PAD38HuDnPp1Teg2D7cEfnfqbTrgJfOVsMy8JRlWZsFQdgHPCcIws1Urxcf/68WkiQ7U6d3kUjmGB87UK1gAc460gQkPB4nmVwe0zBIpbOYpkkyVUBA4t+vuITzly9j34FDlAs6N336k7S1dfDeu9u46bp1WILB3V+/g1QmTSQcxDQ1WmoDHNh7iHafm8/ffguTk5N8sHsvd11xBYrTQXtnF0889jtKapnvfO8ufveHB5nS1MbiRcvZuuUdJAl++YsfMtjTjeLNUywYxIop4v3D9DzXQ6aYx+3xUDI0dMtk6PQAqmrwzW/dgd3hZs+uQ7S0tOB0KMSjE6BDJpWnq3MqsfERLr/4ciaGatAqaeLDULb6qGk+hV6xIZgNVMrtzG6/jL6RLUzknkAxKoRrZ2NzOPEHi1RwkkpP0NzazEhvlly2hGhFmBLsoJSBwWieUI2faHQcl9uGTUqza8cfKZjdaGYZSxKo8beQdNUyPTydKy/9A72Du/jcbY/zp988yqc+dTvHTxykqbmDQiGPicSx7mNceNEaSiWVc5evQi2JzJgxi337DqDYFY4cqU5HZLNZJsZ28fvf/xlJgN/97hEKuoXT4ea1f74EgsT2d3cyd/408vk0ixaEKRaLOB0S561axqduvACbw87nbvkcpXyBeH6M7377i9z704f5y2PP8NKLr/PCC89RKKoE3WFGEylcoVocThu+vBvdW2SgNEqoEXpOjPPO1nfw+iVOde9iw7Xf4oJl8+jtHWds7z84omepi3QiyAYTUR+TiRRHhke5+LIunPYQm44Nk8xH+cHXv8nAmUn8bhc9Z7pZvfwinn3iCQ50n6SjfRppjxunOMLwyBgTE9Fq4pImIkkSdqeLYDDIm29sZfqMDj44uJ/Wlk40zUBVNfbu3Ytu6IyODqMoGunU+VS0MkcOHaGuNsTaS66gprYdUZI509fD/gO7ufbqa8CScdp9GEK105PKw85DhwGYOX0Wqy+8mJpQLSW1giwqGLqJruu8+PzfmNrVxUVr1vKTH93JhmvvpKE1wsTIKJFwAy67DcWhYJgmfp+frk4HxbxBNp9BEh2MT04yOVTEbg8xOlahVFIZMjLURdo4M3iGNSunMn9FHsuA3lGV++69hQd+cDOdC6/hlhuuQRA08iWLMCFMScRhkykWVSbiE0z1BTErRUTLg6goaFYFCw2bTUIrCSiyQl418Lj9YIjIWBhYpLNF6pRGFKMCsgMBEYcY5YPD3fzmD3+l/8wobe1zGRsVqRRdXHTlNGyXd6LajzM4MMZ7206xbOU5hMIXMzG+nXXXrOWR3z5EfU0tN12/llQ8R2ZilE/cdAcnTnezHpBMCVESwZLO2ucNEKyzbR07ihzhyIEX+fbPb6IklnApTiaHh+hYufRD9fL/WLQty+oD5v9vnk8AF/6/Wcs0TVRdoqIZWIKKJEpVNi9gWSalUona2jraOtppbW3FpsDceTOZUh/kvR3v0tLcwcaNGznV3cOCBYtw+7x0n+lh1673Of+8c7HZRaa2t2BZzQwO9BKusaGYIl0tzVz8sVWs/8R1TBRyfOXbX0HQTewuJ4qoECupZMtF0pUUeza+g8dtY/OmtwiEfHR1tvHSP1+EUprXN79E0BOiUinjd3swyhX84RBWwE9NOIJok2lavQqb4mLrtn047F6ampoYHh5l1epzeO31VxFEGV0TMA0R2S6gU0QzMmhGHrcvgFlxVGHxtiojRcYgXUmiyZNgLxAMuBAVlaJWxCyBIZWQinYkWccij2Zl8HhC5LMGAX8dTpsbBJOmZi/J5BC5Qh+WfAJFz1PMmHh8DqLjMdzOVja98Q9uue06vB4/mVSUSy5dxcVrF/G7h5/j+/f8O15PiIqVo7NzGhuf28ratZfR1NJGNptFkBQERcawqvxrCQGP00U6nUEWhapo5AsIpkGxlOf881fz6stvI8t2RobHaWquI5fLYSBQWxfBNFW8vhDhmnrmzlnEjDm1eO01HA0e5LOf/QSvv/46I8MJypUK8WQOxeWkXCySzhfwWg7qQ2GyYopULk1itMTK+ctIJ+IU1BINbV7+8Pu/0N2fIBju5GS8yrCbmDgJSMiOWgzVT0mr4LC7ECWdXDRDvibP9m2vIRge6sL1KH3wox/diySIzJ0/n13793PH7V8lHPRw/vnnU1sXJh5NkEjGkGSRUG0It0dmPDqIKIq0trYiSzIul4vOznbcXi+lUom29k72732PvXv30tnViq5rtLS0YBgGqqri9dpxul3MmNmJTXEzMTlI/RQHmbKBTVBI58s4nU4A9uw/iCjIpNNpJMWGIRq0NrdQLpZIjY8z3N9LfPYYl6xezuwFM0lNjjKZSaHIbcj/aSQSFErlIvFMEhseNF3FWxticDBLS5eDcNCPoigoSjUSrqJr2Gpr0cU8JSuPV7Lj9TmoWDrRVIHkeIqspjI6VMQmaWTzBZz+KuExFyvjsRtYpoAliFiKVHUkGyJINvRKBkG2oYkVXHKITHoEX7CF7lP9jA28zfGjO/ncZ3+NI1zD3x5/lhMnc/zsF7cgiCKNTQv4+U9+jNtTpn26F7+/lS1vbmYsfYa6Wj/7dpzCKDnZuWk3Zv4Uv/jl39j05nPYzeq46+ToCHWNbby3YwujI1kGRyvc9TVQHBaCIGJZGiD+S9MEoUo/rBRirLtuPUYOHGEblg7Fcgmn0/2hevk/whGp2O088ddnKeVSuL2QzxpIguusfbiCKAoMDg4wMCDywYEjyKLEyy++geKAppYmJIIcPXyE8YkEY6NR9uw/zIJzz2HBymXY/E78Xh9Bn5dsLsHCJbPpPdOHz+WnrBTZf+QDTk0O0zB7FpNj40RcPsaGh/CHQ8h2iYl0ArtDIp9M8vlbb8HvjfDQQ38ilSzy1N9f4obPXM9F6zaATeZ0bw9d7R04HXY6ps9m2zs72HSkm8WLl+BPC8RjYzQ3zSFX1BiZGMQbbOYnP/kVpXIOn89DbCzKksUBhnqjjE8MMKdzOaZl4g+bKBP15CfBEkxcXhVVPU335FPkcqNEalooy2NocgJsEoagIClVDorbK2FzqPScfp+GmjEaG5eRTysU9Wof3+XLkCjsZmz8EE53EJsu4PeXyWdzuGtivPn2P1j6kd/z2NPbWL2mmft//XvOXX4pqWQcU9O5+LLlhGvqGRk/xI7tQ7z2ynaKxTKB0BR8/gDBUB2KXDVKDY70IygmlmGxbds2REXmY9dfQ0U2qG+cQiEdRdMqtLe30tc3wMaNb7Bs2RyWL5uP3+PGYZfYtGk7pm7w05/cT124jgtXn0d8MsuX7vwkn77pM2x9831EIcsN132eB371cw7tPsDaKy5ldGiY6TO6ePqfrzB3YSN9W4YRLCdDw0F0cxrh8BTi6TyOosLUqRZLL5zPOwffIrpnhI073sal1DGl2c9knwNSMuXxCTy+Gpp8TgrRJJbopHtgnGde3kxrXZgNV15HtlLg6Okh3EE/r+14h+LkMLlUgunzOhBlO0PDUQQLJkdHqK2vY+3atYSCbvL5JDbFwenTI+zff4DLLr+I559/nv6+btatW4fX66VcLjN37tyzv7GXAwd34fLWEI/HaWgMMzDYTTKfp66+DcsqoFoSPr+Laa5WAAoVKKsmlmUwxenFYVNoiESwyzbSk708/8Rf+c3P70PA5Mlf/5LW2efidJxlregGkihjGDqiohDyRSgXSzQ2t3K6N0ldQyu6qjA0VEGyCQiyQVktYQk2/G4H4+MlSrkyOjHcioglBvjyLd/iP358J4WEgVrOUdfSRCBSSyyXozYSAiuGR6pQyKSplMYIeBXKlRKimAezipDQJBsufxOIIs899QRXXPEpasNdXHPlx7hw7Ty279rKlLpWrvvMehTLRnvH1P+Luvd6k6u80vbvHSunrs65W62cs5AQCIEkkgEbDNgmGGzADA6M05hoYxNsgyMDNowxmGSSyUFkEAjlnKVO6txd1V25auf9HZRm5jviun4Hv+viq4P6A+qt/ez1rvWs5+buX9zLrDkNvPbW6xiah9REmDvu6uDcc79Oz3GDZYuquePnd3HrXdcS9sZ51ncnj/zjE7bvLpBI7OaJRx7mhWceAywO7N/NpV+/gBkzZ6F6bQRBxTUlBEkHQUQSKXuZHRdBUDCSMbzNIn+49a/84u+/YO70SVAhkxeVz9XLL4Ro25bFbT//d3bv3sk///FC2UgoODiuDQhYlsOKFSvo7DxKRSzGyMgIlmWRL2ocPtjJ4YOdZUgoIrLHi6kb7PhsO/6Al/6BXuLREJM72mhvbSZWFWbGrIWEfGG8oRhmaZza+jrmTZ2G3tbKge3baKwOE/J7qKhr4JTFy9hzZAdOZZRkMsV//ulh2qcuYCQxRvdIih98+8fc+6fbiHjD/PmeZwG4774beeSV/+Kfr7zDKYsX0raqmt6xBImcxrsfv0x9fSOXffVSxkZHef6fGpF4JaZmIqoCglTEdX2MDudYPFVEFiJE1EkEGkcQk1m8nhia2Us2tRE8x6gMuGCZmLaLbYmIXhvLllFlEcNw0XUJ01bB28NwYQtNTXHaO6aRGuunskri3Y2/xlMxRqAii23kCYQC6OOtiG4eyVFobtLo7vuITKGX1pY16IbIgiUz2Lt7H7ffcSvvv7uNCy44m6C/jf+46SL+/OcH8fuCBH1ewn4vPlXA5/EgCzKJRAJHcDjS2cXoaNlrHoyEEGUJ15FobZ6OLA5w2ZWX8pcH/kIqlWL7tv1MmzYD2evn93/8G7//3UPMmLOY2oYaLCvB+GgWAXBECRuZK666mj/+8fecuvpU3nn3A668+jusf/t1Jne0Mzw4zOo15zJ/bgx3tcNbr+3krTffR/WFGCkdxiKLPGrTMaud/R9tpyPeQMvpl3LF2p8SqaojNdCE4yYY3daJ9+KTcUSdSbPrkIsynohMXV0Ma9pkZMWloqmGglbEzGc5tGsbDY3N6FqOgcFe/vn0E8ydNY+gr4KSpqE7FhURL3X1cRRVpLY+VnaNCApVNdW8+NIrnLpqNY2NjQwO9tM/2MdJjQsJ+vxIXpkdu/fg9Yeoqo6RT2fRSxMcOj7A1FlTMY0SsqpgFEv4QzFCvnKq3aJFSzh8+CCFQg7Dtoj4PUQqo0yfMh1B1Xl7/Xv88eHfMmvJYlbOO42OltlIigfdNvCp5cpZFAVMIGuXKCke+kdHaWquoqQXUVQvYdklEPAyPDJIa0stji0hSGCP6hTMIA0xkYpYBffe/Q++8/3vYvpGGCqkCUdC9I9lkGWBdCnLxIRGTVWUgKIR8g+hORkogGKVkP0WluuSK0lUNCzmxz+6nbFMD7VVU6irbsF1bR588F8c7f2M9W9v4oXXfkbatYkG67npBzdy/z9+ze69m7j9Z9cRDEVZtHQul132ND2d+/nTHx9h86Zd9PR2UhmoQFRkXNfm21eupKZhDXNWTOG15x5nw2e7eHf9x3zt8vP46IOPue32W7DMIqLkgGjioiGigqsgCOXIWFyHcGuYJStPIpiehFlIsWnLZpYuuo6Brv2fq5dfCNEWBYGf334HtXWVTJ7awd5dndiOcSKLWkRAYtOmLTRXVVNKZZEsk7PXrSNeU0MwGObk085g48ZN3PPb32AaFhP5BGeddQGJiQQXnHsu8+fPpq21nqDfR3I8jaxa9PT0MjQyQDKbwVQUtjz6KBs2fMRdd91GLpdB9oW49oc/44xVp3PWuuXUNlTwxisPo8owMNiHblvUN9Qy1D/G+vU7ueiyL3P/3+6itaWDpqYoK049GyEQYv606bQ21aGpKpYsccVVlwMC+/bupOfYMRBsDMOiKl7H0HAPgmxjOX5sByRlCNeMMThwHK+vGlCRfFk05wia1Em8ycQvhCkl4gieMrdOkQcpGgbgAWQcZDy+MI6cRpB7OHxsK9NbfeAm+XTrGxTsTbial4mkhqX5EZ0cejGL6hHweWbiai5rTvoGj3bey8cfvM4VV1xBaiJHTV01t/z8Rn71q7vYtn0n02Z20Hksi1bUmdIxFVkRMa0SPn8VsqQQCoYpljLoeY3E0Bi4ImtOX0soEKAiFKOQzvH+jt3MmTsXn8/Heeefz6OPPE4sFqN/MIkoKXT3DGDZ8MSTT7Fn73b8qsIN/3Y5W7cd5LwvfY10Ns/cBbMxHZvf3HsPv73vfgIxPwG/yocfrWfNmtN57OFHqL7l38hqacYLE3jkSkIhleWrzmDnrg/QpRLnrDsXX0glkdLxyQ6bP95MbniIiDeOLsQQRC/3rf+UTC6HPzCdhZPm0dXTS9zTiF0y0V2L//j5zUxv6yDk9+HqOh5LY7yQZvbcmezYNh3XgGxmgqJlMFacIF7lIRxWqamNMzAwgOuqjI2NUSqa3HjjD8lms2SzaUZHRwlHfOzavgPHMFACHhzBy5fOvYxIOMizTz3JspPmY9o6rubFqwRxhByekIpBClNz8AAHDuzD5/NQKLqoXvD4BVLZJL0DA6i+ChqapzPQk6Jp8jgvvvMuqiny2utdrFg+DVuwkSnzPJEldEcjq6tU1tcRkg0UXwgLAVFwGRsf53jPGLmUhSGqhL0ifWMJHB0igRYqbJuKaoVVq2dy/0Mb+eblp7L/6CDVDbU4tk5Y9VHM2wiiTSQaBrsXb0AGzYtgCQheDQwLRaoEJ8LwaIIzTl/Htdfcwq/vfpiH//IiN9zwNQRsQnKUq759OVd/8yoKPj9z5kzlV3dsZP3bO4AYd9/xB6qqQvznH5/GduBXv/w+NjBt1iR+dvfvyKezJBIlLAKcsnwul1+ynD/d+wT7Dhyjr28fn3z0GldecTkCLrIi4LoSO0SdPQAAIABJREFUoggQwXHLA+D/ztYHQHfY+tlGikmdjXu+T5UaYO0Z91Dbpn2uXn4hRFvXNX5880/YsmUTO7buPPE2ck70g0QUj4yhl+gbHea/GS/P/utlbEHAFYB77wVg+YoVrFu3jttuvQkHl6u+dRUbPnkHTU/TNulyDEdkNJGiUMzh2tDaNoXBoR4SyQk2frqFkUGD3bv2U1lVQU/vAD4lyMBgPxU1Lfzk5p9g615q6luprG0jlUrz2Yb3CXp8bPjoPbasfwPNARQRw3SwEbBxOeaF9x34xjlf5vD6d9hSKqDKHhriMcLxKAHXweMU0DI9WOjoRZOiPoQ/ItAz8CRTm76MXlxNLGhSsneSGO0kmf8Y2dDJdlZieEKYdgZZTOH1eglFoVBwkX0FNAMkdKpiEZJdLtOmzEQTN7P1yPtMm13DrNUxBo4vpzjRgl8QGEvvIjlWYOMnfYwMqvQe20c+b7Lu1BC/+fW9dPXsR9NM5s1dSm1tLZFQE889/xKXX345i/w1dHXtoqIyRmV1jKqqGJZlIcsy0WiUoaER0iMpRkeTHDhwEASJaTOmUyrm2LZlMw888Ddwoa6hmhv//XvMmj0Tx4G1a87mn889SVV1lNWr6vB4JH74s59y4Ve+zOjoKI3NkzhwqJOu3uNUVVdz5NAWQn6Zk1ecymmnn80N19zKVy/8Mvt2vszpp66lsb4J0cxRGB1kelOIZdesZfO2/fQfe4k//fr77N+zHVUepVCSef+d90mn08heH2ZuGKVGxE5kUW347rkXY0g9vPjCTuRskKBUgWIW2b55J8PZMc477zxisRhaochAahR/bZoPd26hNTuZK67/AcOjI3z83kYCXg/r2ldjF4co5ZMcPTjEhk+PIqsKwUCMgYEhhgcKWJZFOBTg/Y8+4Yw1q3CNEpFICMkXQfAGmMgmmBgfZeb0GXg9HgI+mVh19H9AHIIgkS8U8crlnvbkaZM5criLWLwajwKFosZZZ55Pd9dxZs2cgaWb/OF3D7Fk1dMM9g7zxnt388TTmxAlFUWQEAFJsChqJqlkHl9lhFwuR7ZQwO+LACLZwgSqIrBo4Vwsy2GiWMKyLDLZJOFohPFRDUFX+eENV/Pqv16gq+8I5647i9nTm0gmbARbJCKHCPgcZE1EdIBiEL00DkKA0ZEJYg1RQrHZKFKMC798HdliJVp+Nppp8clnb/Kdf7uQ71xvAQ6nrphCuEaldWozz771En/520u8/fpGRvp3Y5jj/Pm+J/jqpV/inAtXcLxPY/LkBgxzDMXrcs/tP0UUHQTAsg0kSWXSpBn4fO18/eKv8sTf7+LFF1/hwovOxzSK5W1RwcJxQJJcXEdEEBwc3DLEWHCwlBEkox5PRGHhnBlUVAUx7TSxuPdz9fILIdqCIPLyS68wlhjllFNO4aUX3sAyHUDEdcrxo6qqYlgmgiQjUv4TyidC6BEcFi+ezyeffEBJK/HxJ+9RVVvFr++9jf7jY+i6wgfv76OtuYlnn3ubSy/5Korq4NomDXXz2H9gJ/f97rfs3L6Lb19zOYmxNKGIn8XzzyAejzCcGKW5ZSqWoVLKl5gzaw7PP/88qqKC5jI56mFO0M+qmkbG+gfZk3d418lQdOBkIc6ylibabIE1tQ2cGa9iVHQ4nsshWy4hCUTBwRcMUHTKjETXhPR4jlLMZHx8H9MnT8e1B+g79ipFfYBQxCGfM/GHawiGfBQMnfE8TDgFAj4RxxRwHRvbBtcpL1cUc4OoYpCRiQGq6qsZzGo8+Lf9vPPCCBN9n5WXSAROfAknMFImohRn/Tsf0tjqZeqUZqrijXg9ZTaiR/Vx8cWXgOsSCAQwTZM5c2bR3NyMrusIIsiy/D9kF4/qZWR4jO6uPhob2zgBUydaESEQUCnkDVTViyRJ6HoJr99Dd3d32W4nyZimjWHanH76GsbTBcK+ID/56Q8xDJdDXcPc9ovbUFQdQYDR0QQtzZNoaKyjrr6ynE6niVQEg3glm47matqaW/AqYa65+kIOHtqNUTjCaSva2L9vkMHjo3Qd2oErFlG9bfgiIZKjRxBpxvWOsfFgL3JUISFPJeStJpdJ0dszyNDAENGGSj766CO+/JXzCcTD1ARltm7ewmXfvJI5M+eQGc2wYt4y1qw8m8GB4zzx3EMIEgx2D9DU2EIypZGcGGTaJC+losXePYfomNyOrtn4/QGSyQkmL5iBIEh4PD4iVVXouk5A9eH3lxMIc/lylrTrujgiSIBf9WNa5fZIOp0FUaKkGeTyeWxDJxQKUVFRQXV1BRdc8CVef+VJjh5NMLWtEVsIsuLkKVimgCyD42hIkoyrWwR8HkDAFWVkj49iUaO6IkZXTxpV8TKa7EOURSqCHgRFZXrzXJSIl5aYj5GxPNd99xamTG/lrLNP5pmnX+Vb37sOnALYBlnNxR+uwHQkDMFEFmVESUAhR3N7BUgyxcxuTlt8DVdfeTMvvrue9959h1NOm8zyxasx9CEcsY9iLs99v/srq9ecyw3X3oRgBfjwgydoaqxkpHcEWTD44Q8v56577uDWm28h1Crz0nNP8u/f/xFLly9j/oI6gt5aCoUCyfEhbrr5QfL5MC2tLfzs9qv405/u58wzTwMXFFXCtPUyxk8o4/jEcsmN4JYfMUEQcLERJAPXNFE9ErgQCst4fJ/POPhCiLaLyyVfu5R8vshv7vktsiqjGxoiLi4uCCKGaYELrmOBJJ+gjIA/4MM0XPJ5jcefeIwFC+YRr4xxvKeTe+56GkcQqWuoZ+v2HYyPjXPdddegBMbp7e5heGQAUTXZvusD3rv4A0IhH7/73V9xnf92r1gIQGN7M6Lq4fjhLkRBZvOmPeVf3zFQBCg5JlW6RI1HIWuA5VEoSh5yeQ2v4qD1d4KjEUwlKKXzIIKu5fFXVxNxIJ23GSvY5F0DBwFbg0wSpCkqQ4kPGdVeQJElFi2tRVX9yEIzJc3BcQK4VpBsNoze2YRINbs+fYtIHKwi2BoU8iV8/hCuKJDROmmdMZ/3PjzMtqPDhCtMpJjI1Do/6XGIBNoRTBNDcwkEDPK5NJYWJRKXOOuclTz3zNOsWr2EWCxGMBjk7nt+QSgYx+f3sHffDhqbT8fjKXtMu7qO4TjOCdCuSzgcJp8L0d3TRzRWxUWXXoLhmHiCXlRR5cmnHmP61EUUtRzvvf8G+XyWU09dydtvvXeCRi8SCoW58MKvsnf3PiJVVbQ3N1ARr2Z0dBRVVUmPJxkZGkMrFWipnUdNrIkVi2cjOAX8Pofjndv50fdOZ2z4MMnECCVfnv7RNC/84/e0tDSjqC7p+ip03WF6axWde14iHKrnup/ezjvvvMmZXzqXd954EyFXQVVinJOmhQhWHCXRN0YmshpfdYCm6ZMJ+oIYWo6a6ia2bN7AoYMH+O1d97D9jfV88O4GGqa1sWDtOVQA1Q21HJp7Ets2bWb27OUcOHiESe1TCKiDBAIBJk2axMqVJ/Psc0+RzSUpFjUKeY2B/iFikSjzljZQLGjMm9uOYDns3bWZQFihpr6OkqFjYmE6JrYLrqD8jzMhEonQ1dnH0NAg8coQqiwQiUaJROMcObSDG7//XQrFj7jv97ez+pxV9A7vY+6sJchiB6JrI4o2pmUS8nkxECkhkcvlwAFZ8bHvcCdtk6ZglEqU8hM4rkEpJ1IojlFVX0M+McCegUqe+MdjPPTAHSDYdB66hQfvv7OsCcFIObMcl7yuMzGRwykFERQb0xYZKx0lqEQoGDb1FecyLI2hzC3xy4v+g3UnreQ+/w1oxlEsK0s0KuGJRFm8dAkPPng3T79wP/19QSRTpabKIpcrL8QgOdx088/56J0RqloOc/4FaznzzLXIHo3dB4a59aZ7SaeOks0lqaqawlNPPMnU6Q384Pqbuf+BuyloCYpaClURkGSpDNBwHQRJLmfACmUfueu65bEdMq6rI3tBlbMg2JhCBkGKfq5efiFEW5YV0uksH374MWvOWIdrObz26ps4govqERHUQNkGJSp4PB5kWUaSBALRYBkcazh4ZIV8toBpGLiCQ6lgcuTIEb797euwbA/nn30dicQYb7z+IgsXxqmvmkxr42TGEoPIUoBgSGTV6pN59dW3CIUDGJqOblhIkkxzSxuIHlSrbMPas/dA+RBEcB0BxZEIRYJEHJm4N4iey2GKJjiQyKaY7PGhqwqSqJJxdKIV1TjdaZKZHLqrEBAh55h4BRVV9hAMRREFEX9Eppg3aemoIhAN8/TffAwNjNPbswnXtRkesUglbbQcCK6MJEqAhWmCqwcJ+mSK+RJev58jnT20T61n8+YsH32YonbyZDZv6CZSqTI+ZhGrqUMrJZAcA2+oGU1zkKQQhh3CL02hvXkpmcxDTEyMEQwp5AvjOI7E6Fg/CC6KImDbDpZlUCoVWLv2DCory7SYY8eOoJUKJMcTtE+aQiAQYNqMWSQn+hEFk2gkzObNm7n8G9/hnC+dzUnL553gTXr47z3yyspKRFFk1oyZvPDGO0yePZe1a07jl7/8JZs3f8b8xUtAcOg6Nko+ZxJsD1FbGaOxIYLHk+e7132Z9tYONm9+jfbGapKJ4wRkg6NHepjWMRMbgexEmpSqEo2HEYUsE8l9hGtkLr5kJa+88i9KKQvHUBGCKo98cITt2nQ27VNYvnQ2Z82fSnakxIefPIKp6cyfPo3XXniOaH1VeWiX08kPDOMHcq+/zK7RMfY6IqHaBtpmTaGztx+9L4fWl8GsDWOpLi0tjezcuZPDR/YxY8YUbMukf2SITCZDLhciHo9TLBYwNY3e3l4wywg5r9fL8YEkkzqm4yIiSzIiUNIdsC0AisUiCxcuZNq0aYyM9uP1SSTHjmIYWjkCIDnGlVev4MYbBvns4884+/TrOXB4M8vnnYTkkQEZWRURBBnDyOEJxShpEh4khoeT5ZgDyUZWTTqmtCBK0DdhM7eiga7+JM3NzYiKygN//jEfvvMaR45sY8nyxfz5/r8Qi0VoaK+ivraO9vZ2Ah6ZSF0F5bt3LV5RpSE0E4QAEUckM/IJX1ownavPuxYEibVnncaCBQsZG+kHVcfUSuRSXuLVkMk6jI6P0NyyimlT6ti25UMefvhhZs2cSlt7B6lkjLnLa6mITkO051HXcpyzzj6Xc879KjVVHcyZsZznnnmat7Y9x6efbqalZSrdnX0IokXQHwN0LFfAdmwM28SjKOV764kN7zIorJyPICshXBwsC2RJxbJL2LaNR/V/vl7+/yPD/98+rutSU9dATXUdLz77EuvOXsus2TNJjo8yd+5c9hzqomPqFKoqYkiSRKlYBhAUimkkSSAUrMMj+RjoG2CsvRXL0WlubuaiL1/GKStO4/yvnMPGrR8wuP4I23e8xeuvPw22l2wuSSjoQVQsEFW6+3vAVSjlTSy7XN0F/BFS6QSxigbGkglM3UBWRBwHBMdGwkHXbUrJLGKDStwXpFE3iJsiaWwMBLKWg+H3IXt95PQsyomevSIISJjYrge/V8MXljBLRWynQMEy0ZGprJ3JXTdtYiybYNasJpIjKplsM9GKGLGqMWLVJoW0h4mxYXITGoIQoph1qK1RsSwZ0xCRBT/9Ayrb96R49PEhFi9r4cNXj2EVJCYtrSY6ZQn9ncPIWoZCYYSSlSIcMZnIjCLYJt2D7/H4U0eYP3ceubROqWQiqg66oaF4FGzbJhwJ4A94GR0dZemyxdx66y3E43G+9a1vcfLK5XQe7WHVqlMJhyvZ8PEmnnvhXyxcNIvKyhCpTJE333iXgD/Es888w9Jlc6iuqeS9PzwAQHVNDXPnzuXo4cN89cKL+MUddxKubuCuO3/DeacvIxaN0NPdScgfYKg/h0eN4/dDYuwwkzrylLITZAcO03WgE1PP8urLB5k9q4NctkQkEkM3obWtg9d2rkdWIvQcP4hu5Tg+2MmUvVMQPVNJdu/jmz+4EzEiYKZjxLTjrKwYY90lIf764L/49tOvcOllF3LF9V/HLyi8/dxLfLyhD388yGVf/zrjw2k2rP+MRUvnsadnhE+Pv83wnmNM6pjBjx/4L7wnreZrd9xC0O+j7ng3M6fMoa+/G1FyKJU0Bgb70YoFVFXG6/Xguja7d+9mvtePo6hMmzwZCZH/fO915syfTigSxbQlvJIXEwfXsfB6VIwTTMRcKQ+Sl6HhYQpFjWi0ikA4QGE0RXV1NdlslpZmmdPO+CofvPckL7/7BmcsWcgbb7zFOevOANHE6/OgIOL1qgyODeP3+kglR/H5fZjoWMjI3gBFC0oFjYjXJGcGqIvH8ftFjLxOIqVw6PAGbBdEQQbXpujC+PEculbgyL4uHMfC1B0cQ8ARTRxHBUViIpHkmqtu5OSVS7n0m//Bhk924Th5vnfDnTz/wgKyeZFjnX0oioLX42c85/Lyy/tZdNIkBvqPsumjp7nv/tu4+sp/K+f3uzJWxygCBRxrGNf1MTau8dKz3XzlnPnIYgSTcSRhKs8/9ylLVjTgODq5rIaLS8FwKRZLJLQigmvTXFMJSOBYlH3aNif0GwDHlkEUECUBhBIOEpKqkBjPfa5efiFEW5JlNm3ZyocbNrD27DO5/MrLuOWnP6OptYnxdIKW6jpOXX4KguvFdFMoqoRWylLI1xOOOUwMGkyMZ2lsrCVXSFFTG2fhwlncffevaGhoxKdUML11JaZhE42FCXjjpCZGiMdilAoZfH4PqZKFgoysWiiyD6tYxHEgl0+RSXrQSwbhQBDH7zI0MojrOCA62C7Ikgct6GBXBinmM5QEBWvEpOiBUUOiP6KySLMpCC5xf4h4PIZw9BiW41KujS1sJGzTxtQsZDFKNp1AUSo4fCiF7gp0TOpg+LgHVaqmqjpUJrGbLggloh4/midHTihf81wMwpEoji2RSedpaosz2B2l/1gEq7+bTcePI7ighG2Gd5vsHHiFWCxGIODDI3vRiiadhwf5959cy+9+8zxH9+ZoqhOZNNVDfX0j45ljhAJB9IhBoZCjUMhRKhXxej2USkVUVWLy5Emk01k8qp+CNk4kFkTXdaZOmcSpq5bT0FjD0d5e6puWIksis2bN4tl9r9De1o4ouaRS42glHVEs325CoQimXuLw/v0gCCxbPIfBwUEikQgRv5ecpiGLLrt2bQXA1HLIQhYnPUxhfJiVS2fjOgovv/ImixZMo6KikmAwSEkvMjJWYue+Q8SqG3AVgRmzFqLpOTZ+9hGjwwXmLohy190388zjfycQnoQj9FOKNfPbZ3qIN6lMOvlkvrVsKU7G4OhANwPFHKtOOQ1JUVm/dQMZ28EIStTWN3BkxzG8xQKe5hhLbrgaf0M974x3Mj6U5Oo5J5HKpBgjTa5YQhRlUhM5LrvsSl5+5Xk8Hg/FkkkgEKK6qoq5s2dQU1NFdVMzuWIBRRKYPK2V6upqSkaZSarhIOBScsqZ4Qhl4HBTdS3H+pI4toyNTbGoE/KHyPhKuIZFLBIlaZS46Y5vcqxrLxve+IyICpMaVbbs2c/py2diijaJbBpkkfbGGlxswoofr6yjuzaGXcRFIpEpkk5nicfjTPQnsUkhYBL11FLSBkmPB/D5VaprY6QyFv6gh5rmKKoURaAGEMlbAj7ZRcRCcJPgVvDw7+/n7lvP5Krv3Y0tppHcMRyhEdGt5xtfP5N4RYT4skU4JBHdah7/xxt8svll7nrgPd5+6T1q68NcdcVVWGY3OJVlGLNcAtvBkD2USjlqK6u57voZfOeGAiVXBNvBJ4hli7FjUSgZqAGFRCZF78gIJdehonoyNiUcsYSBDxGH8mhRBFxsyi9OQbRxXQEXCRcJSRJQRS+ypH+uXn4hRNs2LZobm5gxdRrvvLme0bFhzjnnHF5f/xqt7S2MDUzwHz++kVNOXYkoiiw/eR6jo8OEI376+3X+9fybNDc3Eq1dwMSOBK+89A5Hjx5HEEB0vUyZ3E7Ao5It5JEQaGisp6Z6PoLgcvnll/H0s//gkb+/jmmaiKJ64grjIEnl/pMoqHg9QcaHjmM5NqIgYOOUo1gBGZWYKOEd16Bg4hkao8NRiVgWJVyEnIPU6NISCrM7OYhHL1LAIqCXg+UdbCTbT0QNISoClhlidHicDz8o8NYr/Zx0HggpmXikDY+/hGBpGCUFn1yDqjiYwlFGEhlwQfVoaLpJbW0t2WyWgj6BIE5iZHAM3DE6pnsQXJFoYBL5YYGf3/4L4nUifYM96LoH28iSSo8yMT7MBWev5r/uf4rKSj9vv/MWQ092UhGvo7O3C1WVwTGorq6lrq4Vj1dEUSRqasoP2UMPPUShUGDnzt3Mn7WUvs4hfD4PQyPDfOva67jiG1fir4iRTYyyZMFc5s2fz7q1X6KkaZh2HtMQy+BjEZYuXYzP56G3bwBRkpk9dybfv+ZaduzeRXtdBZlUkmO9R3n9rZdxnPIcpL/3GI/+/ResXFZDfEygd99hPEqMH//oDl5f/xq9PX001nuorKmj6/heSppLpLKWvJni0NFDyIJKS8MiRkeSfLZxO+edex5/vud6SnaK/IBLdZPMxRe00tbhYeOmXUyNn0PSGcauq6GQDqJYLlm3xNLTViGHw+iBANPWnsHbr75F3bIvEY9Wsu2Dz6hsTrGmaQ6IAp8kehkbGmZeRzO5bIlUKoXfH+KuO+9h4YK52JZJRYUfr+oSiISZMmMGlfW1VFRVEfOHcRyD+toGaqtr8Ieq8UtBHFdEEAJ4ZR8CIlmn3B450n2MaZNncOBgF5l0nng0TskoYTsGQb+f0bEJJjdGmDN7KjX1NaSyQ/z1wX9w00+bGBiKsOmgypJZM4mEXcZzOl0D/diGwOz2RjRDIKhKmGb5AAuFJOGQD8V1UUXw+qMIooOtuyiKD4+qnphJlAAFswCurmG6Fl7Vg+3a6JaNL+zFVEeQxQKyp4EvnXEusXiRa6Qw2dwx9u7ZyaEjnVx19U08+OfnaGiK88u7ryfsn8qnH27jb0+s56RFF/Hco1v5w7234ZR0dPNDPJ44ph4BMYih1aGVBGzRQJQUxtJJFK8HzYGDvb3UNNThdSUqIz5ECvhUCdu2iIf9RCNzSBY0erIm8UgFIkUUFBShhH2iQHMEF8E94XoT7BNlt3hiS1LEHxHQjP8HBpGiKBL0lcNdrrz6m0ya1MZz/3wGSVSYMWsOO7Y+xZnr1vKHP/6SaZOXgCBg2hO8/OrzjCXHSZ2ZJTmaJBiO8c/HX6bryACVlUG+dskFVMTDTKTzzJk7A1GyaWhoIDEySi47galrtLfV86Mf/ZC/PfLK/7gcfD4fWilb5laKIh6PD0XxoHo9KK6LpmlIQnka7LgOQ0aehKkidCepMC3csI9MOk3mBIPOlESkeCW5kRE03SaX15EFCPsiBItlHFHRFbBEmUxihLrKIENjEV58aBgUmVrpNHTFhxT1kyuUyOVzpMczBEMqrhTAcSRcW0UUdVRVRtdNjJJDMBhELxik0xM0tbbQ1jCZrqObyOUKDGkDYDv85LafcNsdP6Kz8zjBYDW6nsFxBIaSJY50JzFckZkL65mkxUhlprFw8QIaW8LkshqmM04s4kfXdbZu3Uk+V+DQoSNks+nyhF9RkCUFQXTIpopMTKT5+mWXkEiMgABzps+m59hxrvjGRSSSA3T1HCUSieDzedi750DZ+unaeH0KeimPLMvYuEyb2kYkbDF0fB9WvhLbMDl27BgH9+0BN4EgZujrfAfVTrDtwyMUi3kWLFjCooUn8f77m0iMjBL2B5g8aTL79+8jNTZBPF7F2Eh/+exzJsVihqWLFyJ7XZLpDG++8RKXXPoVnnn0r1x+1b9RV+ljsD9F9ZSZtM0IoQckfEIrQq4Thyy6KRKNRLDSBrqbIb60kqGGZs65/npG+gaI1VTxvYvXUV9fz84t2xkbHKWY1fF6/BRzeSpjVSTHEkSjMZqbmti2fRuV8Upkj02ovZ2SDm+98wm5QhaPz0dbUyuOY+HYBppu4gg+YrWNzFt8CpXV1fzr+edZu/oM6mvjhIGOaTNwLWhoaKCzp5tSUSMSDZFIjmJaNoqioGs5Ir4oFRUVNLbPQdM0dh3sIR6uYMfYODMaWvBHPQRVHY80gezxk+m1KQkjCIDfF8SybMSsgc8XQBVMwpKAT5GJxoIYuouqKiiqUM5qt11cx6VQSDOW0qmIBBkbGcJ2HXxRP7IDfsfFtVze++Ahzlh1HZZu0dk9D8spsHTFxSxbrpb97IkCQ8M53ng7wUuv/AWQWLxgNh9/+iSbd/yLs85eAWovdqGEKyrIShGEAF6fF79HKlcLuDimBKJEemCQumAAQRBQghFGc2miHpeQ4kNRTWzbBlenIuClOzmOaQloSNiIBAUfoOEILqJ7wqjllmtuBBHBAccpw6L9QR+m/v9AT9s0DbK5NEuXLuHPv7ufBYsXUlXTQKCU5ZOPPqWyqgpXcOg5dpTd23dw5WU/4E8P/ghvqApBcInFK+ns6md4JMlVV1/OvJmTGR0cQtfLVBRZAV9YplTQ6B/oJhQKoU+UqG2o5U9//jWSxwsC5ApZbAOE/2v133VdNE2nY0odxw4exnVdLMsoi7br4AC6IjBcKVOoraKklxjbO0AlEgXHJiyI+HQb1TDwqDK2roEkYIuQMvLokkQJG1vUQbDx+OBA9zDDAylaJjdjFCz2ftpJLq1xyqqVLFx+Bj39RxFQKJayVNfEefyxZ0mMZxBEsDTKNwM1zpSpTTz/+gtMmTqV/u5++g+fyHt0RSQ5j+OKSIVxrv32jzhp6TIu+MrpSHIEV8iSK2SJx6u48JLzkUSbjz98F1GyWLFyIZY+XvZUNzVz2sq1ZDI5xscT5e06s4RpmjiOhSiKiFI5Jyc5MUqhkCMxMc7kaVO46Zaf8PgjL7Bk8al8uuEQNTUB/H4TxWOx8dNtvP/ee7guxKviSJKLJFsguqSzGRrqKlAliaWLFvPCC69TKBTTlZJhAAAgAElEQVTwBRXuuPN+eo5v4I6b7qauAhrirRwb6EHxqIxmS/zlsceJBirIaXn27+8kWBGldcpkRsYzpHMFamNVFAs2aliltb2FPQd3MaltCh6pQKQigtfjZ+/bT3Bv18f865MPue3O3/Kf975O7RRYt2IdhWyRqKJjBQXESBBVksn29TF/0Wzqm2o4ePAA6cQ4e7sOUJWO0dpRw6OPvsVPf3ILtZO6OHTgON1dR0kI4xRNi1gsRkVFHElSePfd9diOyY0//B5tHW3MWzAfyzAZ6DvO4mWLcXSbnbu20t9/nK7uXpafvIrmqXPYtGkzK085g1WnruHqK6/ENW32A/947Ak6micRDIXwSAK2Y1BTHWdoaABbN9BNB59HwStRXmzq7yIcqmLj+nfZtfE1bv/Vbbz2zvNUVU+jItJKdfU8UuOjhKoSCEaAYqlAIOAjl58gFq9A04pge7FNHRwF0VVx7SIiKoIt4Noirm0juDZV8SiSaBANq8iqiqBI2AIEPRaIAcxMjtUrz8XJdyEqPmZOnUI0MhVXUJg9r5lrrrmM5Ysv4uprr2FodIQbvvcTEF2s/CCyW+S+++5k+eLTyWReIeCPYbtZZNEHGNiWiSl6sGwdwXVQJQUXl/qWNnQEenNJ0noGJBNTldAEUBwbWZIQbLBwcM0cuZyJaMiE/B7Cqh9B/N9mtiAIOLgI/xPYLiAi4roygizh81Z+rl5+IUQbAcbHE2zcuIkZM6Yyd+5ctm3fjoCD3+vl6NGj1NdXMm/+QmxHJxy3SCRTzGudQ/eeTXhUHw0NdeTzWYJBH0ODfaQm8tTWxRlLjRKJBPF7A+jFPJbtkM2mqaurI5UaxxFg/px5iNLzuK6A1+tjYiJ1Yk23XE1HIhFkWcXj82EY5T6rgIvjCriiiGrYhAsmwngG2bSoDocZ08aQgJLrkMOi0RtE0i0E00QbSeC6oIgSjl2u7kUVHNclkUxRGY9SU92AXfSSt4dITeTQdZNNm7eRzuYQRQgEAhQKOTyKxNhwAlEA2wbDNUAQ+PDDj9i8RcQb8YEjMH/RfArJIiPJIbITGVwXJEEmmy4hAJu3fMrUac2cdc7ZHD66i82fbWVk8A4GB0cIBJvJZ0dYtfZk8vlG+rq66OvtYnigj9dff5OAP0hbeyvRcJyh0W6KxQK6rmOYGoahgatSVx/D61XJZrMUi0UcYHDwOKXZWTZuPMjXv3YRFXETXJne3l5KRRNBlKmqrMMwLIKo5PN5DM1kcnsHf3nwb8ycMYfbf34Xf/nLA6h+gR073+Wxv77LjPZmfGqEw8f2kclk0TQN3XHLQf6Wh7HRCWbPmo7P56O7q5dUKoOqqsSr46SO9RPwefD7fXi9fo4ePciSZSexdcsOHMehqnEGqUyBSREvD//8+/yosI+mydMoiEFStoMm55B9MnZJQ1RUggGF472d5I0sJVejtq2Bs2urCQb99Az1k8ilGcqM4/XI5EtFgrEI2WyKyniIgeP9pDN5kskkTU1NFItFQpEYg0MjuMJOouEomzZvpmegl47WJkTRpVgymTZ1NvGKet547VVOPvUMRgd7aWyo5yvnn8Oklna47BPOXnMag31DhEN+sikB17Hw+XxEwyFKhRKWYyOLKoIDtdV1SKEmssMa7afU88GWt/lg004mdTTTUnQ5nD/Gjd+9gpp4DEQTwREQhAqsE6CEoD+AKiuIsoThaIiSRL5QwjQtHEookgoIWKaIaZpMpJKkUiUKuSCW6eAKIobgolWq1IVlBCWImdtFKi3TveNT/vrIn3jqqd/R0DCdWGUApDhjyV5uuflm+ntT/P2xR4jF/WzdtoHtmw+wfNmpFLIbiYQbAB3HErBMB1mxkOQoAgK2YyGIMiZlMLqNWY4v9vgoShYmMoYgUsIEUcB1bSzbxZFcGmtrUBUvAdHBo0gItguuW/Zl/9+UdVf43+3Isgrg9/vRNedz5fILIdqiWJ5AX3zRhTz26JO88cZrjA0lqKuvRpLhtNUnU1dXw7MvP8/smbMYToxy6Mgh/v7E48iyzJFDXfR09rD6lJM5cqSTr170ZXANeroOYVkG8xYu4uixLnL5cSoiUXTdQJFh8pQ29h8q0tvfiyjZGLpNoZg+cS0vm+IBMpkMQ0ND5ZQ6ScJxHERZxKG8KK6rLjHNj6DIWKJEwHIJoNCIRBqNlCRg1dQSjVYwvmMriurHcgVEj59qr8uwlsO1JHqHR1nYPpV0zuLovt0IroyLBZKIbDskkxk6j/WwaMEcGhsbyWfyBH1+omEf+ayN45ZHmqqkcNnXLwXB4MlnnuXdV94jEI4zOpaiubEFrEGqamvo7erk29+6lsHBQfx+P9mcwc9v/RWqV6GleQqablERr+LwoX2EY1GmT59OvlAgGgqz+ow1KGIAUfBw6NAhHKtERSzCzDlrgPJCVEkrAGBYMJEs97RlBPR8BsEo0NZaz3nnrmHV6oXc+5v/pLq2hT/8/gEO7x/m0MEeHnnkMXRdp2QmEUSF6niYylglV33z23y0cQt//esjvPfRNmprq+nsPoJgipy/ainFksNnn7yH3xvDdAU0EyQ1xMCxTmQ3QMAfpvNYDwF/FEGQqK2pR1EUDh46SmtrK+PpFJ09PQioeJUAer7I2jWreeaZZzhpyTw65rbR032ckfEc9/3hRe666yaikollZ7AEl7xjI3u92LLKWDJJfVM7c6fNZ+emA8ydOYedO3dSyOfwCiqLZ89j3pQO9u/vpiIeYXBPJ4VsjlwgT9ESEBWRWCxOMFJNY3MTS5YvKIM3Tj+bQMCHrHhQPTKOZeO4JotOWozfG6P7eB9TJk/l8P599Pf00tvdRffRIxzpPMYVwMy2Jp576VW6OssJhrpRZMqUSbR3TObwvkMUCgUk20EUIVYTIdMj0N27n94j+/jODx/i8acexRffxjWXnslJS07h0UeeYvrCRbTVVJKxQMUgOZGkrq6G0YkxNE3Ddi1M0yBg+ZFEGVMv2wt9Ph+CIJTbjpKApIhUVAeIRULICoiSjI6LaxUBDds1MPUU1bW15H17uPPedVhCEk0/jCi3sXnrJnZt6WR0JMMbb61HUC2q4tWcumoBWzfspaQ9Q8DXQik3gdfrQ8DBdUxQRHQ0DMclZxVwxRPVsOlSsl1Ur49iIY9u2qg+P2lLxxuWCYgSkuuiqOWWSlPAA5T7IIJt47oOLjaiIOPwv35tARDcclphecZZ4Pprr+dnN9/9uXr5hRBt1wVJknj55ZdZsGAB06ZNRysWePTRR7n55p/y2fbPwHU4fPggI0ODbN22id7jx6ltqGfHrp2sf+lTfEE/xjIDr1elpKVxbQcEh7r6aor5FAG/TG3lFObMmUOpVKKvr49MJkM6VaChrgPLBL8vTFNjiOHhYSzHQBREHMfBcZxyj8808XlURFHEdV1kUUL6P+y9d5ilVZn2+1tv3DlV1a7YFTpVZ7ppoBtoGqQbFEQRIyIgOqOOOuYE6Iw60XFGR0R0TAh8ICMoCq2EJkjOnXOs7sp5573fvL4/3gL9HMN35jtzzpzrOuuvut7atXftqv3e61n3cz/37YHjeXiupDXfSWs6yf0Tw8xoCsWYRsWGhC64b2KEWavBaDaDsaiXE5Mj7JmeYiTwUQQ4ro1uqowMj3HBBa9DBgpDg2NYtSq5RAQjFqOzrRvXszlw6BDj4xNcfvnlFAqz1KoN3HB/QRUa0Wgcx3FwnDqdXd3IQGFkbAKr4XJy8AR2vUG5VAYBU1NTNDc3U63WaGlpZdPmTqIxE6Eoc7aaOhMT03R1dzMyOY7nBLTmOzBNk1KhTDqts+Gc09EUSbVSYmp6mlqthu2EXguOYxFIF90Az3cpV2qUKg5oaVauXQXRKk1tXURyNnv2HObC117Mzbfcypsvu5xCsUx/fz+Hj00ihOCUU07hwQcfZP+hPRTKVYZGx9m99wimqdPSmkCjTHZ5nErVRQaCRDpFpVImCBpMTU6Sz+dRDRNPwuKly5iaKRCLJVi0aBFPP/0MC3r7yDY34fgegQ+aojAwPUNssgxmmvXr1nFw11NEBwYx091UfY1IJsuytetJNrfR0ZWn5qpUqwExBWSgMjtR4ejRo2y+8Fwef/RJEPDpT17P4cOHuO++nwEwOT7M3/z9VxBC0Ne7iF07xhgbH6aptZ3jx4+zeMky+lcsIxaLUanW6Zvfw89/cR+rV69ieGyU1uYWFBUSySiKolGzbNo7uvA8SWdnJ6pQaDptDU3p0DiNO27nfe99D+lEnCDwSKaaMKMmlmVRr1RJJBJhA37upBmNRjEMg9nZIogIH/nI2zkyWuW5+7/P+ITD9pefZdWyZezYvpWuN7yNTDTJ7FSJjo42kqk4paJNNpbCMAzq9Tq5dCqctVDmqONgrtxUMryiy7eCAFNR8AIbX/r4UiIDB9BBeMT0JpypBoGSo1Jy0RMxMpklTI0GPPnQAFHd4O4f383Q6BDnbV7H/Q89wK+21EHswJRxUDyiZgxJEHr2i3AG2HNshGoQESGvLebUNhldR2gaqYSB50tCyz6IqiqadFEUCOakfeFTKa9W1XPw/HtwL6zABfJVnGlpaUL6/59oRKpoaowVy1dz5NAhkvEoPd1dmJrEqhcwFI/CzCjvuuJyggDy+Txnnnkm0Vic5mwTv/rp0zSlU7S05Dl+/Di2L4jpEcYnijRn4xRni2RSLcwWJhkaGiIeT/Lciy8BUKvVOHhwP6YJUloUCjVUVQ3/MSL8AE3NTpLOZVBUQVtnB9VqmPrsWDbEoszvWsivXItvPPNzTAcu2LyBkZ0WtpS88/WXs3/fHr5XmSKaSzMQM3luYozz3nU1mY5WXNulWC4RUMNqVPnFT+7j0ceeZej4ON3z+hgsn+DSt74dQcDo2BRCBvT19SBR+OaN38H3XXwfstkshWKBDeecx3nnncfxgQPk8u1cckkP0UgCRYuhahp+4KKrBoZuYts2M1OTmKZJm9BRtAhBIMOwXUXB8V38QBDLNFGuuyQTTaFOvlpBURTaOyJ4foWG00AEEsu1SCQNkikT27FwXRfbNvE8b67R5OP7DoF0USmzaKHB9PghBk+8xLe//gMufcsbMQyTybGtHDp0hKuufjvPv/AsixYtoFCcYdMFr2Prg8/hSZWu7mUcOjJBrqmJdetOoSkHlcIgE8N7KFUaxGIpCsUyvi9ZvmwVpVKJw4cPk+/oIR7Pomkx8q0ZmpubmS0UWbJ0KfFEDCNi0NTcjO14LOhbyIJFizi8dw/7dr5E0wUXseTMN9OSb6I0uofe9i4Gn32QT7z/IwgtTTQSRdUdMtk4qZhJPBFBejqLF68gqke4++6t/I87bufppx5neHiQm779bT74Fx9EEQb79p9gZqaGxCeeTFEul3nThjNJpeLM65lPtW7TaDQYODHC5FSBWDyCH+zi4osuxPVs8i1ZgsBHSqjXCY/qvoJhmDQcG6fRoH9Fiu/d9K8AfP/7t/Gxz/41A88+TSA1KEnWn7GOnaMzxONJapUyCIUgkHR2trN/n4uiqAg8+jtbeeAnnyfGdQjzbNBt/vIDNZaesoBnX/wls5Ow+bxzaWlpw/clTZk0iIBKpUI6GUPTAwJZA+GHgkRBWCDJELh836fmeXimhqYIECqKMEEVBBL0RISJ8QMEjkEytZKY0cTeA+M88/KP0ZQ4e/dv48Etd3PllVdy7MQR1q5ZzH2/vB/ETmSgEKhZFNUAVSLwEKgofji1GDMi+OjE1BCshVSQiiTAR8gAU1eQmnglOhRdvuL/IBEyIGx1hdd+Q4UoSKGGPIuc02sDSBVF+IBEUUBBobMrRfDH2RGElH8c1f+fWPm2VvmOd11OZ0cHN//gu2zedC6F4iTdXZ189jMfY3xqnJmZGQrFKidPnqQ0W+HIkSMEAXR1ddHe1s309CzzF89jYnqKRUv6SMV1zjv7fLb84i6amnKvmu9Yjk0qlSJAYefuXaiKxtjYGI88/AyOo+B7GmOjE7huBT8I/7jxdIJUMoMvA9LpNJVKDcdxUFDJZVtobm6mv38pbtJH+A4xLYYbhP90ouEO3C4yNGybmBHDcmyiqkKtUSduBJiGQT2w8VUVIxJhanwSq+7T1dlHELgksyrD0zNkjQR1q0EtcFF8QSIeRREaC+fPZ7ZYJpNtYseuvbi2zYKF3dhWmagRRREGDddHj2qhD0KghHkeiiAZiSCEwJdg+wFCChxXIFDwAg9NV6g2yggZENFDnaqq6mGz0QvT5l3PRpEBtm1jGAZASC2JMAnF9/2wcgOKs2V6exbhOCp1Z5DDR/bx8AO7URR43cUX0dnZSb1eRjcULLtKT083sViMSCyJJgyOHJlAMVUi8Ri7d+/HKlVZ0NdKzChi10fwChNMzxSoFupokSjtrR3Mzk7TnEuwaFE/x4YnQVE5evQonufx1re+Fcuqo+s68+fPx/fCSVpF6GTSLYwMjXLg2BFWrl5Oey5FvAGe6mN2tOBocTSzg9PXnkF59DBj08MUSzMQgI/Ac1y2bdvFY088SzzZwd79x+nu7uH811xILG5w07duABHwzPPPs3/fMZ5++mWOHj1KNhtnZOQks7USf/2Fv2J6YhLbF8TTWZpyLdhOA9cNNfLpZJSGVaettYkgcHAcD9/TqDdcPGnjBQGGmaJSqdLZ1U00Gufy157Nd2+/D8ezmZ2dxlDB0HTGhieIxRI05bMI4fO+915KVMnykwf2c+O3PsPMRIkDLz9OtVEjHtWoWz6xaIr7H9nPhz73WQYPPMlHPvJWTu1fSb5rHlbDoa2ti7PWbSAI4OjxQxhGhHx7HtezQAk3FqFIhBBomgYEob7cBVWR+IGNIgw0PYkW+Bgi9PRo8Gt8t5n928bZtn0frW293PCtr+F5Hv1LljE7PsW2l17i4a2Ps3iph++bKNg07FkgjpQeEhehBAhU4tEehJYhCKJIRZ2jLl6ZYpQIfOZKcmQQzI29awRC8gqGChF6BylzWB1mmivIQAGhzjn8BRCmV6KgQ+AgUAkUFy/wmZ4RnHPGhzh28i4EbJNSnva7ePnfotKWQUA2m2Xfvn3Mnz8fIQQzM1PM75vH4YMHyHe2Mjs7SzyRYf78+ay5bA2OHaoTisUiA8eHcRyHbdtfYnB4lMGR46hC4fZb7uHxR+9n4YIeVq1czaWXvoUDL7zAurPOZGa2AFJQKpWwLIuWfJ6B46Nkm5pYvmoFmhIwPjFEqVRCNyP4vqS5pYVcSzO5XB5Dj9DR2o7vuQSuT23GQooAGZGoMkAxo8TNCBW/TCwVI6YkSEcNKpOzeLqPqmpoho+e1VGkJOpHKJYq6E6Dvp6FGHqMVLIFhMeJ4X1EUfENlVg0TczzMY0olmNTqzU4NjBAMp1icHSQjrY2Wlpa8LBJyNhcbp6O7vtU7RrRWIxKqUoyFcV1bVy7gaIoGNEINaeOlAJFNYlEQymhqgq0aApVAVPxEFKiqzGCAHzfxTTCIGZNCd3kHNeaA+mQUrIsCz+wqVarFIuzTJfG6NF66OnsoVz16Z43n9XLL6ZRg+6FHWHat+GDcOnobMKy60yMTOFLQbFSZnqmwNj0OOW6zfDQGCsW9hF4Li1tCfx4jr0DR3F8D10zSSSTTExMoCJZvGAhgR/Q0dHFjp27SaeydHf3Yls+1YpFSz5Oo2Fj6AqTk5O0NLcRi8XQFZVKYYaXn3+Gcze+hlh8HlV/ghU9aSyrgSt80nEox9qYqc+gCgNkCd+tEVEM1q1fw6lr17J77xDtHb1k0jke3no/mUyaS97wBizL4p1vfxeZXCuGGWXFihVYtVn65ndRP1DEdkvUgzKmkaNaKlOpVKjX6yQSCXzfo1KaIZGMMzkxjWVXw83U16nVLVwHsk0tDBw7iqqbHDgwgJZMcDmw79AR6pUKqXSMU1etYNXKlSSiKYaGhjg6cBCEFw6bBNDS0kogBWYshiM1fM3AdUaJiSYKBGw8axFjEzVOPf0ibvzaLXziE9ewUgvo7Z1PIqHw7HNP0N7eRU/3PEwjRqVWJxFL4vgBummi/mZGED/wUYRCxa3jC59IJI5QVGzfR6gaAoFTrDIxnWF8pMrLO6dQlDy33fZTJsddNp6ziR3b9vDStieolaaJJRQCsRfHHkY3csSTOaQUiCCN0GqADVLiex6qlHMg7YdeopK5/EkfoSqhX4gAoSoEc7QGc5W2FCGxE/wWExJ+PwRqgfp7sU+8sjsQgr6uSnTtj7v8/beotJtbmuSV73knju3xqy1buOKKy4nGNN599ZVc9uZL+Nq/fJ1HHnmEarXK4sWL+dEtN5PNZrnxxhuxLYex8WnGxiZ47rlnOHnyJBs3nIsXBPzg+7cwr3Mx2SZYfcpymrIdbNnyAB/56PvpnJfC8wV3/fRh4vEmCsWAlaes4omnHmHdunVMjI9AUEZXw5ggw4jgouD5ArQIumqg+BIzohCLRgmkZLZaIxqJgycRwkdTFVynTixukDAjKIqKZzs0Gg0830XTFKKpBBEFZlXw6y5NJQdbVRi1Lbx0lLjvscT3kTLNM2kLzfZZWhJUAkEpl0WXkhYRMEGduKrSpCdIJpPIaARUjUbdwXdcvMAjGjewxl18RacWmSGiBMSEhTpdRfEM9llV/FKNslVH102qVgPL9WgEHp7VwPB8DE3l8OGD9PT0UCwWcb0GmUwG17bD+CfVIBKJYNs1cs1N1Gsui/tXkkpmGZlscPBomdnpKYZHJihVrNCpLhInEU/hyyr5liZasxG6uppJJMD1LLQoRGIxkqkcbfl2vFqab950M5e87c1kMlVkeZDdD3yLRrFApabQ3JqlUvGImhESzS0ojkMynUS4LuONKgpR6nUbIeLhyUMXRKMmffO6qJTLDI0M0t7RQeC7tLd3ElF1EvE4wydPUG/UWLNmJel4msnpKc6/5BIODQxw/qVv44EHtzJdHgdXEhEJNEWhXDxIOpsmrmY5WdrPdMGmr3cl6VQztWmVRkPnR7fdwfMvPMn3f3Qvf/WZD3DB+Z/lF/c8TSU4RCoT5c/+7kN4jQIJYXLy0E42bdrEkqULiZkRPNfGc1yKlTKRSIzybBnbtsnmU7TnWzi0bzeRiIEUMkxFFxpvuvASHn34AdRIHF03cYTC4UP7ec3mN1CqVRkaO8LUeIkPvPUypAjYtbfCO676c5q6ojz789uougHxSIPAsVD1HLYVIGOSnbuGOXPNxSxeaXLk0AFOX9dL/7I+Xv+6M2nPtXLqik2Mjdr4tFCtQ2DYSBklGrFoyqepOXVyzTkCAfXZSXRdpSnZhmVPk45mCaTN/v37OXLsMAcPD6CqCt/9t1s4OXiMt7zxal547jFGhk/ywovbWHvaSgLvYQQtBKIEno4MXGQQ5nIG0kWTUaSnI9UGvhpFj85DBi1hSAEWSBOEC1IF/jBn8b8oQn5nhaAvUVQR4jvMibQFoKEodcDD99qQSolKWXDeeR9l165b/3tX2kIRof2qptPb28uWLVtYd8Yajhw5wimnnMLU9CSZbJpEMs6Gc85m165dbNmyhaZcnoGBgVcbJr29veRyOcbGxvED8LyA7du309YeY2xshE3nXcTOnTs5dmwALdJJLJoinkyhoLBixRKk9KlUKgwMDJCIR0gmsxiaiq6b6LpOzfFw/QDP11BVlYgWNkVE4OP7AfFoFHwfSYDvOchAQVHCEIeZmRkikQiqEGi6ihkxwuNU3aaiSiJmhEQqizRtDM9goRGnXG9gJjVqSYibKZYLH1NVaBmuUHUCgoSBKj38SplIxATPo1qrUSqXOTk2gq8oOJaL17BxXZcZ32FhLUZV9zkRjOFHDY4//DCR9lb6F6+kM5sLpyWbmqjX60SkQtyMkjSjRCIRGoFNNB5l+cqVJFJJorpCJGqExz5fRdMVGvUSruvjeh6trW3k890c2H+Mr3/jJqQSp9zQkX5AMp2hORJB10xcN9z84olWAt/jwIHDyMDhXVe+iUjEYGJ2lHg8TjqbJaKbfP6z/8KefbuIpBTee81FFKYazI5Pko2ZjNs2arFMMpNncmICNZ4Ax+a0M89gbGiQqck6BFCtV8hkk8zrmMfhowcxIip7D+zCtT06OzuJRA10PY6ihI04RQlv9lgsxv79B9l8/iaC6UlQBJ2dnYyND3Peazay5ZdbiUQUhO9gaAb5ljMo1waxjCSivI7FC8/klw8N8/AjT1AtTKHqDo1SG0rm/XzkS9tonfde/uzLl1DPvszt//w4X/v2z/jCh/+Gb/7ox4zO7KKtrY0FCxZg1eo0ZbKosTiVaon2RJx63SIajxEEAbfddhuZZIKLL9xEpVIiIEA1DLw5w6jB4SH2HQwzVftXrSEWi/Ho1kcYm56ge2EbhhGduzvDE5PrumhaMrTSCMLGmaIoof5Z95gYVVh/Si/f/c53uPaLN7Jy0QK27XyUfftOMjUyy7nnnsdLL42w+tR+Tlm1kQ7DIJnIzr1GDj+QBEJHERAECplcJ6oKMrDJxJrxggmOHR3goYceoLl5HoMDwzz04MPMVoa48MILOXp0N0MjJ/ny336KVcubKVXuJh2bRxCMI/woipBIVUUKBUXXUAIJ3hzgCjHnPfIfC9jfmDz94fX7Ct/fBvJXKJbf14z83RUO8/3XpbH/37bCgRWLQDpEogoIj/0H9vLhDz/JX/7lh9iy5V6KxSJDQ0MsWriY9/35h7n4orcwNjrN6MgUpXKVgYETHDiwl1qtwfDQBGedtR5VMZg3L0+5MgXEODk4RktLC//wD//At7/3LX79xBMoejPr16+ns7OL/v5+Hnjol+ENqhsomoKhG+FNq2mkcwlc3ws5aTNCIh5FSg81UIlEYszMTOH5NolEBFU3aNRdZqarANiNBrVKiboTmsHUqnV836duuVQaFu2OgVQEE1mFgqqgeirdkSb8Sp1UIk7KCzDbTQLXQU+2IjGo1RQaIqDJD1CMCFEzQonGKGQAACAASURBVDSioKsanV15fBnQKBdIRqNMNY5RZ5zg2YM4w0XOqXpYQzPMFIpEsy0stKP84+33sm7VGs5/30YmrAoD1QK+Kphp1KgFAVk1iVWzqU0Xuf32O7HqJb70xX+kUqnQNS9LvVECU2H58pXcduvd/Pzvvo3d0OjsWoiqd6OoOk1RD9u2IXDRNFCETSBdqtUypaKBVasi8Ni9+zjPffjzEPjYfgPbauDXi6gxg6ambtoz7bz08GN85XPv4tio5PQl8ymPjzOSTlCuNXDVBun2Vg4PDtCWb6WKx8niFKlsioHjw+RaMsQTEUYnTtC3qAtVV+jsWEZ9tkJxtkS9WqV3fh9Hjxxi3alnhHFd0QgXbr4A3/c5fvwoMSPCL356D13zFzJf04lFYhgyiiZUXNGg3ChSJ0uxluSc017P5W86n9dtOIsHnvgRvrKRv/rk9Tz04Hbe8Jencv2nP4WayjM0UWNh3xeQ9hAfyXyDdrOVIHiRj7zj49x014/4wKc/y8TEGOdvPIeBgQF8GRCPxzFNk5GRMVKpDLbrcN3nrsW26kyOjOB5Hq7voXmhux/AmrWnsOnCi9mxazemGWXjuedTq8BX/ukfWLJ0PtVG2M+RSHJNMap1i3gyyUTNIZEwUNHxAw8Ci5geQ1Emschz1iXLmfnAXTz6671cdY3J7Pg41Vobt935CAe3HyASt7js0jcj8dH0Ep3daRTNJpVK0N2+FFUm0DSDsdmXadQE+/fUGD4xgfTSTE4X2LP/Zbra2nnzW9/Jueeezh23HGPb80+zbcdustEAzztItbqTbK4b6dsEQQLV9PD9AN928AMFPfBDPtsXKDIM3pWoIF0gmOOmJcor6g/x+9Uf/zvrVfB+1av+N1//L1gvJCDRdX3OCuIPr/8WoK3M7UTNrc38+M7bWbduHW2tzTz26OM8+uivqdVnaTQanHPOuTz//PO8+bJ3cfpaja//69eZmpqiUqsCAZblsHbtWt7+tsWcOHGCTCY8ui1bupp4WufFl18kGTNRFLjj9jtJZ9tYu+5UZmZmKBaLPPDA/axatYqmpiYQci7fUMe1HarVKrVqA8t1qNVDg6RqtYzdqFCvuKhCoEiPAI+jAwcI0HAd6OtbjqHpRMxwN1fNADMaQSo+kYhBV3svQgrUXBIpJMtNEwMF1feJmjrRSJyWTJ6EVyNuzzDTqFI5MgaBSc/ihZQ0iVa00WNRhARTUbEaDRr1MqoGlclRbKFS+9VDrLJgty7p6umir7ONYm+JzR/8IGqxzjN3/IK3XXMFwwND3Hb3j+lfs5q1Z53J4aNHeePmTYyPjBL4PkJRqMuApatXMXTsELoevq+DB4+i6yoXX/p6vvfdm7n51n8nk87TNW8+uhHHcZRXB4r0RIJ6rUHghRRRLKLh+FCariGlTzqdxHMsctlmbNsmZWTwXYdsth/PbzAxVkLTLeIJk0N7dtPZ3ISf7yClqBwYKhARBsNT03RG2si3dyDVUNpYrlSIaRrtTc3ousHk1ATrzz6LYq2ElD7F2WnGBkdJJ3I4jsPjjz9OOpWgXqvQlMmSiIQj5ulkmnM3nMvg4CDixEkqs0WmJ2dYMH8xM4Uh4rEUjuugGi5avUKzmeDPrrqK557ewrqzF+PiI4jz5MHtJHp1cvM6kVoMNbDobU1RKH6Lf7vxWQoVg/7+Mlu+/x3WLu/jE3/xPl7as4tPf/LjPPbYY6RSKXr6el/ty/T19VG3nLCZPTUVNuwaDdrb29E0DcfxaFhhlNWyZcsYHpmhVKnxt1/4MtsO7uSuf/8V9/7sXt74losZGz4ZNtxUgW5AEIQnScsNSAKg4UuBroDAY3J2mtZ8Hr8xzY6TBTaft4rHHv9HHnpiH9d/4FZa84vY9LplVOtHuPPun6FrUbLpOKYZpz3ThqqWSSbGcdwaoDAxXaDh2IyPTWNGA6plwcIlbXzi49dRmC5zy63fpVKpseVXd7Pu9M00tWgMHXmQ5nQOLWKHhvJCBWkjXROhRNF1iS61Oc8sAYEOnhIyFQqvzJYDf5zy+K9cqqoSjUb/6GP+W4A2QiGZzlCpVUmkUpSrVVasWE5rezuqGqWpuRXLsli0aDmaZnDhay/i0Uee4pOf/Bi5XI5kOhOO/GbTHD12mJ///Oe88Y1vpFZtkEymOTE4RrUxzYolPUyOHefMM9ZAINizez/bdg/y0Y9+CENVGThxEkU32LV/L91d8zAUMBRBMhVFjxgkzCjN2QT9C+cxMHCMx/buoH9ZP10dMaxqjZZMigCX9s4M5UqNru4F9HQvplau0dPdQTQWI5ZOMlsqhskuQlCaKuNYdWZPHsex6midHSxenKE1qqAP7KFyYJTC3jGUiEt1+iBL155GtnMZL2/fjtcZoyACVLJ49SpBEGA7HiKQ1L0qrlOnMTSIEficVi+xYN9RMqctZ3b3dpqrAY3CKD1XXcxN372dY0eGufqHN7FoUT9qJsVLO7ZTL1QwULjjxu9S910++aXP40gPP7CRfsCGM1djaCqmkaCjrY9//fq36e/byBlnbmB+3xpSyRzFUh3PrjFTLBGJRBAlie/7JFIJbMemYdXJt7UQ1yKYqhoO5dh1LK/BTKGAY9ksWNiD5SvMFko4dgVFGtRLDWK6yV//zRe5+q0XszyZoBEUMWwBuk4ul6EwOYsRjaFGdY7tPkQ6HkOeKHDRps10dszjwIkB9u09RKwlzfETx5C6Tl/PfIqFCs35PPPnzyfwfcZHxjl+4CivOWcj3R1dCCFobmonk8wzMV5k8PhhTj3rHLbefz+VWpl77/sVQQCWVaPScDm0Y4zZmVF+/YtvcHSqnXu3PE7Zl5yvZLjyAx/Amqyw45Yf85kvf5kvf/haBmdf5tZf3cMNP9jL5k0f45NvvggzuYOzN72eh1/Yzv6du1l1ygpyuRyB5zO/u4OJmQqT09O8533vx3McDr70LB/97Gf45le/wjve8Tbuu+8+Pn/9F3nwwQd5PXD1e66hs3MBb3vnlZwY/QF9PfMZHZ/ie7ffzkxhHLfqIlQFx7eIRDV816ZRr3DowHHmnbkMx5eoWgTHrmGqMQLDQSqwZGEvRS9gWjSItjRx2dvP4GPXbEL6gseePsp3vnU7C+a1MXBskqVr+5BKgXjew7GLNLe0ooleVFUjNTWKZhocOzzD4YOj+HKCqNlNLtfOF7/8RW6+9WvAINt3Psjo8EMUhhTymQzRSJTAd5CeB6pE0wQoHp41hVAjKEqAU28gFInvekhPQRi1OSCyUXVwPQ9NE8hA8l+F3b9LqYRJNmHS0/8xPSKEuBm4BJiUUq6Yu5YDfgL0AieAt0spCyLcnm4ALgbqwDVSyu1/6jUURVCr1UilEqxfv54XX3yRaCKO1Qi1velYDMMw2LNnH5ZlYRgGr7toM8899xyTk5NUquVQ5aEFNOdzaLrC4GDoo2sYBm6hQWfnPEZHh2hUSjz33Mucvv4ssqk0Ow4O8etfP8Gfvffd7Nt3gBu+dSM7d+/AblhENIWormHZFYSmkowaKBKGTh6npSmHqsH27S9z/OgAplBZtqAvnP5yG4xPTeMG8O6r3s/Sxf3E41EOHTrM9j37icTj3HPPPbiOzze+8vcops7q01fhKz4nBkdor5fZddv/YGlxjHjM5LS3vBkqM3i/PEAwfgJPjxOpzpDUJPpcQ9MhQFcFUigEijd3xPNRhSSqa0y1Rck5XZywJAXXZ1jAUZHmG+/6DL1r1nPjE8/gZzQalSpO4BNNxlm/dj0nF53gvLPPw3VdUskkjnRQ1RiqpoQqhkiWTKqJtaetYceOnZx+5tsol2vYlmSiMQ2oCMXBjCkEvkNMj6PFTcrVWVLZDI7jMDk5TjweJxmNYRhR6lYFKTySyTgzVoPi7CypTIZCoYyhG9g2BL6LVBUqtYCtW5+j54IzSGXyRNVZMBTUaJJZPyAeT1Bu1ECRTA6Pc/GK07hs80U8/+JLbD7zHAxV49GXnqZRrqGl48xOz1Bt2KAIrFoNQzeJqCpLliyhq72DlqZmpAAjlcJwAkwzSm9vL4NDJ9F1ldGRKYaGR+nqypNMptj7wjAf+MDH+eanvsFlV81jwVnnE73rZ3ziq3/HTX/1VX5809/zpR/8jMk9+9n65FOoE9M88MtZrrvuL9i0cSF3bbmNKy5ex63fuJrpoSNc/vZ3kMtl+OEPf8D73vc+VKGgCcHePftZvmol8Xicj11/Pd/9xr9w7bXXsnf7y1x77bUUi0Wuv/5aDh06BE89QS6X44orrmB0copTTjuVvp5uPM9jz/4DtLYmcWo2kpBj1ZRQEmgYBvVyDd/z0TQdkBiahq9CPFDR8LAJiGsKtq9RLe3H9Wy0fC8EsHnjUjZv/HtcP+CF54+z9YlbObSnwT0/fRDPt1A5ik8VBUFAHlPt4GOfuZSrrzE5bcWb2HBeN1LqCOFRqz5PYNfoTKVJZBLEcx2MHBgkVvXQUnGICAJZC5NifFDNaKjgkGH/S1VVNMUETQXdw1MEEITxbL8jlP7f4bX/1Aplg7/Lc/8+LOTVHt0fWn9SPSKE2AhUgdt+C7S/CsxKKb8ihLgWyEopPyeEuBj4CCForwNukFKu+1NvqLW9TV7551ei6ypjIyNs2bKFT3/iMzzyyKP4js/KNUsoV0usOeVUkskkuhal0bAYGhkmmUwS0bS5oQ4D27bYsWcH2WQzd915P4aeoF6F+YuaueIdF3LllZsoz9RZuuxsOnoWYylpZmcLxGI5FizqZ/XaZcQTUcZHJzB1MA2FVFxB11QihoL0A2yrjqqqHDkySKVWZXx8nHw+xdTUGNlMG2NjBR595Gk0VWGqsI9777mfz3z6enQ1hTBznHHmRkxD555/v41777uFycIRLlp6Op398/n5g/dzWX8TT37hes4pThKYGnLThfgZD/OuhyjGDdJrX8PU7hMcuuAyDicNhJMB1cN1fWRDwQ9crMDGcxuok4NkDJ3Y9h0k9u6jaVxBEXG0nhRRmcRMNVG94mLWvONNfPXFp5k+NEhfVyf12RIbTjubplSGwcGjpFpSFN1mhO6iYxCNWOSbmrnuuuu488d3cfZ5b2B2pkyl7GDbLpl0Ftt18P3Q6EkoLkGgoBMDRaCbGpZlIee0rb7voxLaBOTbu/BlwOEjhxBC4NYLJCIRIok4ridRXYWa7eD5PpphowcWF562jFMWz6M2dYjJQglXMck2Z7ALZWanptm1fYClfc1877Nfpel1G5Enh1h97mu47uMf4t9/eRdqRxsnxk8SUU2SiQT5fJ6uri6SkRgXb95MW3Mrbt2hVpwmkUrT0T4foajsO3qQJ598kpUbTyPQdcZHBymWJrC1NIHTxFnnvJHT1/ay+9n78KtFEvEc+/Yc5w2vv4jZqEEQMXEdhdk9u0l19RFLmuRbkhSGp5i228m1qmw49xpShg3qfv76b79IhD5i+Qjlus15Z6xl554TVD2HWCzGzt27GR8bplwYp6u1iwU986jOTtNo2HR2zuPIwHGuuv46cuXyn7ot///1/+KaSiTIV6v/OfWIlPJJIUTv71y+FDhv7utbgceBz81dv02GO8HzQoiMEKJdSjn2J14Dy7KBCBPjUyQTaWKxJPP7FvP0s8+w0PKwLI96wyWQdVy7hBCCcrlMsVgkm4zTsEyqNQU0SSqVwLbqBNIllU6gawrtrW0smNfD7pdeIBbNUikEuG023UvauPTSN/Dc89u47vOfZMsvH0TIGKlUAj+oo8w5oOH5zE4ViUdD7a6haoyNDuMJlbHJErm2NLYU+IpBsTTFE09uZc2pK3ho631MF49z1vozeO75nWRjLbi2QUtzC6hxIsJlZHCCx6ae4p8ufQvD4xbL/uljRKzQKS9Qo+iGilY18d0IKknE0m70mQBDjeE7EjXQMVTQ1ABL9XFFQM23qVtlEiKgUK+iVx0S0RyRJWmEqlPwizSsWZxyhZ5cG273Iq7KJPBeF6EtkWTw8FEWLFyK73osWLEcoRAOBkiJFAIpFVzX4847fsXCResZODaOVGyEVFFUie1YcwoDFcex0Q2VwAtQjNB323EDYtEEruvjKQGGoeA26jTqNjOFMolUit75i5iZmQJdgOcgfYmhmdiWA0oUFEnDc6k7AUfHCqxYtoK2eOgdfXB0CttpoMU0WtJp2tMRVvX3U5+tUtvyDB0LOzjvlNU0N+exoyZWoYRqxgAFfJVa2aJcadDX1cuCvoVoqIzODqHqBoaq0ajWUFBwbZeenh5GxqZYuHQR1dIe7IqgY8EFfP5L1/PhT3yUkYkjLDl1A0888hS7js0QU1u5/b6nODR8hK6uLk5bu5KT9TpTW59g9an9kFtMS/dCnOEpnGqU9171TrY+uJ2jJ6c5sP8YG9euYWp8mOWnrOG2u3/KaWdegD8+xvjELBdecAlIl6jpUCnUOXn0IAmjjUQixcnBUTacuYGBxx/lpK5x8MggLW3t1CwfRZUsXb4SIQR3/vvP8D2NL37kCqqyQkLEiLafxabNp7J6ySo+/KlryEajCN/DVAGpMTRVpCWfAT8sXiUNVCIEvqBUbKAbYd/K933knM8IQuI4DuOFIpVaA9OMUak4xGJx6vUpAs+jPd2J77q05eMoaoz2rgiqUJGF53HsOhWrQIAkmW1Bkyqq9FCiAkWVoDqACq4CQnlVDx3CnkfgRRCOIDBmEEYcP2hCj6zBC8oIofBKLFg47fg7PMlvaav/U0sKJBqKKAAKvt8CSg1VpPjil37BsdFfw/e/+Xt/9D/Labf+FhCPA6+0OzuBod963PDctT8K2kIRxONxnEaD3u4eDh88hG3X6ezroLh1luZUCqtUIhY1MY0IqgK23aCzLYPrWAQSfM8m8EIvgO7mHGNjkzRnU1hWlULZxw7a2HVwO+++6jweuv8BunuztOQzPPXUQ+zYtpPN576LH950F5PFcfr7+1ECDxPQVA01EccXNrkmA8+zKRaK5A2Dvt480+MjtJ+aQsFlxemrSKbi9LXC5o3n870f3cB7rvoc77zirZSqFol0iunqAJFxlUx6KSp1Htn2EuVKid4F69g50oBagc93tnHZ6TmsdjArFYKOd0OrpPzTxwm8ZgpD83h2uobX30qsJU/XUJ1IKkG54dIoNsJj+tQYVT2sTgvjY3iaTVNPE6999BATGkQ8DQtBCpf3fvP7lG65hz1eiuL4OKlkBE3TKFs2meYWmltTPPrrexF2OwQmDbvB2eeuYd+e7fQtXIwvSzhOHU2No5oRFFXBC1w03cRyXISiIHSTqKEQeD4N20VRNGQQoKsauC74knQuj+/7jI2NUZwp4bs26XSSTL6DfXt3kss2k2tOUCxNEo+HoRYEgky6nW2Hxhie3cpNn3oj5uQk7dE4ZjKDH+ljdPgY88/M0NPSxLwLXsNz9/6cnzz7S177tkvYP3CYJjNHPJ5grF5icmYamVHpbOvitKWr6e6aR326QTqewCSCYZoYroFmxDFcldWnnUV+YogtTzzEvVvuYcNZm6hXi3znBz/kbW/6c1QcOvILadhVlp9xCkPTW3nTe65i+wvPsm/sEN//txv54N6DfPXS1/NXf/s3dM/v5YL1m9n66EtcfNnb2bntWXzH5oef+me+9u5LePEnP8Hd9AYMmWC8MEbMEGx74m7SyQzxRIoDO57E9SSu62P7DhElANdlfLpAsVpnfPvLZNIJmvMtJHMtDI9Pkcw0EdVNBAZCSBpWBc9T8QMfGfiggWGEJ6Ntu7aTiH6QwLNQFItauUQ0mQJZZ2S0hl210JD4QkFRAqLxBIYeRddiRHQdAEMLkIFJECioikJvVzuOHSAUNdRoN2pY9TYqlSrJWJxyuYpt6URjGjNTDdqamwh8l4gmiLaGI/K2Z2EaMXzLDrlqX0GRSijli4SmTAQKSC8011MCFM3H1z08aeDZAapqozOKKlSQKgIdpEmAAsKZa1SqILWwYSlCQP/d9eqY+m9jnPiN1lvObQBSuBCEvz9Kg1ciyTLNDv6J+H94jlfW/3EjUkophRD/lxkfIcT7gfcDJFJJisUCET2033yFt667NololBMDxygXyuzevRvTiNLWnkfTFDTho6sKDcdH04xQL+16CBGGKjiuTa65k0hUo1wuYfk2qqZTrTRobcvS2zOfY6MTqIrO4Ik9nLF+HXo0jutMEzVMFOkhVIllu/hS4AUOQjoYhsHM7BT5lizSmaW7L0UiMo/Xv/4N7Nj5IjMzDb538z9w+ds/gWbCZz57HVdf/V6QJhFTJ9/Wxa233sz0+Bg333AHGy46h+37D/PPrzuLqxcvhqrD0MAMARBJKPRYEzRlejlSKDLvtW/CX70RZWiaLXfex4Rtok5UKVqTeJ7P1GSJwPOZnJrF9QNU20L1A/56RR99p/QgOIRIJbDqOkKo1OxprnzX2zn10x9ECANfhDIv9RUGbu7D6fs3oCoqgXCR6Pzgu7/m6xNj2PUZEAHRqIKQCaTQ0DQN1wvwZIAe0VFR8X0fT5FoStit9z0XzwtvbEVRMAwDRRcYpklrWwsqgomxcay6jR0zWXvaerY99wLVhku+rY3S7BTpRGhG5FgNzEiEiYlpZKyJ9nlR8s1ZqrZk3FHxffCQLO3t4OHv38pTB1/gg9e8j6eObactl+OM1Ws5MDWEnJxicXcfZiJGW76VpmQaUzFImHGkT+iPXZgAPUbOFxgt7TgIEqkmkqksp3R387nP30ClNs6xgQY/vPkWbr/jC2Ti/SxZvoGzNq/EbWR471Xv5+ihAdaftpaTR/eHtVwmxjdu+jes6hSOH5BLa1RGCnz6wx8AzaUpFqewZwerW5OMj03SlWuiOFvlmzd9Hadapae9g1WrV3NicBqhxjAjKWZr02TjMTKJJO1tneRaWtBMA88PrRymZmsomk7DkrS2tjA5NU5HVzuBFBiREDRUVQUJpmGE4OJJShWLbFzHVCS2qiKlj2loJIwE8bY4gRsgcebAS6Fes/CsOrOFSujr0wjQFHXOiyYcQlNViVAkitCwbZt0vg0UHasGnh9FBALb8UL/eg8UTUEThOqQIMA04yA1HM9HUwJURYTJMEIhcAz80OAECAhkFERoteorDkLVUFUTTY1BoCKkyW86kMGr9TaAIgEpwslHqYQunP9h/X5O+jdU9G/bs+qAjxQNkDpCUYknNAJf/4PY+Z8F7YlXaA8hRDswOXd9BJj3W4/rmrv2+97A94DvAbS05aXrBERUhcMHjtCUaaZcqLB0+TJu+Ma3WLl0CbF0kkQ8QyBgYmqcwZMDPPrAvcRiUQQujbqH59rousR2AiLRGIqqsnXrwxhKimuv+zCmZ/Klz36dyZE61ZLBC88dYO3KdRi6hm3VGRrYzfz+lczr7cGnQcMvEfg1oiJBVE1T9yYR0sGrNpidrlIrFlECm0bdQwYF7vrlr/ADwcCExZQ9w4/feSX1isP09DSjhwfoX7GESqBhWYIbbrqVF3fuY1HHfFZ25dlQ38lf9hssWljm4z7s61rFtkaBt/R3kXrhZhjUGe9uptDZwmvUY5yjnuCM1b3sb19Gw2rDS1kIw6A8PkMQeNT9BpVKAbUwSdTzMB5/kYmCQCgREkqdihOQzGjYDuyd3seqkwf455/8hAMHDnPHbaH7HAp09+R58Nc/Q9dVFnZuJJPOUixP0TlvEah5fMdAFTl8LBSjga6ElYaUAaZuIDQ9dD+bS+gIN1WBYRiYZiTcnGuhuZQU4SBHyHnH6Fq0EEVRGTh6jKMnxzh1w2bGx8dp2FXQTYrVOk3ZPJVSBdWIEg187vz5Y1xz6QXMVKaQGhSGDmNiYXoqC0/dQP+iNXi3x2l7wybWPOwyWppCGZrFETavWXsmLS0t9C7oI2ZGKJfLaKpKpVH+n8y9d5BcZ53u/3lP7DzdPT15NKMwypIlOcgJR9nGAeME2GATTVpMWrwLiwGzS1obY/KCYckGYzDOcg44S7Zk5TySRqPJoadz94nvuX+ckXfv/ta193erbhWnamqqerq6prpOP/19n+8TMDWdQmWGppjJ4aHDiFwHfkIna3Rww8du4O7HH8VDQ51Nr7vltt/T2hvjH06+i+LUOIcPH8Qpxvn4313HIw/cy/jIIDd+8cs8/dQLqDIgGaS49l3XkWvv5Jtf/wd2Dwxx3cfezxkXnMb3f/p7unoWEMFjzaoc1XSUmUqeRFOcpfNWoAuLdK6FOT0LmdOzinyxwN5927ErFXYfDlMd9+/fT60UVtKdte5Mfv6LX2JEs+zcs595c1vJtbdw9NAo3//uz+hZ0E19VgQg9DAMKZ1OhYtnNUWhaDFTrtKsSbracniuQHoNapZLJT9DPJkiAAzDxDC02ToxFV9GUFSw/VDWl0qlkYCqOyAlmmrgezZNmQDPFzg1hXrNRtUEqi7wLB9HnWTngTHmtbTguh5GKsyWD/woptlKNKpgNRroUWM2B0Qj8H10TQAeEBBIg0BYswAMgSrC4TlQsX2BRgSEjVDCIl5lNoNEACgSpA/CC4FfvDm4/tfr2PfAsUlcCAVEKME8FpgVBNDWkSKQbw7N/7eg/RDwfuCW2d8P/qfHPymEuJtwEVn6n/hsANd2KE/lSXVH+cQnPsGCefNZvGIZzZkWFGAiP8H0VJHRiQIoAte1UTWDbEvoXPPtOr7vEdEVDFMjnW7C9Xw+8tHruebqcPJ2XZfx6VGM2Fy6Fyr0Lj2FuuNSwAJHYhRr2F7Aqxt2sPm1/RTr01iyiAwa2JUaTsPBsqex6w28WkDUjGBXLRb0RLju+rcyMDLEwkVdBFLjjLecxaPPvUZH90LqGMjBQd5+6vEsW7OMwXrAfb+/i3vWV7HyI5x0znIuOPUcvG+9j0xWx59qY1gFV61hFgaY3DeOPidNoBgsX7wEy88j9m5gcOezVCKnMewmqAifmZFJAkx01w4/GHadSEShPJOnVKvSZkoG8xMEwsIu6qiBLuw4CAAAIABJREFUhjXjoAhosVVU3eCyd7+Xm3qWsnfffLZsHuCkE0/ktde2sbjnVF545TG0iMq6i89my/ZdtLX0MDpSQZgSXfPwvfA1FFSESpiLPKsN9oXA1A0UwJYh123VatRqNWKxGPF4qPy1Zrf2VsMhEBpmJEG9ZtE7fxljI2MMjUzQlIwRi0SZKUxhREwCVUc1ddxyhViihZ07hxg7rUaHFhBRTSKGB1Lj4NARDry2lSXJNnQDalt3ICWk9ATda+bQMd7G9EyRhXN68W2HhmXTmmkmCHysuoNiRDBiJnq1Sk9zG7sGh2gOVC776KfYvndfSLsHggsuPpfHHvkrZ5x1Ooqvcecffs4F6y7ksYee5ODBfaTTOfzA4TxxCWOTE9x6+3eo2j4/+cUd4IRH97vvfpD8TImbv/r3AJx56km8cvsLuK5gbGACo56nt6mbSdvh8MBBTll9PB25NiZHx3nmuY00JU0efPBhFB/SPfPJjxxE9RVQNNJdfaxcuZJMS47S4Ci9XZ2kIgmSCY2mbCvTpQbLUxmwy0jfRdNUAkUjGY9Rt+uYhkWtIVGsEuWESRcqUtqYpolpakQ1nUbDwkPBdULds+O5KLqCrorwvohHcH2fml3G8zwc153tZw1dp47jEDMVfF9H0wWdnTnqDZuaLGBEMvR2JolGkmE66qzR0PddBgbG2bt3D5e87XyshkQzRcgdCwMHDx03zKVRA6QXIESoQ5eeixThl4aKj1DcWXWHjiKi+NIGXwlTCX1BEEg00wZ0pJSoikpAaFcXQoS5JEK8oRYJCFAQ/9tzjj0OKuCHfxcCISQRVUdR/78Uy7Hr/0Ty90fCpWNOCDEMfHUWrP8shLgeGATeNfv0RwmVIwcJJX8f/J9eHyCbyXLrrbcSi8XCYwwwnS8wMjxBNtcMKhSrNZoyWRzPI5FIkUwmueuuuyiVShhKGIOo6aDrOuZstOj8ufMplesY0QhaLEYmliIWTaNpBr6u0fCrJI0sblQiUynmd3aypB5gqAa66hOLBjh2nVqthB7RaTINyqUpMvEotlVH+Db54iCubXPRuWdz2WU3k0gkOf/Cy9iwcSddXe109M1FkSq2H2V8tMT3f/gDFsybTyzdSm7hCn53/+N4Q+N8/B0f4ShRBvU+Vk3fR6w4wEl2QJ9rU0u7xDt7aL3zZZRdFaxvfJPkSVdxZKTEzIFprNYaqmVCOcAwNXzXRVUkrmvjBw6JVAIKDaL9R3jopOWkc83kohlG7VEKSo7tR0ZRzDS7NryC2rBJJloJ5CCODZ0dnRQLgpee62du15lsemmSeHIOY8M2XlALg3S0BkKRxKKt2I1wYSgReJaFYUYJfA+F8GaNx2OhtV8oOE44zZWPKRkMA9d1EZpGIAXFQploPEGj7tDW3s1MYYLxqRKqAi3ZdgxTY2JinOaWDg5PFgj0KvXiDL/78+N84+OXo3lV5s3pZHokT6WpmZFikWXpONmWHFu376Cjq4u21iwz03mcukN3Lkctn0dKSaIpRX5ikkYgSaVSVGaKJFs6aTJABA56yeXJDRu47affYf+hw/zul3eiRAx0u8Jpx60jm2vGU13mLFrAyNg4q89cSDTdwsbtr3DaqhOQ0qettTl8n3yJqqoYhkqAQr7hEkulqAagCJ+yZeELnWqtRH5qjKbpaW6+5d+45/GnefDR9fzl93fy/R/+gJZcO8WqTSAcurrCNVOuo4vrP/kRvvqPn2f9+uf4wXf/jSUrVjM5VURgUChMcejIBL66Gl9GWHf+RTTsSZoyaTzfR/lPCXa+7+PYLhPjw7ztzOPCjsOghqGrNBwXP/CoWzWMiIkq3TAj2rdCsBYqWjRM8hOzWdQBoatF/S+5HsdoBN9T2bF7gPaOtSxauoyTT12JqpYZGT3KxNAUgwNHmZwcn/3fDL7ypa/x3e/eRqU2jtBtUHQECioKUAPimKoSZl2rs1RFIFCVY/HYEk2Vb8BiiK1h2JNtBdTrPpVaiRdefIb3ve8afN9GKB4QymuPAbVCWC0mA/+N5L9ACFRFDT09xyIACOkeZZaSlDJAVRU0NUa18uaN7P8n6pF3v8mf1v03zw2AG/6n1/yvl+s4VCoVGrZLIpNBUXUsLwDdIJHOYkZ11EicJ554EsMwqJZLzOQnuO6699KcyVCcmUbXdWbKIWcWTURDg5Mnsb0GVbtB1fbQ1DgRLY7nu/hukWQ8QDZqpLNZ/IhCdWqYiGWjxuNEIwHFqQpmJIZru5iqxo5DO3DsOulEHLtWR3oukQhU8lOsWKLT1apTrlS44JxTufHGG0mlWlm4rBMP+MCl13LPn+7m3dd+lL7li4llWnjK9amIClddeBlufJSWzi7G1r+KNXKIoUKeU2/8F2pmAj1vog4+iXbpapyyoPznexgvFmiY/fR0LuVw8QxsqRFodVzHR1UUXF/iOA5oMWxVZaheY7RSQ9u+BzOi06okqLQ2sb00gL5yFbYRoDWKJFJQrU2hKJKaNUNbdye9i1ppaWnBtrPouk6pWkHTobmpl7pt4fsSJVAoFUJnqhACRdNDUPYCNEOnWCyCDND0sFjC9/6D39M0DSEEtuURiURwXZvADAAD13Yw9HioEJjljm2rzlShSLlUYP78uViWReuchUwOHyEe6WDznl3omc+iVEdoVXVoDei68AKmCkU2PPdXHM9HESqe5yM9SUdLK5lYgp07tlAyInR191CZKfP6zh0MDY+z4oRVJJJNtKEz5ZsoOjQ0lRNOO5WpmTH27d/Ope84m82vbubUlas4uEdnTquORpV8foIdg69z/HHLaIo0WNDWi2VXqVQqCFVHVXVUzSBimJQ9FUXXqFULjJaqyIZHtTJA18o1eJpkrF6CaoGEVaFSLyMlXHP1ezAN6JrTjV138TyPdFuWmB6lmK9zdOAIx519MQfyPjd/8zZG+4fgg1cjRQShh6DR1dbC4KFhOubM5XOf+Ry//N0PaRTq1GwHNaqiEBBLJLHLM3gSCsVp8F2kqBHgIAJoSsZxpQx10YEdAleICSEvjkXI9VqzNMBsop4AXx5L1wvviTCvR8HzBCuPm8dFb7uUo2PTHDg4iO8VKc9MMzx4gOuvvxbHDnjooYewGi4//vGtLFvWR8TU6Zu7jP7+Iyxd3kZ3d5b21kW8vHEbB/oPkIwrGLqJ60VAqWFGI9i2hWFoxFMRDMMnqi5E+io1a4ITTjiBwUN16lWXeQva2fDa47z3umsQihXSGKqAQMX3JUILG6/CrBbtjQIVRQkfDzPJFQLJbFKgQCKQvsR1A/SopFqtsW3btjfFy78JR6TrujQcm1Q0htBUfCnpmT+fSrFC/4FDzJQmOTJ0lHgsxYoVK9BVUETA+vvuYevhg2EDhqqjmlECReABuqFhooIIMDRBnAiO66OqPtGIglt3adQsmmJtlCaK9HS3IyMxmpoMCHw2v76B1rm91Ks2UugMHhmnUp5h2ZJFIAWR1giqUGifm+PhB+7it3ffxciki2GoTOfH2PL6a1StMqO/GMeINHFwbCt/uP9nvPWt76RhN1CjUd5+yfGc1LeQTTufRosqOCPbOPPUNRStSWTJ57QTTmfftpdJf/x8nF8/QHy4jlVvo+tD76OzpZ219jDPPPcyrZ5JOQY2EUzPwLEboChokQhWw8CSAcrKdsTSJiyZpFSxObLnKK+PjRBJZjC9gAk0lp1wOqomWLBgIZtfO4wrTXp65+O4KSy7gkcdIRQisQTRmEmtUseTAdLT8VyXSMwg8G38IEB64fHOccKjZjwaCzlSJQhLEWaPw8euMJZSRVfCSUwNq0AIfIkTWPi+SyKZQVEUarUaueY2ErEEtu1iRmLUK3UiiTRRU6Xi6oxNl+iKx3CtEtOFGZYsXomRbUYEPqaZQDdMhFApl6skc81omkYsFsNxPDLNOdBVjqx/hHQqwyPrn8BIxti/aSePTg0w8fp2zKpB35I+Xnn9FbKpJI5lUavVqVhV8kWQfgPfd1ixaBELc91gTTEzsR8viFCvgW35YSCSJsLlWyAJnCqup+KJ8OhemhinvTWKb1t4io2tSgIj3AeUKmVUVTC/bwGl4hSWZeE4DslkEjeAWDwNjsbBkUnSqQzxJpUDm7bR3buIK65+B6+8tJm5Pb3UajXefuFpTFcktlR45zsux1A1lFgK23YRIoSIRCLBZN7GTERpNBqgiLAqCwUUiSQMSlOFCEtsQ2sOxwoCQkCe7UMVAkRAEMzmUitKOGkeU1cQIGSY2y4UH9e3qTby7NszhBAzWLUCUV3je9+7A98TzJnTS7FYo26VGBrbz7oLjued73wLWzdv5fy3nciZbzkfFRVFWca7rrkMxW1hfHycVMogCHSkCGNXFRWEkMjAoVrUaZ/TzuBwnh/88Dba29sQGPz853ex/snfgNSQ6LMZ4AqqqqGq4HmhMkpVmTUgMVsC4s0OJ+HiVlFUhDQQIsyfF2pATBVIfBYtWsinP/UJvnDj4/8tXv5NgLZl27z8ykZSzRma27tQFJXunvmoqkpzS45MNoFpaGzfsYdNr24knUqSjBp85IMfoFIuUqtbOK7kgceeYGp6Bs1IIFQwTBUsD8XzMD0dU2ooTh1NOJhag3Qmwr7XD3Di4nls/8t3WHviYp594a84juTyD55JrDeOSEQYnYjx6ssFPvX3n6G9vZ1GDWLRJB3tcwDBlt2vkzRSnHzeeZi6SfucNk5dezZCi6NYTXzp5q/z+utHeWL9Ru775TOceObpvLB9G3ff/0cSBESbOuk6cTmLO46nMHyEvt4+dh8+wP5qicz5FzLzqavRmSAe76TgF8mkjlK1dmPshDXmYh5srZGJGqi2QtzUw1zrwMbFozQ9g7Q8itlWpArTxYCaEDidM3THJUeH99Fs6cRVlQcff55LLrmQo2MjqBETw8zw/Au7SDU143kKqXQHvgwBtFCeQvg+wo0SBD6aGmDXDVQtnJpsx0bXTVzp0qg18AM/vGmVUKtrGAbS5w0HWhAEKIGOZzt4npzl+BR810OPBUgpqJTLBBISsSYqtTLSlRhRjdHRcRYuWMjQ8BGmx7eQirbz53v+wmevez+HB7cRi8XJFwvYqTjKTBFNjZFoSmG5HqlUisHBQRQFzEiM9p5Wmrs6UZNNjE1Mce+D67n5W/+KJjS+8uWbefH5h2gUS+zr38XBkX0kEimiusEXP38Ly1Ys5Sc7fsPoYDe/SkWxgypRtYl0c5a7v/0rHn7yJV7YsoNJGVaxHZu+VKHgKRINgeO5RGIxfNtheN8B4pEKXi6HkhBUPYGSiNPS0kLvvLm88vo+9uzaTUsuRcTQ0QSMTEwj0kmGK3mWzl1C/0wVKTRmHI8gsDnznAt5dcdhYqk2/ECjp3c+cUUj076Mjdu3ENNNPNcGYWA5NjIwEAha2zrYu7eBltIpl6thto4v0BV9Nm9aQ1PC9pYgkAShvAJFUd6gA/xgNvw/COOOlUBBKAoEkkBKVCUEucCXSLWBqmkEBKxZczxjhTLHHd/Onh0bSCbiGJrGu6+9hEcfu5/BI2Mkk+3c9q2vs2ffJpqbbd593dWcc/Y82nJn8i/f/iSdHb288MJBHA+qRR8jmsa28wTSQ/oqjhugaQpoEolDJBZlYrqf1i6T9vYsAoMA2PDKZgIJQglASqQf7suEUDBME01TKVfKzMzMEImYqKpKMplEU/RZN6Y6qxJUEeI/aCEhQnpECJVUKsO5605/U7z8mwBt3dBZsmgp6XSWplwr2bYWYqk4E6MTPPnAfahxjUy2ibdffBaK0GhUXcaGx3jllVdJJWN0rl3NQjPLzMubeK1QZkS1cNwarXUDT0TwIzEs4VOTFlIWyQgovfwa65atpj55iNUrevjDy8MsaFa47B3Hccu3txHNDeIoClGWcN7F7yNIbMQeyrNh+x6WnbqSSC3PY1//Aw5VlPEJrvv859i2Yxu/+9MvaGvrpX/fJDNjU3QsPIOmziwoNdKdXbznvaczNVNh6PGH6WnrYvLgOEEQcJFRRy28StOqlcR3tLL/9f1MHRrAq++HqEmTSJDNZJlfrjN9/8+Q+Dz5qsVU+8kMzumjWJ3Er1o0yjM0GjUqtTLVWgXfk1iWRSNfxBcKR8dH8QnwbQ8EGHGD5jPOojmeZu3apWRbk/TOWc3YsE+lWIHAxbXChSGBg+962LYDGKiKJFAVEMyWHyhoIuzIUxSwrGrYV+nWUVERavAGUDm2NzulhDEGQQASD9BQVBUUFUXogEQJwPc8UlmNhuviBT5tLa2MT0wxZ858dC1GuVIjm8pSHE0Q6Cq7x6Y4MDFK4DdIeRq6DAjKNoqpY8SiOIFLRISpgioK0vExfUmxUkR6AqVqcebZZ/Hpr3yN6tEh9HQUz5P87Jd3ceqaPnoW9oAfVmilc230Ll1OMp2iqC3CrOoIoOZ5xA2V+372W75z6zcp21AMwGFWLSDDD6s7u5DyhI+qRBE+eC7YskomlcGtVVGjBuWioNDUyYOPPsWTzz5FoCksP/5kpgtT2JUyQgpasxkUYVBwi8zpm0Ow/VW6F7URsR1QJJmOJEITWFWLSEsLFcVABPC2yy/l8JEZevoWUfUFEVVQLwtMRUdSJp1sxXN1amYR3y+BG6BpUaCGLw003yOQEKhhHHGghHrkIFBQhQbSRxPh5jAQYhYE/6PSD1UhQAnBXmgIUcPzVVRF4eILT2f9/VuJ5kxihofv2/QsXMiLGzZSmIElyxeQTqb5452/Ix5LMhir8uufr+dLX/0W8ZiGVfPwlVdYvGIZtYqkNdqEi0c8kcRxoViqoOgKiipQCNCFSuAVyWaSDBwY4MN/9wm6UwtIt2VpDL/Kot40BD6K1kQgHbRIHDVQeOCeh8i2ttCc68T3VNyojyMlM2PTKIaJZNZcpISDSlM8xsRYEUXRyOfzNDVliCVM7r3vSR594pU3xcu/CdAOZIDwJaoEq1rjcLnEyMRRDvcf4MJTT8FMxxEqbHzpOZLJFKuWn8z8efNob21j1+5tKJs38cMv/BPHVx3E8CSrrrmKqa3bOCeS4YmD4/D2s8n2zoFqnnRrAv/QEPP21DFf30ByeB/rX9pCexrO+3A32VNK/OSSbvZtbmb7XzVOOuUEsukVXHV5D/ff8l1KXp2npvYz8NzTfH7pOlpPWcOwW0PIDMcffy75wgh/+NUfePwvG4kkowwc+T1mLgoyzu23fYM//r6NiJnEdm1q+YCqL/jx7x7kwcdcls1vxmzK8vzz/RxtqJzx+J0M5Mc4ub0ZIXxYUEUmYigXfICdU+N8+fav8sG/P4flPV1Esj0oaGgYaJpGtVbGMAzGxkbIZrMcHDhI4Pn41gyKdGgUJxACnt+4H8NIU3dhxdo1vPbS69x9519YuGQlUoNUMoOqqgRIStU80gcCHSnBkwLPdVA1iEQjxGMxLMvC8xwcx3nDtRry3CqSMNlQUZSwmXp2woaQHlE1gaqGqgPbtme1Vgqm0PACD8dx0FUNT4aOymy2mf37DxCNRmjJ5Zgp5iGeplH3qQiLV3fsZIFZxXcNtGgKR1o0JaPUrAaGYdCcjOK7ksCykMIjGU1SxOPwkX5aEjnecelVDB/dj0hJepetYv3963nL6Zeya/fzfPbG27ju/VdwwUVryU+VqJaglrIY21+jrWUOCqB7EQIN5i5awPs+/QFu+vZvkIrJmtVLmZqaoCmZplar0bdoIePjk/ieYHJijI/ecBHze9bywOMvcP0nrkV1Z5icnmZb/xATHSk+efV7KNz6KxSRRGudS7XYIAgsgoaNZdURKHS3tbFt93boWszWcXDLBvgqx69chIKHGTVRFJ1yySZQJMtWH4eDRTydwPE1NCEplipIPw6qQjrThu0IhKrQaDRQ9ABbWhiqQBNe6JQlAKEijxlYhEEQSHwAIWcXjiGNIkRYvB2EfS+zSKAglNklIM2oAvADVi1fzLe/9TUuufRy5vfprFx1Gi9s3Eku20VTMmBwYIDkcgNpQ8+8Xm7+l0+zZed2/vS7+4hpGsPFcWKpJpLNWR586CEGd/fTnGqlMZ6nobm0dHUSTcQpVMpUalUMH6rdGVQjyhW25PpMjoXuUZgY5qFFbYwcOoCvgm9No0cynLTkSkzFoLXL5qwzj+MzX/l6KGWE2TFEvpF58r8nvNp0z2lGCBUhFrzx6ER+BXsPHGLTxv8eL/8mQNt1HY4eGaRcrNC7aDGoKtWqw8REHk8KjEDHsm0sx8W0Paby00QjSapWFT1iojy6nZW2R32yQqNQY+6RCZa4JoOvvcKuoEZ8S5KT1iwmN+c4gplpPCOF3jOfadvjqYEdNByHl4BTN3hcevq5bNvxClajF7I5anqaA3sOUyn1UzQ89gzsI5OrseasRfz+xYdZtzzHPS+t56pPfR1XFDk00WB4chJqRdoSzTgtzaxesZIHhtZTKdVwKFBxYN4p52GoVSanJfF0E4suPo2/rH+aWq1CxgdNCP46XEfJ1xkeLdE/YvOTBUnUtMFZl19P63En05luosOIMmTvoTnfTtQ3mWkU8TwPRahYdgPXtRk8epBaqYbruqjYSL+GqfuomsFUpUCTVyaqK7z/gx/jnr88xJoTTqJScohGw+PddH6KIAhwfAddMxEoSBkui3zp4TRcfKng6n4IyErYRK0ooUJEm13OSIKwDktCNKq9cXQWIlT/OI4Tmm2EiaZpBGh40p89fobW5wA1XEwqIefZ0tJGrVZjplCmvaOTfGGY6sgkjhEwND7OnO4EgVBnvyBE+ONLVKHguBbCkyRiMYIgwNB0WgJBSiRJZzJY0mNOWy+DYwNEZMCXvncLbcvXcP5Fq1l33sm05lqZnpzBbmj4gcSXglw6R0JPgYRsNIGQCgOFAg++sJG1rfNwszGGZqbxpcdMaZpAwqZNm2hrnUOhUCQaU/jYJ65mz+4BXK8tpIdEimIjQKAhfIke+PiqQPU9VixeyNE9OyhXi6i2RVt3D5MNGzPZTC6XI1KYxtMD0osCCJpoaerElzpSCjzpEchQpdDe1hW6WLWQtlFUD6vuIGY7EBOJJFKG71+jYSOlh3KsQUuElIiqR5AEs8tID5Cz9u9juwt91l0YMtgIB/DfcAgKcUzD95+4cHUanSwTEwMI1aKlZRG2LcileyhMlxif3E1X+0oCaZBI11GjeQ4c3IkrfIbHh4gpUKxXmRgZxBM6VOosaumi3KhgRQVN0SZikSjleo3m5mYcJUAqPsVaHsUyKQzuw8smmdyzk3hXO9VMhIJXQZGgaiZgs+bEOXh1hYnDm3l0/cN85is3Y1sWiqiHpwcEQgvfrDA4Sgkt/SIAX3+jRxUEyUQTXe1tTIwfeVO8/JsAbdsJ86q/fdvt/ORXv6WjtxcpJbVGg0y6GRFLYpVn6B8YoaMdOucIpsfGiaR0nnrxKZ696SbOy7Zx6oeu5Oq+uTz03Ca8vMrln/kIP/7OV5gplHjf332QqJagbUkPEcXlrtefxbZ9Kl0x3IkGt37/nznzvLM5tDdK36Ib2LVnFwvaBKmuLl4encLx23neTzCiqHzj3LkMbrmfvmtMJqOP8Kf7P4SpvUhTXOELN15Gfehxtj1/mEMjBeaoFc5dfiVNuXPY9twmTEelIB2ue8fZXPKua7jojEvJT4/z2zsfIZdI0qN75I045aLDrw/2c+KKhTw50s8g8Cuzm+qRac6r5Xjp1f2ccMJStu5+ldVXXE6j6FOljqLaGCq0tTazdOmpPHD/Q6w6binjkxPM6+ll/84tNKXiDPTvw/cEb3/r+dRdg3POOYcde46yYP7x2JZGJBqjWCyGLeqenN3oa3hegK4pGIZGEAhUzcCyJJVyFcOsE4vF0TSNZCoOgYKmRcJWIl1D0RTqjTLRaBTHsULppfQBHUVRiUQSeJ4HgcTzHCSSWCxBvdHANAwUXcE0YwRS4EmFQIQfiJa2Liamxtm2YzdzOrsYmKpSqM0wVaxid6fBjFB1HGSg4OULxBIJDF3HqtSIRqPMFAqk02lS8RTVskfTokVQbTAzNYhfnKS97ziO1G1e3T7EzqEDfO6fPszMhMWuPQ9zzrkryGW6GJ/YT6MRI6AbT+ZQhE+pWKN/7y4++9nP0dQM/TWPmF9mxfIFdHV1sWXLNhLxJM3NzRzo3x8uZoXH1m2vcdMXfsKzz/QzcLRCU3sG38yimHnUpInnVkklE5SLJVYvm8u2pw0MmhgdKDJ66DBBJkWlEkVTNNSmNEuyggMzgtSqVeTa2xmyS2Fri9Rx7ACkTktzjnRrFl01KNl1fM9iemYGKebjSYVscxKkiakYlGZKIEOaAyUCaPjSR6Bj+x5R3UANjiF6QFhkC1KE9XIBOkiBCCKz6pLZZwZBWIILoZsxCNCI4is2t3//Vlo726i7AXHLYPLoYRqNaR5bfw8bXz7KH//0JFX/NebFmvm3u/4dX+pkIzrFiUmaEilUxafuqCgyQLN9ClaNgtWgyYPeXDu9rV0c2Btm8Fu+QmegoJoKu9s7+NL0JJqhoeYrWNInX/eRioYr49AIaFV6eeblR1l3wQo2bXwMIXVU4WFqOlJRUYSGH3goQiAC+UaGj+cITF0NhRRvDDoBleoMjzx2J4nI3f8tXv5NgLamqkQiBvPmzqVWq1Eul4mlmnA8l9u//wOy3XNpn9PGwJGj7N6zj3rZob29nUTSYOHCxdwY1FEDA3yB4xb5/Ec+D4oLgc4VP/1His9v4O1Ll7H4hJP56vd/yObndtCZySGkTV/7UvaObOHyyy9n687nMKwsrp0Gv4eXXn8ZuX0UT19G0aqSOP4SyoenufsPv+WiE3RamhscHdzF5udslq4dZnJIRVgd6KbB2886j7HhgJ8+cD+jt9/BqvPPZsfRKr++6ats2LCVf/3OHXheO0Pj03iWBD/k1mqmQSbi4gKOBaNHjtLkK0RVFcupEV3cRdfyIo//8G5e2PISd99zD5VHdrOOnqRBAAAgAElEQVRi5Sq0qEujHlqPb7/tx2zatI14PEqjbuN7oKGgqh59ffPo7x/AlgoIyQXnn8fm17fS2nkc9boVhvg7dXw/7H0MA/SdUJokPRqNmdAUE2vC8wRCqBhGBFX1KJdLGIZBIqEgZrfrnuvj+wFCDW/OY2WpUoYaV88LlRRONUxP1HUdEChCwfddImY48Vu2hwwsdC2ClD6mEcO2bQIEsWiCbLaDWExDMUxcX8V1BZbvU7MdfCU0spnSByU0YRmGhup7NLe3kkw20aiFp4DCdJ7K4Ahz3noy7lQeUbUYHx7CMjLc8s076D8wzvs/cCWPP/Q0Tz/1IquPWx3mqAiBpbt4egWBSrEySUdbgrnz2tiweRPxRC/JVJT89CTFYpHmbA7LshgeGSKTzrJ/fJDurhaGhyrs3ZGnpTlOe7YJV8Do5ABVb5TxmQxHx0ZobWmnXCoxPHgUoWvYxQpRoZBu76Bh6qiaYP6yXnZtPkJGSOTMDAkDks1JIkUbw9HQdQVN09AjEZqy8dBiLn0cx0IoAbbrINEIApVYzEDTDEr5AkpvD7puIrHxfYUgUNG0KL4EUzfx/RqqYoRN42/QAWJ2oj72+1hxLgRSeaOOK8zoCLXwqhZgOwqGkWD7ru2ccdaZVCt5pvMTTE4f4IknHmHdeRdw3vkut3/3D8xdEsWqOlgzDgmhEkzWadZS2MWAIGYyVSiSyqRxPY9kro1TFvWRDnRyIkJrPEt9uMTUZINAc/BqVZyITjGe4YBjgZ4ikILOhkLDUvEsn7JVojWRZdFx87jjzi1caPWx92AehIvnSUw9iYKCDMLBRBBa6wM/PN1EzQie66PrBoHfIEAQSJ3Dh8Y46cQT3hwv/18B8f+fSwjBxlde4XD/QUzNDJUEqETVJKuX99HRtZi2zhaq+UnwJcctW4H0IZfOcP9993DzJz/OP372U7z9bR/ka7d+jR/c8TPWnXYq9z3xV9ZuPIJagZe+9iuel/9O87plrDylD2MSzu5cwkA+z6FAsPXBFynJfjq7ckxOGDQt6OXwY1WWrV5N3/y1jE7YvLxjEq+xhr6eOq6/Ec8bYUFPC0M7ohTNMieffRmqsY6fHzrE03t30aj7rD15DVsPHsWJzqezaxk/e+hZrrzyHbg7djEwVEWPqei2RffKHs487WSeX/8MbYkMrxYH+N4/f46TVi7jy/94A++6eCUR3aK+aQMHp+CMM97KvkaZxc0x0iMGB/v3sXTVKo5fsxjfgxtuuJ7J0Ty1WoHFi1awZMlxrDrheP7+k5/i8ccf44orr+Lyt1/FQ488zqZte8hk5qEKiaLFyOcLNBoNTNPE9wMUNdTaKoqK9KHRaFCtVolEIiiKjiICIpEA1wvNBLbt4LllYrEEAW7YeCMEjZqNqocuMs+38XwHVTGJRTPYth1SIkHwBh2i6IJavY6mR2cbqhUUAnwkuhZyq0YkylS+QK4lSzyZZnhoP/OWnMSBzY8yXiiRr7Wg6zZG3SYSieJKG18IGrZFNpul3nBp6cgwXqzRmumAaI0b/+EzPLb9dZ587FFWLumjnkly/6/v5MkdPwCRZNVxy5nXPY+YGaOhqhTz4whFYbLQoLlrDn3Lz+GOX79AYWoP4yOj7N8zzdIFc1HUDP2H+2lbMo/pmTy+72PbLlbDRboWLdlmFExMlpPJzmHRwo+iah6F2iDLF57A5i2T7Hx1G6/M7+akk1Zy6OABBndtwW+UQQYosQSl8WmSEYNKuplnX9rKqkVLuPfHDzK4fw8XXvgWtIhC4KkYhkfFqTE0PEiqOUNba44jI0XK1RKnr13J/oFDlAY1fEXgBR6GkaU8Pczpa0/jT7//DT//0bdBemiqQjLRTK3uctq557PsxNP58dc+Q96qEA0aYVgUDh4emp6GwMCnhC8tdC2BwMO2wPMbJGKt1J3pUFnkhgFwptnCY49uY926c9B1nUQkyauvPkkgXRy3PGtMUTntlFOw3L1MjdQZ2j1I1AmI6yapWJSxYoGqFjBZLJLu7MZ1fBINiwMPPEtbNseXv3ITZ1xyCXe++Byf/+6P+NCnP83WnVtJxuPM7ckSqZXIpdJIK0AEKUqWg2t6ZJQs4+UZ1p6yjBuu/wx981S+2Pc+XBlgxqP4AaHVRqooAlzhoaCi+gEVt4Cq6UT1VhzHwjBC/6RrFbjmmosZGau8KV7+TYC253l86lOf4tK3XcHJJ5/MwPgosUSUts42xsfHMKPNuF6dVCqNVbXYsWsPl1x4Cb/59a8xjCjfvfOHZHLt6L2tnLbuDP75a58mkpvDz/7lW4j+/Uzv2cOpIobS1crjU3WSPa20xlM89vIGDtbyOJpCV2eVBekcf3zwcTx9FZUjW6jZOq5nMLJ/E1t2biM5/3i0pMnY9CSJiE2bEqXmGwSaJJ3V2fTCXuYunocW83Ck4MKL3sb3/v1WFD3GIw/cA8ok733XP7P70BF80cnTj+9kenycnmyW/Yc0Duy4h0ABbV47ZlTjm9/7LmoQ4aLjXQ7t2o4UTcRaFzJ1YBMiobB0uYqpQ8m1+MD7rueVp//KN79xC1dffTXPPLWezZt209bWTLVa59e//Dk98+Zy+lveQq1ucc+9DzN4dIZNm7azcOlKYnFQFI1j2V/RaHR2oWgjFPBcHxRjFrwVPM+jWq3SkutA+mGYj6rqqKqPYzXwBEQisZBGmbUm+0FownFdF12L4HoWMrARIkDXTGSgIKX7xlExCIJZY4I+O6GLWU4wvAIR4EmJYRj4gY90/VBCGIQLTE2PouoaCJXxyVGy2Syab4OmEDMi+GqAqplMFPK05NrZOTKA0rD5wrduZs6d93LaRRfy6299m6WnHU9zZ4a7vvxrvnjjraxYk8HUFeq1EpomsWsVdClZND/GtJXl9LXn8dqT+3H8CocOjIDdztRogRXLVjIk67i+ZO7c+ezfd4AVK45j+7bdVGo1ujpa8QMIlChCieLY03j1KppWZ//+bQjZACRTU1MsWrwcXTdRhUIqlWL//r2gasybN59KIU8uk6aps52pcoHDezZRGcmj2EkajkRSw7UDjEiOQqGA26jRP1QgqseQqEyMCmQjSqlaQXF1pA750RGMSBP33fNHTNOgq3MRmlDQFJ9oNEpNhZdffIHPfOEbfOGb/8q3v/RF8GI4ug2+wFdiBF4DXQvwbB0zEkVKH9vR0bUAXcviBxUMPYrruAS+ilAMfF/jF3c8QDxhMjYyTLE4ytREkWq1hFAsFC2gUla5/Ko13PP7QwwdGeCPf/4TMmLy6L0P8c6LLmH40AD5iTzxtlZsH/71izezev4izl+1AkcTjA+O87GP/R01x+XAocNc//EPYXz28zz00ANs3vIIdqxG1auQSjXjyBnQNHRhctfdj/Ke952Dkuvg4Yef4aYvXstHr7+Wf/3WbRTKDdraWtDNCB/55Ed56q/Pcsm568AG2xOYQRSh5XA98JwkumGHRhwzpBW3btn7pnj5NwHahq5z/733kW7K8eSTT5JszRGoGulMKzv3H2DvzqMsWrKQU09fza5du0hGkhw5PMjcnj6q1TJ/+acfcN8r2xhrVFETzZx96lm8590fYOLoJJs27GQuKo9QoWPEI5Vdwk3v/hwNGVC5vMKe8aP85N+/x1dv/x1rTzmFt5xxB+NuM68f7ScYe5nuzgVcvHYVH/noXH7z1CSbd7ls3LOTaK7EKXEd3YFpPY8tplm+9q0MTb1EdmmZ1FCNH/32FubPvwEjMp/K9CZGJv/Kd3/6Y2p2hJVn/4iq7RBpmeLo5F/RlMOYyQS1agNbb1BxXPAUFEOhKXMi3Us1th2s0Blv5uxVizmpcYCzLurg8IDJt57YxkubnkbJxFjQ18PPfv4dfvzjW1i2dDXz5h5HUypD3/x25v5iPu95z3Xs3r+Ds889n/6Bo6Tbu/AxaNg1DN2hVq2Hyg14Iw/C0E0MXSEQOr7vk0wmQ1nhzBSaapBO52g0GrieIBZNE4umKRQKlPLTJJtSGFEjXHoFYNsOihrg+TU0zaBetdBVh1QyTb3hoWkGjmOhakrYvKOqYa64DBCaiutJDFXBk6GbUOLjSQ/LVkjGk7R19FIqVkGNI1WT/oFBxg2fXDZKsVEjGzOozpYvjE1W0PQI6Vwb3/nRb0jFEyT6EjRVhvn63b9h2fLVfPV3P+dDvJ98dYY9217mqaceZnCwleuufSel4gzdbQEJE1wEfT2dFDbfx0+/8TCB6lFVVJLxBJ4aEImVGK+WyXS5bN86hVCgb/5CXnxhA7FYkgW9vWTT3dhumXvvvQ1dHWdyPI/nN5BBFV20EMg6gYBDh49y5ZXXsGTJIvoPHaRcKRCNZ/A9hUPDk2ixCHFHRa1Bs9bKliP7GDg8zGWdF5PwFYSnkHcrxPwK9XIRI5pi5ZwU/UMWjUaVXfs2k01nsCshvTVdrDBcOkxpYhdmLCCT0unqjuA5LjEjTndrlqNTHkq3xRXnLcXzfHpPWkf/pmcQdgTLKBAJdCSCQKoYEQUw2L55iHJ1hv59gxzutygWGiRS0Nou0JOQaTb5pxt/RSIRIdE2SlSYnLTyXHZu3YQQDvlpByMiiUQEH/7IO7nrJw+RVrNcecVbmdfbR9I32HLfQxTrFWp47JsYRVM1FnT0sXFqiJF+QTwb44ozruDkFfOoNBzufvhe7v/D79FjbcjAZtncDLVyDEcxCIomyRSMewoG0NHZixlbgqwe5L4Xn+WvT/+JK997A2+9+jpau3u5/dZfMWWX+Nqtj5BtjfC+sa/yzsvP5vglrURTClPDPv/wuQ/zytPbObBviJNOXc1E+QgvvbyBO+74+Zvi5d8EaAdBwJzODhYsXE734qXk6zXypXAJlstlOf6skwgEjI6OUCmV6OjroCWTpqM9xxNPPMbNX/4mX+lYwtHxOnMXncgV136ID998E0/8+RkuXdyHN38hH/MbxBcs4LE/P8x5116DzrHML41YPIEiz8T35vLsC8/Q3Hci4+OjSCGJJuts2v4IyVw3O/ZI4ql2Vpx2FWedVGR69Je0GAG7No3z6jNNLDxtiNVnzSdurKHe2IXrS6SrcGRkL2pyFII6db/E2rOu4rXXnkGksojSNIlUlEa1jlMJNcOqP0pvR4LB8QqiUefQgX52vd4gsngJH//oTXxozt1MPjZGzwvDrIp08v2Kz5LuZby6ZQeuo+BYGl/4+28SieocGZgim2miVK1x6MhmTj99HZddfiX//PVvk2nuIZ3NogiIxkwK+XFAecN+q2kaqqpSqVTC6Fs1XBCaERVVVRCGgVWvIuMpAHTNwHFC/XUikaBc9pDSQwgd01RB6FSrdSKGSYAkkF5ozBAhzxly41o4gUuJZhih+UQLkNJHEypChHSaMnsi0FQ1pHECORusr+F5kmgqgxk1qVpFauUS2WwvDdsikk0RjUUYPDJIprmFzq5mYqkkt//oB0wGDa5514VceumlCBSuuupKXt/xGtv37mbhorlceeU7+cpXfkLDmqRQKqObGpqRxBc6mgJ7+4/S/r+Ye8/oyK4ybfs6+Zw6lSSVslpSd6tzO3Tjds4Bu41JBobBY+MXMAwGDya8wJAZYIYBZmAIg4kGNxhssHGibZxz7LY75ySplVUqVT55n/fHkT3f+j5Y78/P9UdLYSmUaj/72c++7/sqgPAicj2tjEzPYafyOJ6PlVKoVQSm0crAoLGgyEhzwgknsHv3PmZm5mhrX0JKt2k0hkH2CMIAVYsRIYjYQRAAUK3U8DyPdNamWq2Sy+UYG59HVQzMlImasimVinRkCpTLNQ4fmUXvkhkfm6Re8enu7cBvKpixQdMPKU6McODIMZ7afpB1a89FTVvseuZxat4coSSzJJ/jax/7BDIei/tXoSox9UqDmIiJ0eMcOSTR3ruEWrmSJOcR8q2vfgERg+97ZFUZX/LQJQtkmWefPML+nfM8+9QRli1bxi9uvoObfv51MlmdAwd3E0URX/76d2h6Y5xx6kZSts6uQ6+w98AUv7jpTlQNSqU67Z3tRKGDrscQy5TKs2hawG03/TetSooXHnuekZFhxkuz7JsYoX/lUoq+j7JigCVdPSwu9KBZoLRkufVHP2bfzt0UZ0ssKSzGTOXQTIWpyTEarkxHzxANp0lKcohjD0kEXHzRGq77xPsIZY2eZTHvH7qGdacOsXbdG3j04f08/eKvmJw6yvGRPEcnHOaKYxzY9xI3fvyfkdWQe+65hT17jpEtpNFsh5/8/NvYLRq9fQNcesW5/OHW2/9qvXx9FG1ijk8exwtj5psOaiaNasnk8yaTooGdUehZ1MeB0RjncICuSjjNKppkMTi0mBt/9SM++L/ezynta6hOzvDQcy8x+Pvb6e9bxt6gh+WdnfzlpafpqNd5aXQPkQxvedPl/Pn+h/jQBz/PY8/cRdN8jqUrLeLGGK2ZeRqLOhne5dLbspr9W7fjiwHeuXEtz2x9lDtv/jGLzeW8ff1qepYM8se7N3PWJRFL3nAbruexpnsjfyiFrF/ZQU//ZjaYbewruxx9uQoNePnxe5ClENGAwY4so9NVfvHGNGvaJFYPtGE7bcxPz3DnfQ1OPNmikXdYbbm0doUM3/0j8r1n0HHetSjLLVKug/fU97n7wXtpSbcyNzfL+vXrObDrMLlcmnSuQq5gsHTlUsJQ544/PMVcsUpb/gRUSSVwI9B9nHoNRdLwfD+5nNIMNC0Jt7GsTNLtSsnl0KsZCpqm4TTKTAqf7t5+RkaOo6kahpWEQnX1dDN1fJhGs0Yqm8a0UgghqMzX0E2VOK4j8AkCD9dLMhqiKLH8gkBS46Rw6XoiN4skiBQkOcIwFGJAhBFeINBNC8cV9Pb0YegZ1LBCce4o9XiKrpzJ3qPHOGXdeuyMzezIMO9+8xUsau/hha3b+dRnvsSHPvoxnt3+Elu272PrvkNIsswrz93F9Td8nMef3MrTL+3mwUdexPGO8uMf/ZCNl13Bn+68DTvfjSwZ+GKGo5U8605ay9zci0xNzZFSMvR0ZBgeOURYMci3pRCiQSZtk8/nOT46QTrTwpKhIVo7Byg25lnU20fpqMF8SbwWrIUAITVeVcFRLtXwA4elSxZxx51/ZmDJIuLAxfNcYklgx63Eps5I8zgVN+Qv9zzAd773fV7etxXHmOPY/nkKioy1tI96qCObi/nJzZuRcnUqNVje2cd4qUFYi1AJ+eVtz6HrU9iFAvv370DHQFFjMq0ZZubKALQv6WDNql6OGnv47m+e5n9fcw5f+e5dfPHjbyGWLOrTRR7c/Dz1ZsB1H30jZ53r876PnIEfwIc/tZ5tex4kVeinwwmRo3bOvXAZt93+NP910/t48dmtZB54D5/7+Ol87V8/T9puxw8aSPjs37uPseOzTEwf5OILruTYkeP8+60PIOkGqmUQ5Vog00qhdzm9lokUw+GDBxg+8grbq4/ghwGPdd1Pd1cXJ6xYQ3NRk0alTBBXaTYCFEOmsyVFo7EX2VCZq/kggxAah2oRR+Rl3LfH5+w1OlPDsxyu5Xn2d4/xp1tv48mND2N1rKKlvY25ySMo0Rynn7mE/WMlsrbPLb+4jVv3/DeWbVKbP85F55+BaWTYe2CYpWvPIMHw/n8fr4uiHUXJXCyVMsnn8/QvW8ZsdY5FPYNsfeopdu3cy9jENCedcyrlcplKpUK9WmdgxRB9g4OceuI60obB3ff8iSve+g5Ko8MUp8s89MBPOfOMcxkfHWGgo5fDR/ZRn57l37/0Ge57+HFEFJJZZDK0eiXPP3gXR0/az+Xv7Ke1XSMYWc2Wv3SRCjNYlk6m3eTYxD5WDC2mZcNlnKpY7P7GfTxd2suebQFreo/gnqSSzrSRatfxNZv5Ro3KngJmtpcoP0ffopMoHt5NZ3sHLUuGcH2QaxWimf3YoUKbsHCRmCofpuLGzEuCyDIZSGuQhlFXwbRa2bvjAIvUkJnHdjImVGpAb6qdo0ePEngRw8e2sWbFCgqdefYcOMY7/m4jv/z5LaAYbDj5HHw/xMqYxIFBIJpMz00gguSSJEbB90MgXJhxvzpBlonjcGGeHb0Wo6lbJr5TJ5OxaWnNMz89SyxBriWPruuYloXruYQiACnpLkM/JAibCUA1FP8PZ6RMo+EQRQGaprym3xYiCdMXC4FE0kK+sQhDYklF03RUWSFQFRwnCfg3+/uZjMtMT+ylPDzNhaeewtRskVYTCouXoOXyBKpK58Bith06wFMvbeWf/vNboCpIXhJuP1eb4c1vv5bWnEq2o8DGSy4glzO5fOPbaWtrIRI+p2w4FUkxkGSJrGniO9N4tQb5fJYoDNGtNNl8O9XaPIEI0DSTyclJisU5pqfm6OiMCFHRUzm6u7uplMrUykXSlsm85yfOVWQUVRCGC3U7TuKJBxf3L1xmesSRjGlaGKaKKgx8WUOJY4JGg8OjRzm4d5RMrNDb00VG1zk6WWRkuoHrCeJI4plnn2B230O879M/w+/ooOFWURTB12+6hx9966vEWoL7UjDRFI1CR5pSbY41J60j9GSO7N6FvHIN6Xwrjz76R957zQXce8/v+cJH3s4nvvBF+ns6eObJh7nugzey7uSzyWUtXMdg7HhyUgjkfVx97dV89Qv/yhc/9yN0BmhrbeOXP93EuhPOZtPv/pMHHu2ivaOf3Tt20dGVplEPkIRBJt3K4oGV7N29g+6eNsrFGTp6usnqJpaa4tj4BLJu4MxUUFWV007bQOjUCfSY6dEpDu4/QK1cTSw+ioxuZYEmgRQjNxV8V6BqKeJIYJDEzUqqQ7Xqsm7tcirFKba8UOeNp6+mPO9RPqZRc0M++4ubWd7fSXd+KY3SGFdcugKViP2vTPHxb32DCy/eyFve/C7+eMcm5AjOPvUiHnz0Ca655h+5+Q9/PXcEXidFW1YUXtj6MgN9RR578WU8IVH1Aw4f2ItbLHLBBReRymd5Ztd2nnniSdavPoGUYdI+PExHTxeRFzM4sJjv/vAm/usHN3P1Ve/l4vMvoDw9S0+hhVxrC5EEwmmy9O/fg2VZfPpTn6L6YZfPf+ErDK1Ziyz3E4f/xD239mB3tjO4YYiZ5vPs2HmYvsIAHUpMam0LWUXjdyJNMHglS3/2WXLdLbz0pjcxH7yMO69Qr0VMz8wSKjHFWpHAA+abKOMVwso0a5adQDbXwqLly2g4Pg/dfz/EgvHhkHygsUQxKI2lCVSbqOngBt2kWwZot9s4/PxBFq8ZIv2ORewvlTnxTZ/g+x/7BGFvnmNT47T2diF7ZZYuX8fqVUNcddVVPPTwUzz8l8dZNDhEobOfiek5JCGhBTG+W6FeryP5IbEQ+IoMwkeIxBijq0rifAzDpGAqKiISiFhCRDGKooOkoscKe3ftpruvh3lFELoVyrMOUlsHubYCUrmBU6tRqpexc61omkqjXofQA0lGMUwURaNWL+E066TSdpJ7LClIQiTYqXRuIRkOHK+JEtjESDheE5MYy87Qlc8yUZxDIk2tUiPb1kEmcxK7t73AU1t2snpoCTsOHmPD2qV0L1nBG959Ob26xglnncO73/IOrn3vNSiaShQ6HDq4h6vf8w4+9AGDqWKRHTv3IosdIEW8691X0t3TtaArhqOHR8hmbNoLGZxmRKGQx3EbiAj6ejvo6mxl+/ZXCHyf8dFZOju78X2f5ctWI2KZ0bEptr30Ale+7wOkbJuZYRM/qiLLKqqq43k1ohCUhbFVLpvlX77yHwlRXNGolZqohk6z2cD1JcK4Skpuw1RsVFOlXpvH88ep1l02nHIJMwefQo41fOGiWP/IzuHdXPvWt/Pl657GrRxlyuvi0cc289bL3si/fep6IreBpkn45RBVF0Sxz2y5hOcH7Nl2iNZCO1e85e/54+2/JJfTODAzwh2/OZsNq0/kkSe2sHJoDdd/5GruuGsTN9/6rywdaiWfXo7dNsyJTYWp4zodnRey5aXNdHYbfOObH+HXv3sMRznML372OOW533HxG8/kvs33s2LxKpYtzeA4OYRRQ9cNwEXTUozMHiSdhra2PmSRZFQ3XAev4TE9PMy+fTv/SvVRMQ2Tptt8LZFPURRymRw5y6Ap+SBLzM8X0SQFu82GCQgCnc60yQ++dzPf/9LHCNWIT3/9e8yOz3PGG06jqzdNoJXYdajM/vkXiN0KP/3W/fiNeexIZmBoMTsPbOPXv/oZN1x/HW/feB5PP/Uo3QNr+cHNdzBas/5mvXxdFG1JkrAzKVra2jhl9Ul09PfTP7SMHdu2ccem33DhGy+lvauT1W84mW0vv4IexuTSGex8lnQ+xw0fuJrbfreJ3v4BpFjmS1/5Gl/+ytcwZYn7/7wZ27KRNJ1SOkOjWeMnN/2CZ7a8giTLnH/xm7HzOWark2w5sp1FS3o4OjtHaTiP0jdHvbCFbN8AobOc7lQrlqUzqzic97Y3kaiMNSDgu5etIN3ag271sGr9O7nrAY+hcC2hmyGf76enA1rSWX7zmx9hSTqH9h1AxB6//e2veer5Z2lrHKZ11SLG7Zhzr/lnIlr4zIk2E90tzKpZyCmc+vjNlMZCPnnjtdSbEvs/dCOVapP3n3MJtXyBaS85geRb28m3ZFi1ahVBEDM1PcvKE0+lVKnR1tHJ3OwcsSxhWRa1egVNkQlDn1hWiIVAlrXX8pNF9D/wUkmSCMMYWVYWdLWJ+xHdwHcbTM9MUigUKE6PE4UBjVqR9o4l5HIqMgLHS6JDFVmgaypBKINiIMsqQehhGAqViocWqEQxKLKGnjGpzczgeR6mqRATIUkqrttEVnQsK0sQJCMVSZIIg8SQc2hfkXPPWsvyJSsZGujmySceJd9RYNZ1GSnOc3R8mk23385tv/s9xw8c5tY/3s7AitWMHDvC+eedyXvfey0TY8dIZywUFS648Gw2nHYKba2tFItVxsbGcJpN7r7rXmZn57jwokvo7e7jt7duwjR17B3J2O8AACAASURBVHSiId+8eTOtra0IIchkbLq6LGq1Jl2dPYyOjtM/sJjW1lYGl21gUc8ijhw6SORHSDFk7CyuV0+CneVkFBRL0Kg7tLYW0DSNifFxAj9C1XUs2yaKfLLZHKVKnVhTUHSNKy65gBcef4RDR8dRRJbVF1/Hsw/9ifsPFHnw8QOsWX4amzfdzpve/Hds/ssD/POF59LVnaY8M0PkVBP5ralALCh0tDE+NkZ3oRPFSDE2UaNR97jvz3ch4gBNN9h0y8954rEtXHHZ2Vx+yRuQ1bNQdYUXX3qOA/uGGexdz0y9wu7nNtNs+KS1xTz3jODM85Zi6728suUOzrzonbzn2nP4X+97J4f2zPLnB37A+vUn89hjm/n0Jz/D9r2HkSQdTTcSN6EUs2b1KqRYIAmB6zQYGTtO5AekUhk62tvoKlxEKpPGtm1MTefQoQO0d3UzNjbGxGTCaqnX65gpi0ajseAnkIhiQSpt41TqC+sARBQR+gHRxDA/u+mHzBzewRlrVrNl+3GiQNDVO0h1cpYVfUt59rmnOLZ3Bzdc+1bqlUnSqsnhkcPsGTuKLAWoSsBLLz1PoaWTPfsPsWPPAbYerf/tevk/3LL//x65fDZec8JKLrt0I3oqR2tXF6puEYcRD29+gHe9890opopmW9RrNWrFeVYuH6Kzp5sgCnn2ycdZtXQpfX199PX0smffbvr7BmhJp9m1fTv5lhZyhVaE75Hv7ODXv76F93/gOhb0/EiqihJZnHbJ6bQsbmfJmvVUSr3c9sufIsmjnLtuMa16N8dm9xOGPod2HqEvv4gglhBmTCgCvFpMJJqofsRkZRYrk0p0x1GTMBS4zSRfobMzT0xA3Q046aTTeP6Zp5EB1bDxPZe2jElYdzCsNFE2hxdC32A7ftllZGQ/qi8opFrQ+zs484xLGZ+dxbJjYtfFq9dpzSsoqkRPTxcf/scbWLniTDaceg6j43PY2QxxBLaVZq40S+R7hIFPFDhopkHVDRO2Xqy8lncsSQpxJJDVBSu4BIqUWNBfzQwGge/V8Z0GKduiJdfK+NhhIMa0WknZWexUC3PzVcLYJxYOgVuFWMNKFyh0LcH1AkrzxxMXmYgRyAwMDuE5HvOVMrVqlYGBocRG3fQw7AyKaoJqJlEHhoWdypHKtaHEgi0vPkNbi8rc2JOEjSKKKhOFIWq6QNiYQ4pD+rs7SadMDo9OIpkmAo3IDyBwyWUzqLqEHzTRdYVc3mbdunVIaMyVKszNltA04zVdeSwlAI7KfDUZ7cgRkiQ46eQ1rFq1kl/d/FskSSIIBFOTpcSAZOdoOh6VSoPugQHef/0/MTU5zn2b/gtZTlGtRUgKNL0ycRwu2MMVunt6ECImm81y6OABAFRNJwx8JE1GM3TMTBuKrGOkLS676Fx27tiNMDoYOTzLhnM2sGXvGD94+laOl2O+cPqbyLgBcR7cI4/wnd/fwX1/+CPHDh4lp2gcPLibhuOgqBKmbSJCPyEShTJt7UspzU+hSRG+X6e9rcC8H/L4Q/dz/+ZnUXD45je+TP/AEk5adyLnn7uRe/98O6PjO7GtNFm7j13b9tLekefKvzufb37jv+ntXk7f6jauuOIynn3yKTzH4dD+URy3zBc/+0H2bHWoRZM8/cwLZPLtNBqNZFO0dKrzRU4/9TTq9ZBStUYum8ZpBqRsk7ZCB4qi0Gw22bFjB1EQUm4sZPCnUq/lYCNLhH5ALpMjCAKiGKI4JG2mSLcYHNx/iGa9wXQlZHD5pXzxe//C/MheHrxvM9NzJT7wgQ/QnBhhf3GWqNzg5EWLaYZVRg9tQTZgbr7Ijj3HuPq6D9NWyJJLa0hBjWPHRjDzS7jrL09w6qX/wL0//N8vx3F8yv+7Xr4uinY2l47POHM9XZ092Lk8hmUl9uJikScffYxYyDQDj67OHsrlMocP7ofECYqsJkf1V8k9UgTxq3G+rx0kQoaWDdLSWqBUKtHV1UF3Xy9tbW2EAdimgkUNTzaYmq4zURyjWZlEi3K0tbZTbTqksxJNWcYPIpzKLMgRaqwhRTL7x6foah3A82NWrV2BU54lY+UxTRChhWlC0ynhhvPIhoIu62iKTjZXQFHrpFMZmnVB1s5iRFCTJCphkfZcN7lUnjarldlyke3DI2QaCkozwI19FAJmvDIdS9egynWQIvo6uymVSsiyhqal+dUtd2MaNqlsjlgSRIGgWXeIhEez2UCSNUQUwEJ0j6oqSCSqkSiKECK5c5AkCbGQi/xqXkhycRghayq6lFiEK/NTIEdYlonneYjQAXQ6O5cgYp1yo0TolSGsIZsd5PJ9GKl2vNChWR3Bc3wM3UY3TVQtg67r6KaR/E2Sim1nCPwYO9eCQEJSbTTDIkbCMGyElmGwr5fdO7cxNzvMZZesQHgVNEOjPDdJKpujWhxjycAAhHW8uku54eOIKInnlBUkkSzaBNvWII58wsBh1ZoluK5grlRMDDELuEARhwu2fBlEsrmpWowf1Ont62D16tXc9N+bWL58OfPzZZxmstnJkgGSgmElp8Yf/vRX/MtXv8yB5x+kp3cJe/cdAynC8StIigABsmLS0tKCqmpYloXr1JmcHIcF/KysSggBWqoFO9WKpceccuE6SqUyL24ZIyzHPLLvCY7vKvPHHc9wyTvfzGfPeC9ROMM7b3wvf/rxJrLpBp3ZDDMzMxSL06iKQhglAFtFlZPcaRR8LyCTzlJvVrnn3p9jmCY5q5uJqYCHH3qI8ckRnnzqcS68cA0P/eVZvvvd7zO05ASufOsNVN2jxLGLKtv87Oavcc0111Cvz/BPnz2Hz3/5g/zbF+7m0F7Yvv0gb3vXaTx8/25iIdi1dQu//Pkv2fLKi0xMzVJc6H41Q6clZbJmxTJe3rqNTLYdZSFTJpPO03Rq7N+/l2KxuNCMxJiWThgqZDOZ1+StYgF5pygKtWqdXC6HEFBzakhBhN1qMjdbojg1STlQOfXC61h54lru+MUXuOW3dzI9dpQyOju37ORtl13G1qe3MDc7SXl6gquvegtNyUfSVd6w/hRCV0JoBq+8shVNqtLf28X4xAy51k4mii7f/peP/9Wi/boYj8TA8PAwzz77LJpuoupmAhHNpDjvjDN4/rktOIHH1pFRYgGaqqDpMrZtMzdfJptNoakGsSqTtzOMTUyiygoiVlm/fj2ZTArDiOno7sdxG5imzuTkBL7voaV0ypWYdKBTDebwQgclULHVLjQroOFOo6ckqlVAthGqTnvvYiLhUKs0CVSJ8xZfkZBzpusU5xyEF9DVLdG/qIPKfIid0okcHcVajDAjlFigBBYpK4tmRYwVSxg9OmEcI1VVzFKMbaUZL85xzB0FpQWnUuP5gzvIVTLkmzViOSCvazT1gAOlBrKYp1Gdw614BEHA4MByajUPXTfRrRS6ruP4DXw/SOjqsUDRVJpOQDZt06hXSaXtxPDgBq8V6jiWXnsxq5qaSPCUpBMPwzCxPochmqriuf7CRZnAzqQScg4JW89xHExLR1c1FEnDb0goioYsq69RuTVNw3c93EYDWVVBSgw7pmnS2dnJ9NRs8vPkAEWTIZLI5fN4QUSj6SBJGq5Xp9lwUWQVgUTdE0ihxERpgmzaYGJ2AkuKCeIAQ1Fwmw5u1SUyk5CqMAxRZQ1JkVE1HVmN0SSbKDTQNA1N14hEyKxfwjB0fC9EVjRSKZ0wDHEcL/keWhKAlWRJg+dFzM0lG0+5XKa/f5CpyVlUzaK7d4C1607i4YcfplKpUJybo+4IVEnD8f3/WScLEbWvbpxBEKAoysL4KsYwTFzPRdY0gkaDsifR0ttGWyFPviWHofez4awrueVHt7HxndfwwFc+zP2bHkUWL/K2j3wDZb6G2dFO6fB2Bs3TyNpZGo15XCdAkiIUSScMoySxMY4wDI1avQyyoK0lxePPPEVYM/nEp7/N8y+9wNl953DuGafzmS99kkw6xYc++GGQJA4c3M6+Q9vY+lyRy9+2ltVruvnP7/47F5zzTs4+93T++yf/hRwvJfQiPA8O7BsliOp89pPfYHS4yEdvfD8XXHgXlXKNUE7MRYKYXC5HrdogDJPXcKM5R0tLC47nUm802LDhPPL5PJ7nYKUMRBjhhy6KovDA/fejaRqe572WTplJZ3Ech2bTpb2zgBJD92AHvpuYuGzbpjQ1xXPTx3nD4nuZrO4GIfGPX/8erzz9CP2Leqn7FUaOHSJvmUxPz1IOqtjpHG+9YiOQRjZb0XUVrznNFZdexPlnvoHl/Yu49dff+Zv18nVRtFFkVq4YYmlvF3rBpuo2GOruJ3BcOtt7MK0zGRkd5ZyLz0MRsKR3EUOLh1AsiygWTE3P4jgOrhtSazS55+7N6KZFs+ERxzHTpSLLVwwg4pC0lULTNAotbcSyhGHozBfLBLYJXogIQ3QtQjhxQhGRLdw4wpPqOJU6tpljfHqUTNakVqlgGhmqQQlJrSEJibxp4Cgex0aPsn3njkQ2pGhYaRtJi5HTyXw4p7aSSWWQRIxuG4TTKoEvSKVbaM+kkJU8oSpQ7TY6U22onQ36TliRIJACDz0rkSnNEtddXKmNlNXANDUMrR0RyfzproeIaKIqMqoc06gk6X/NRgPXdUnnW1AVnTgOcdxE5VCrVTEMg3Q6neROCCBK0vEURSNa6EaiBSqNoirouo4WxxDGyJpK1uzAcxvMzZawbRtXkYmCiFptEj9ooOkZXM9HxJBJ2dgpk4bnI8sytSima3CIicPDNOerFBbl0UyJifFRUBX8IMBxGjTqASgmQRBRrjhIikpPXz8pO8voeInZuRmWLFvO9PQIumaQyVsYGZU4jEjpMrapkrLS2BqAipRyUHWD+aqD61RIt1j4XoCm66hKiiioo1oKimES+yGe5y0s/gBdT8gjIvZQAgVTT16TCIfI1yiXaqSMPKapoSo6YeyzcvUKxkYnaWlNM1epUnU9bvnZJjZe9TYuufh09j+9mc62AsWKQ+g3kjWyABVAkvA8j0zaQkRgp1O0tReo18sLOnUJEQQQWxA2ODbcxL3zARavWEG5bvIf//5Nlnap/MNV7yLdsoHFLQ6HwwEev+vXUPPp6htkUnSx+8groNp4UbjQxCuECxTx5IQRE4UhEoK0qTA3PUVQqXDfvfdg2d2EQY0Vq8/i9t9v4u/f9S5uu/0uVqzI8ZmvfIOzz8hy18N38adbDvLpL++HFHzzcx9DyUV8/ivP8JHrrmPHsXtYvuo09u9rsP3lcT744XfwTx/9KK2FDOtP6SBv97F//zCBFDA1PYGIoadQYGBwGXc/+BAxY5jpHAcP7ycWKpl8jp0796CqMrIS4bouuXR7kla44MCNfA9TlZAiBd3OLsytHWQEYSThST7Tc0VqkYNsqhwfn4JmlZM2XsKBl5+ls+dMeodWkckUwMpwfPgAnhfwkRs/yZ13/5Intz5NLpulf2gNv7ttMzOjDp/78hcxFJ2zLzmdf7j2KkYP7uTBBx5ixfIlbHn5ib9aLl8XRTuSJOxUGsNKEeQVunI9KEWHvo4+jhVnKNdmyLdazE0NE/g+5clRDh3YQ7UREESCar1GpVonDMELQpquT7laScgpQWKT3rNnD4qQ8J0Ey6QZOiKOcUIfUzGQYhnXdxLaDWBbNjEJwTpWk8Vh5TU0WSOf6UWSYjo7+ig3q3R3taJoGeIowhMRWZGhpS2PqqoM9i4GEeNGHvWgiSN7aIaKEsjokkZeUYjCECNOEesms0pEa6ihyzLjYZ1mFKC4Eb6sYboeju9hOR5KTRDJgoYfUK9O49k+Dd9hUW+OifEZmoFAMQwUSSKdTjE7O0e8EMIexoJqpYKVSmOaKer1+kJXHOPUG6/NrKMoIo4SAKusqLhBE9PUX+v0FEUhCmPiBSxY0lWqxCjEkUSz6WGaGp4fEcUOrhO8li8ioSNESOA7BIEKmoZwJKo1FyWbgTiiOHkcQhc930qhrYumGiJLMp0dBULkJKRKt2k4LhMTE1ipCsuXrOXw6DDtPV3ESmJ91xQVSYiEii2r2OksrYU2ZiZG8XwfISv4IsayU0SxwDTN1+z6QeAsXIAmowen0YQ4IIoECf8hmZHqRnJR54cBhmGgKhoiMOjoziFLHp4XUK05eL5D4MnoSgrTtOjL5Th0bBSMLF3d7XheDTMj0wzqqJaBXI9ZOLEvoKri155nVdUJAp/5+XlOWLuC3t4+pqfLNJ062XQndiZPS74LVXeRVbj73gc4ac0J7DtU5IbrP4ppjFEqhjjjw1htg/iaDqrANWQEJoP9/YyODhP6LrpmgIjx4+A1/bgqK2iqTrPp0du9nNVXnc7ZZ11ALj/ErX/4LW+5ch2KcZQbP/ojYkIOHa7xwffeyJNP3cL17/oAP/jm2+mwephrzLDzif2sWr6N397+HO+4/H0s7uqjOHeUt779bRRnZlnSewE79xygvbuN00+7jO1bX+aSS87EyvTS0dHBkqHFtOZyNOpNsloOJRVSqdZYtmgtUagg5JCGLqEbEVFcJxOlEJ5OKBxURQeRrA0JCVn1CYII09JBlWgvdHP8+CRmqkBxogq+z31PPEF+0clABjuXRw4FfSvXctLatfiyQteG9Zx/7qns2nOYZ7a/wvoNb2RibA+NxhxtBZuXtz7FaRtOpa1QZWZ2gtZMP7u3PUJdtpE725h7FXb9Vx6vi6KdimXkTGIzzjQFhqUya4Kv+6TTKcZLEfnWArWKQy6XQ09ZtPV0saK9m7SdqAccz2ViqkjgC1TNSLoBERIS4jgOIgJNkcgaaUQUUak3QJbxJBmiEENEhKEgjBYWhaHgeQ6ypiLJOn6Y3OjHwkeKlIQmLjxa9X5E4KNgIksRadOk2nRwIxkFheHjM6jE5ESCY9I0iVgOCSIfIcOEZeOpkAt81IaHqUE1WJirhSE5WUYKInRVoyHFaLKEklIIhSD2FCQ7TYsSEQQyg4ODvPDiyxwbHqNRB1XV6W1vpzJfoVRMKONmysLSDcJQUClOkmkpkLZtwlAjilRkW6VWq2EYiapDIIgjCCMfw9DwAxddMxFCIQpComjBmaiqqGqCy9KtFEKCwGvSrNcSyniQzFxdZx6EQFU0yqUK1XqImS5g6Bo9fd24zQZR5BN4LrIsyBYKuEHM7Mw8pmkTCx9ddokUA0XVaNbrmJaNnc7iBj7jx4/T3dlFrpAnm8/Q1dWBIurEUhLgk1Mz5LM2uVQaJ5PBsizkRuLadFyP9vYCmgqB5+O6LoZt4rtV/MDFadQRIlqIE5UIgghZkUnZJoocJy5NWUJWJCQRkU6ZFHIdSLGaIMViQUd3B+Mj0/R2LObokT1kW9L0dK7kE5/4Erf/4bucsKwbJTYIgojYNBGxjCLJCViACCRw3BrLCitpNBzaO7oZHj7Eju172Llj3wINRxDH+0ASmJksbrPKFW++nGZ5koH+c9m+fYSMonBkXicOZ1i2ch2HDj7PBRe/i527j9HbpuNMwFvOv4SJmTHu/fO9uIEDEqQsEyFCXM8nCmW8QIAEf3/N9SiS4PQzVvEP7/lHwlqRi84/j+GJwxw52gA54K4/3cPo/r109J/Akv4T2PTLn/DTr3+Bl77/UxYtXYy84kx0c5A1q8+nKUZYvnwNrW02s3PHuP2u7/D73/t4lTmUOGR0vEgh0KiPzhDvknj2OZ2Nl1/O4OBSlp+0hjXr0nz9a99nZPQIb3vT9XR2FKhPFNCNFsrVIqYVE4g5YpEhAhrNygIGT8MPI1JWmpoX0KgHzFfHWTK0iOXLT+f+zbcgIWjGSeSqEo0ztu8AwewUOcNndOQY37nhwwi3yJa/PEi2fZDdW18gXrWCfQd2IUshN9xwA/ffdz/pliwXX3wxadPgnjvvwG9GrFyznoGBAV58duvfrJevi6ItC0FLoY12u4+pHfvRMEgXdCJZkE6ZSLKF58csHRhClmVcr4mVytJ0HOZKJYSAhuPiuiGeH6IqSdH2Qg9ZgSiMCUVMIwyYc8sLlBSTMBYIVUOTXo0KFSi6jm2alKoVJDUJt1ckGd3U8R2fSCR4LUWR0DWLGIV8W46MmWJmZoZIgKaaKJqCQELWLTRNIQ4lZEmgESREFt1MjmqmiS4iLCdClyUaks+8FhNJoAqBEUZkNAtfEcSomLGKgoIQGm4UEoVN0imTlJTBNLIcHx1HU1Q8t0Yqb+M4HvOlZOwBSXZ5LBL7t6zK1KrztBV0bMui1hD4foCq6riuj21rIMeEvoepmURRjCJrC3NtDSH/D+Mu6QCT43MQhahasgkIoeAHPsQSsgRh6CQqCFUlnUnh+AniyalVKI2OoygSUZxcjKZSeUQgQNawbZswkNB1kyhOfo8kVtRCIOFHIaZpMV9pYgUepZkZujoL+F4TOawhCAiCCDeEcujgO3V0VVvI+laQUJBTBqlUChF5RIZGd2c7pflZ2vo6cN0GPb0deI06hUINzw0wDCuZn3oespx08UIkIwwRNvCaNZYuHySTbkFVpWScZiVLbnJykkU9vbihx8TRQ/xu0yaajVl6zz4JTTIJY432tg7q5Xm8RhOJBfu+KhGFgumZSZoNF9eroBsaoZ88962trZTLRTo6Oqk3XEwzveA4DTGMNNue24FuG9ScCqamo1o+h3bvANVnbr5K/9J+Dj7+IifkVvPyw09Tc6ssbu0k09GCrCrIhoRqqPhB0tx4UUgsXK6+6mqWLesD4XPxxRu54IILOGHlatavXcOdt9/EO979Yd7+lnfwGxEwvn+GQ8ceY0lrD0/vP86xT72HfdUSa76ziZVGK1Oje2np72JyaoyurpC3vv1C7rlDMHP8OGvXDHLmmct5/uVdPP/CyySmqwQM47kxciyxd89O/uMH72X7rkfYtmsXxdlxirOTia4/yFGvl5HqEAuBpCRvWVCSha6DJEGt5hDHMZdeupHrP3wDb33b5cn/rQyz5QAl26Q3lyWWWmk0agR49Pf3ceLaM/jC527klceeoLerl4wkaGnJsW3LVtywgm1oHB8fZf+Bnfzpxt2MHB+h4TcZaMnA7Dw520aEPtls9m/Wy9eFeqSrqz2+8porafgBmiSTUTWGhoZounOUxkfZdbhEOpulszvH7PQMrXaOFSuXo2gQSwJJMYhiKM3VEBGEQYyia9TqFVRNW5CvKYQBKEryvghIipBqQBwiYg9BjIh94igkZbcsFOwk+tGLIPBdAjdAVZJLCBHJaCmd0dFh/njLzXzkE58FRV5IJ4sQgBcEqKqCUbARgU9OyGiSghcESLJMWlPRw4gjqkegSqzKttFSyBG5PoakIhkGLx8/jmg2sZsBkp7c4Bu+jEtAGCaXhh0dQ/zxtjuZLdZxXRfTtJFlGafp4XkeUeDhew4pw0jUH6pCpVpDUWWQZUzTRlVSqJpOo17DdV0UJUY3NRy3CrGEaaYxDIt6vZqoH2QVWUrGJZEICEM/UZTEictRhAG+UycOG8hSlCT6KYI4koEMyYqR6OgZwrTSTB3fRuD7C7nDKqrViqLpCEVD1000NUXoxehWHkVTMVM2sWwRSwqGaaEpJtVAcOK6E3ngtt+z/rQ16PIUbmUSIQega1QmRmlWywRBQEtbHoBwwZUpIl5TD9ipFEeOHCFwF/SyMnR2ZZDjGE3XyedbiKIYXUuC/A07zejwMFNjsyBJDPR309nVxpLBXnw/4r4/P0aQ7MQs6lxKsxHg+VUyuQzLV61jYNFKtm29h1WL+9j5ygiOELixxdTkKLLkIGI/wVIpiUZ40aIltLd34Hkue/fuTkgxEhArqJoMIvn/Z3KtNJplNCWmVp0n19pJpa7Q0ZOlNDVD5M0jopAvffsmfvjNnyMXBP/x6a+yb9c+Xtz2InOlCSzb5PjYUTJ2mpShUCi0okg6IpbQdYNmw+crX/0E2UyeT3/qQ8yMz7B09XJGjkxx+uknYKab+FGdT934VZyax6Z7nqE4N8OhxzdzcWGQ605fSV//Ija/coT33fk4S5afxGxYQgidWzf9ismRQ7QXShw4uo8X7t9PR1eOL3773ymWq9TqKcqVKtm2FmxTQpcUVEUgfIW0baEZOpYVgTDYtudlvvXtf+P6j1zHOWecj0xiYJFIYMKSJCX8SkkQIeNFUHEiAiFTqwekUjpNAW4dUoUy/ak87fK5ZPoiZqYPYio+drqNZtBA1kxWLB4ipRnsOjiG2yhz/kUnc8oJq1i8ajnTo9Mc+c29HBg7gh8GnLdxI1v3HyA32MeJG07lV3+8i7F9r7yO1SOyTKFQwKg6zLoOkeeTKtXRoxhasyiGx5MPP8onP/Np3CaUqvOEkoSGjKJqVOoRmYxNFNbI5bLMzDZQIkhZaSRJwfUCBKCbOiIMCAEjZeJ7DrNT03R2tuO5Iem0TTrdnlCoZdDimPm5EkY6S6VeZWlPLz//5c94w2mnsyzfAZFLrebR09lHJt9F79LlHD18BCMO0NIGkScQcUDfon5K/hxuw6fa9Gkz0zTwyVsZxt0qBdXCCqDPyHHk4D4mH5jA8xo8v2UrtUqFm37zOxS3Ri6VpxEE7N23DS2bpzJbwTAsojjkxRe3cPDQGLqcjCpShk6j4eA5Dul0mompZiKJk6HhNMhYJlbGxHdcJBESBRKZfA5JaNRiMEwLz2/iui66riMBbqOKupBc73kBuiqDFuJ7IaalIkkKAQJFVQhEALEAWUZWLERUR0KBhVk4ikCEBrHiU50voyoagV8jWUIGqm6i6hoiltHQE5NDIJLAeDkiiqTECGHraIaObWeoNxtoVgZTykDlKM5sCx1LUihWO4op09beya8efwSkkBVrVnLueecRyxK6rCxQYxQQSRPzKuvyyIH9tHXkePffXUlXZwE3CKjMl6nX6+i6RhSJhMhuWTzseszOlAmDgHe/521UyzP09fQysHiQe//8MHEMOTvLxOQk/T2LaboekfAI/Jh8roMDe/bxsx98j+uv+hi+e5mO9AAAIABJREFUqiFJBqphE3lJp63IAhHHyJJMuTRPLt1Oo+GAFCadYgyqJqMYAiUOUJSYrO3S9OrYLXlqdYEXuHS0D1Kbb5LOtVGecfnmjzfx+MNPkMmpjI29TNuqJZRHhwnyFjOzLpkI8t0dRKHPfMOjODpCQTbRbBvPTyDNF218MwDLurpZu3Y9W7e9SBRF/PRXv+La917O3gPP49QcjhwfZ/+Lz7F6/Qn0XnkNLz17J8/dt5vLL7uUZReci/rAo+zZu4NlJ5/FkeGHWX/KIOYpy/nDHb9noPd86mtDJqb3Jk2FbKJoKoODg3iBh4hdmlFIRsshNI/p+jyioiAiBYREJjvIL39xB2Hos2XnIVpaTVwvol5vYuiphdgGJVHkyCmEEpPJWUiSQjqnMjkzT82NSKfSGJKCCzhEyF4ZyffwpHqSC6+lWbNkKYoko2g2QwN9FKegPl9hy9adqKTo6V/E9DvOIru/jdmJKe7c+RyrVq3hjLPOo1ic48qLLuEH+175q/Xy/1q0JUm6GbgCmInjeO3Cx74KfBCYXfiyz8dxfP/C5z4HfICEMfSxOI4f/L9WbVXF1HPUwwbttkRvoYVjz77E4489wsBVl9Gd7WL5aSdyxZXv5IUXnuOJpx5nvlgjt6gHJw7JZm2mpyeplJsQ65iajpBVIuGgShqaIiGLmDCMEUiosoTnORALRob3sn+fw1xxnkoloa7Mzs7yoY9+BDNto6dtvHqNvKKQbs1T6O2mOjOHebKFkbfINgO+961/pVZt8NxTT7FsaBAiWLqoi9179tBwakwd8Vg9UOD8y95Ie2snzTjkK7f+mK7OVtSjDfbsfImx40XCSCIYH+df33Q1x4+OsmHjO/jJvbdxw7UfJAoaZPMd1Csz3PDxL+BWS6BqVOebdHQVuPuu2+nq7mFqYoKUqRMTEQloeCGSptPd20Vxbp560ydj5ynPV7DSOpqm4ToNwjCkOD1JLt9GNpulWq1jmekFuV4ZRVVRNJOG6yHJ6oKBJLG4G4aB7ztIUoyqqLBgykFaQFJJ8CrRNI4T3bf8f5h77yA7yjP/9/N2PvlMTprRKI+QkIQkJGyLJBNMMhgbbIyNAQccwMYYJ3a9GBPMYrAXG2NjwAlMErAEkUUQQRHlnEYjTc4nn9PxvX/04HXda69v/ereKneVquZ09XTV6HQ//fT7fL+fr0ZYbAIXXbcpFweQgKbqqEYMoei4XsjMtiIWmqYjAxVfhqtLmqGhGVGkELh+qOiIWWmKPhTdIiouquaz4NjpBHaeiufT0tqGqkoi0SouuehSxvKjVFWncEuVCXIgBEiymRymLtDwQYapPbFYBLdS5mh3D7quo2lqKB81o/T399LY2IiuT6SuAPnMOJ7nYZdLbNywnrq6avoHM/i+JBGP0nW0i0hCEiiSHXv2sXPrEbwABnqO0jilgYObdhKpa6KmNsFg71A4GA4kUkA0GsHzNdJVtaE+Xa/GrowhEASei++ASolASPJZAaIRL2/QkGxDN2J0zGoimoigWSa19TX0Dfdy9Tevp7HKp7qqife3DHDScR/lirNPR4sbqIqGLn0sUyVmWniEDHNVUUjF0igWIYFRgcs/exXXfOeH3PHzW9mz5R2+9OWreW3VNrqHfIaObuVz13yXu2//Bad89HQ2rn0c2y3S2FZPZrTIVT+8hf6xUdRElMODW5g5+0Q0DJ58bh3VLZOYVKuye2OCZ57ZzS33phjvGw0H6eUciq6EIdNCJZMbDwfeE28miDK2XSZfKTKweydzj5mPI0sc2T9M1aRa0jVpPqBbIhU0RcGT4EkJwgXVp+x6NDRWkXAdCrkiXhD6GlBUisU84BG1NKZPn8vRvkG2btvIwiVLsX0P13fJ5PqIjMKC+cdyoPMAQ2NjbD+8j6NHu1i2bBk3fuZSysUyyWiUV155iV/++q5/XC7/aUGFPwL3AH/+v+3/hZTyzr/dIYQ4BvgMMAdoBlYJIWZKOaEV+gebIlRKCJSIQa0MSNuwasMGZiyci1lbjxzTUFBJmEkWLzuJQwc6KckKnqKQH8sh0Wif3sGnLz0JRVH43X1/IBqNYcRM4pEolZKNKUT4HxxUUIVA0xRaJzVz3913USnbQBhx9cUvXsmDDz7AzJkzsZQwuTs1K04ul2N8ZJjRsRGsRpWxkX5aapspuC4tM2Zw30OPsH7zBta9/SZViSQPP/IaU9un8KcHH0QJfCr2EM54kV1bdtHQ2kpTVRW/++XdFLqGyY6XkYpJ89K5NEXinGy0kT5pMafe911IxdDtDIGAM866kKcevZ91m3bQ37kPM5nE8WzS1SZNzS1oqkUkapKMx6gUMyiagSIkxWKemvomJsXSHD54iGw2jxkPsxalCAN+gyDAtytkxkdpbp6GrpuMjIygqoLIhEmBCSZJKZ9HmObE5fM/hgTf9/Gljyr1/4mPUhQUqRAIFaT3wXUSyt/8ABn4BH4Z25MIVGQg8L2wmCmGgmFFABEGJ+gKIlAmGBzhGwWqScX+Gy1zIFBNAx+JHo8QOBUCL1yW0bUA3/cpFvPkC1nq62ooFPIYuoLnuBiWgRQC09JQVZ1UOh6eNPDJ5bIEEZ2WSU0MDw8zMjoQ+gTGBkkm0+RyWSLRUGEhJQyPjRO1FOrq6ugbHMBxHKJWhEKhQCKioqs6ZlQgNRjvHydV00ggBKoeZXZ7Ey+tfQe/kCAetT74wxCAokC5WGTa5LlMnXwMD793LwFl0lU1LFi0gFdffhnPsRGqhgzK6LqFJsNzuBqIwEdTRBgdN/Eg1WSA5ygEOhRyHnNnTEaRLoHQoSCRfkC+FOAHGuVimYJfxklFUYRO17hP4Bh0j+xgUlUdf378d/z+0fv440P309ZSy5HBAfqHS2iqypuvvc35p13M8tPO4fLPX8jv//gbtm1azxVf+AYHt+3h8QefgphHvKaeltompnfM5pf3P8xZ51zCV79wMaedtpxzzziLSTOqEa7BtOZpHBkco66mmkwxi2aquJXwbcwPHFzXw5cqqhIjEqmGgk4mN061NZNI1OHq73+Tb3/7O4yPZ8Pr1wldrL6qIoSGikQGYZ561IziuJLR4TEiugVIPM9HN1O4dgFTD98++3q7mD5jNlIoaHoCp6LS2z0CMkWpVGJgcIy1a94kYtaS1jX69x9ixZ5OXlzx3+RyOX55z/14riAeT1LIj//devlPi7aU8m0hRPs/O25iOx94TEppA4eFEAeBJcDa/+2XNBd8TUevirH67vtJuRpTPzyPaYsXcv2NdzJ1Rjt6JEZrUx233vGfnHPhRRzYs4cN694i09dHxi1yeiLB1vc3EktU8ebrb1EsFyjbJdrbphCLxOnvOopdKVCyPCxU2qdOJpVKMLm1jf37D4aWdgR1TU3UN7fwxEOPUN3YiKWGQ5tYMkF7x3RefeFV0uk0vaMDrHn1daSusnfrRtasf5dJrc0smD8HzbWpMxdx840/YtuWNVS1VDFWHmNyaxvf/fmPqIw5HOo8SlMqzdlBnBuu/Dw/ffE9nlq7lfI5i5hx/7VkfJh/5XLKG/ZR0+MzCjz7wmOAz/x5C/nk+Z9ET6k0NzbxmQvPYWr7IuyKT8QwGRkextI13FIBTyqAQn9/P6aVZNa8eXhOiYMHD6KqHlJIUExk4KCoJfyKJDM+SiyexDA0yuUSsZhOsVhEURSi0ejEoE3iC5+oZVAqlYnHoxRKWYQakgEFE/I0KfClAoqOIuUEQ1vilIsTw5+AUnF8wo8ZLodIL1TvaEa4/q4YEk0KHM8BoWOZJtlshUgMdE0H28H3fbQolMcrmKYO+DQ11ZMfG0ZgY0tJb3CUD2iFGzasYebsDtrb2xG+i+tUGB0fQVE0LDNOoVBAVVUSCYO6uioG+4fZ2t9L2XZIp6px3AqKkmFoaIiGhgb8QGFkZIzpM6fR19PL9m27UBTYuWM/buBSXVPDeKZILBElN14mlU4zPDaEDDzMRDPz5x5P5/4CpUqZ71zzLV54by2jrsXo6Aih/XeiyPrhA9KKWiw5YSH3/LafRDyBH0i2b9vElrXrQBrkfBtDVpEbzRCJx8JkH3xEoKPpMeJVMTrmTqJsu+Sy0NqmEJGgC4VdQ2CrOjIAmRZoBqTqdQIbSmaUOFHI+viqiuvlKBT6MVSFp197lTlzl7D8jC+jKArp5lbi1c2sWPkOvV1DFEo2N//sdmTgU6yMcdU15/Klb/2QVdtWceayTxBLR0kM5nCHKqTbEjz56B8Y7vs0993zCoXiGG/f8E1WfeSjfPFLn+OGm77FyFCe++97BFAYGsqimwqaOZF0FOh40kZXfISSxfE8EnUxalqjOLKbQqmE7ydxfQ/fKaBPzL4URUETKjJQUISCdDx0U8MtOyHlUDEwzRiel8GIqXhBH0KJ4DplmlrTeHaE7t4eBBYDPbtom9rBcYuPY2hggEWLp1OxbZZ/7GzikTQb9h1kTnMjyXiMZDTC4UOdvPLSc3QfOUqx8P+P5O9qIcRlwPvAd6SU40ALsO5vjumZ2Pf/2IQQXwG+ApBIJpllVLHn/V2YEVh4zgkkjlnIi6+sIRpESA31sXXc4brrr+Lfv/t9/O98j4qucmjPLrasWc/S0+bTccwkopEWDL2aRSctoeSXmTf3GPZu28vYSIZPX34p3ugAjfOmozsBL770Cls2bGaor5+IbuB4EIsnKBWKFPI5PnTyh6jWYsRUg1KVhVKXpLXk03d0D+P17RSdIV55/El8X+fn9zxCr1Jha99jHB3upio/harsCNmxXmKaxHIDZlQtwS17dA0UGNh7FCGgKz/E1Lo6Jmk5zpg+jccHDlJvN7DbVzCEypZH3iWoOAgtjqE2c9s995Af7WWw0E1WH2HO5Nm88tLL4KgoMpTlKZpBNJbCcRyErhM3DHK5HKXRPkp6juqaOJZl0dY2lexYjopbxpcSBQ/PGQJ8CoUcKIJ4MoHjVcK0GDMSMlRsHyOSCB2MqkGpUMKKRqlUwm5K+jJMnJYKQkgCCVIRKGjICcSqQCAJFSJIBUQYIRYmt3ugTejEXSfU7lfK2K5DLFlFxfUQEizLwtAtiqUSUSsMA6iuqUNIGzdXZPLUNs477USKQ+/hORojeY8F8+Zwww++TueRfkrlCvOOXciGDRuoq0kRjVg0NkwiYkYZGRwlHknz09vu5Bc/v4MXXnqRzs6e0GMimBikBggRPnfyOQfX8xgdyTBz1gxy+QKmpTEynEE3oaGhmsBXUFVBuVwmFosxNDpAbWMDuXwBO5fh7dVPs+z0c7jltl9x+79dTVNDA/1dNkKLgZ0nEC5IQdtx5/DNa7/MJy8+D7us8LsVL4fDX8fFUDWEoyKlDslqBlWPY2O15AojEI8zaAsatSSB7aAMZth/oBvFF1QZcd55oRtPSTA2NkRNnSA7PkqNDBjZtQ1ZrEC+SCGXZ6hQJiI9RgaPkBMeouTilcu0TjmeTtVFW3ocsZFxpjQ2oqbm0zKzncu/+WWKR7qQbplvX3EV533yJJ5/+k1+8YvV/Pa+27jh2ttpnHErVYk6VMvDtYuobi2yqFCVUJnykTk88Mh2TGsWNY2TONzdw6WXfpG+/m5+cddNzJu3gDPPOJt9R7swIxaVShYpdLSJPFIpQxOYrEhKhSw7Boro6Ph+P6qqoOk6qqaBCIeRFc9FVww0VSUQPooKnh1gOyWE4eEpJbRIKAOOJIqUxlwUkSRQTFL1CTzHQgaCydMVjpk7mdaWdlpbOpjc2kBzawvZ/BjpeITmhkbGxjLs2LGDutoGRq0ovd3jSBlHE9W4cvjvlc7/d+qRiU575d+saTcAI+Fdx81Ak5TySiHEPcA6KeXDE8c9CLwkpXzyfzt/Y0uzFAU4femHWPKhFDmlyMG8zkN3/QVPNbh5cj3bh/oZaG/i3Kuv4qb/uJtPXf11rjjtVHrWbyf/xDP05Quc/eNbGDU1Do8McKhrK3ff8jOiwiDwAm6/7gamzmnjitv/jdGeQURFIIVk0ZLFHDe7g8C0sKqSXPu9q3nplVe58cc3c9y0WZTsCuvfWIMIFE696QIuuO5C3nMO4Vbp/PfsG9izfi8H+iqoosRbXX9g55Zu+taqJDIFvnblxcxcuoRoY4IaTyNZV0fjlFayvXlwU2iGjueMI/CQigAhmT7/eO659b8448wPM9ozQO/+I/S91MUX7r2Vlw5sZ9XKx6lN+nRmuhntHeL39/2B1nQHnUcPhAOxaAJdMyFQgYB4LMzo8bwwPiybKeD7kmg0SromjaLEKecKOG6Z8dI4btkOHXVAQ+sUYqk0Xfs6CZwSkbp4aM32ZBig4BSJWlHK5TIoAghQJrpsIdQJXok/ocgJILDBy4V6YyaMOFIiCc0aMtDRjAhCi6GoJopuIaUgFjExdZ1c0cO0EqSq6hkbL1Jb10ix5GFYJrn8OG0zZ0G0Dnd0iL6Df2Lm5BlMb6nn8isvpvdols7OLuLpCg/95VnmzDmWmvpWli9fzqc+cS6KAqecchILFy7m3HM+Tjqd5vrrr2FoqJ94MsHo6BiGGgklkF6AH9goIiBfKBGLxSjbJQb6h0nE0pRKBSJRk0qlQl1dHZYZxfUqWFaE7qO92GUP33dBCaWG8UQ1+dwYl197E8PvvsZdM+J0qjV87OE/oakCD48vL5zLCQsW8epjG8gVjpCOTaapoY4Bt0hdQzXp2gSirp50cxOxpihD999DXaBTLA+hJBXq1CTT3CR1Zpo18ii16RRxX6EqniZmqOD65CsltHicplmLOXiwDzXiU/HLoZS1vhbbNPjxn59iOFD5z4vPoyrjUGWXyTk+DenZ5PwIpcUn8kznk6zftIazL/461WaKJ59/krilsX71KppqOpi/qIOxQh9r1q6nOjWNcuBy4skLefX55wCX9smz6Dq6j3jcRIta5DIe55z+SRYsuYwnH3uAI93rKJWOhtZMCdOmtnLdd67mox/7OM2tMxjNFPCkh+t5CEUipILreRPD5oAJZSqq0P6HpzMRSv2B+cuYYLx70iESiYEaxfU0hor9xGtieK5OSypCo9aA4Tfi4iLFCEIaSGJAnHS0nVxpEFXJgVpLz9HneWfDNt7auJY3nn+QoX6HiKlhGBrTps0gnkyzcd375PNZdF0yPNLz/516REo5+DcF/X5g5cTHXqD1bw6dNLHvfz8fgiu++nVm1tfTN/gG7cfO5Hc/fRpPGCSiNRTjEab6SdbvGmTjayv5zlVXceev7uJPP7qBV8dH6a+UaGlppV/mGcz4mFFBR00TSPA0D1cGPLfiUeYcmIOSr6A50BCpYnJDHccUPeYd7iOmghWPs+ZT32LPrt1MHsnw5r63MWRANGrhlh3OvO4SDkfH0TXIFnLMv2Qpq15/gaXzTqVkJdizbgeH9vewfN751ClhOG5F1KDJOg4PxvGHx6kMqWiuiqdlIF7N/OMX8ZNrv0dKq0ZUR1m0cCG96/dwSsdiLKExHjM4ICJEJlczVMlQCiocGRtjZmM7t/zuYdzxPGaDCa6H79g4ioGnuDTVN6EoCkODPbieTT6fx/NC2RhAMe+QHYsRTVTTXN+AUONE0ykquQIDfX0E0sMu2hiqSzpdw3gWysUKVsTA9Wyk9FF1lYpbDBnUwUTnjDaxnj3RDIjQNSgJJqSXwYQbW4TdOGFyUXishqYaCE0DoaDrelggXY+y56MoBkILXZiqqoZr2opPEPg4FRvPDXDLeQ52bqd3/yHsXJ47fnQTI0NFTjzxVGz7VTSzxBmnnUUkGiOaqKXrcDf33fcgqWScvXv3UF1bS6FUZM7c2dh2ib7+HkZ3Fjhm1hRqq+LsOrAPy7BIpeOoKEyeMwvbdtmydSsnn3Qir696m3Q6zfjYODNnzqSr6yiKyOEH9gR8S6KKYKIjrGBYoYRSYvD7u39M2rT4+iHB/ozPtEkzkZpPOjvKJ6cey9C+bs64cAlNZ3yTmdPmghWlrW4qer2BVKIgvHCVWgpee+FNml0F89iTOOwM4fWMEa1E6c2XOf3Sz6EIyVvPvUJPbhTVDb8P27MpDvdzUtt0jox0Y6QNYukYR7PDGOkIBbdILgjXxa1sluqiQI8IgqxNTbOBUbE4mMkxb9HVHMpV8V+3/IRf3XUzkfEMy8/8KCsfe4Krr7uU9e9vpCrRTCxaTbbUiyZTrHt7M6CQrkuRr7ggFYo+kM0RS03h+Zcf4eXVq9AFfHjpaaxd9wxBUCJuxjna2c1Zp3+MR594ik99+vOMjJepqqkGVcX3wuvOMCJ80KDqugKA73gh5AtA/SBwY4IV4/qERGKFUtmmqjaOZweYZgxLjZCOSJI43PTTH3HC3BNQNIEnHUwtQjxWhWYYxGIpHKfC66++zpMremlqakJSJlGdYsrkpVxx1RkMDfWw8vlnePW1l0BTqE02UrHLaJr5D+vl/1HRFkI0SSn7Jz5+Atg58fNzwCNCiJ8TDiJnABv+2flcP2DEhezhThrrU1Q3zaZ3z270+GyK+SP0tFXj7fUxhctTz6znY45OMFLiJz+/kfa5HbR+/3yy/SMM5vfj5iWP3PwLnJECNyw/nz+8vZLGVJpK90Ge7j7AcESBWJKOU07CtXMc6O1mYWMLZnaYiudSjkUYUIYZlOGaq6NqeI4NVQarH1nNeE2E5e1L+N6xy/jM2udJfWIyr+56l12dFSY1zKC1cSZLUk3YhTFWv78Wtz/C/Y/9gbufuZfAcVly+ReY1zSZ3e9tZFbHsTx994385JVPs1B4tCpR7gk0nlMKSF0nnarjjAXL2bNtM0p1FQMje/noWSdT7D7CW6+uomtPF3X1bZQdF03XcZ0KuhrB9jx279xK6AICfD/8qoWJqgoIPHwUPLdMZuwwmbHDgIaqptCiUaZ0TMGyLPbsPkhmLEN921QaYnGKxXHyuQy6aYWwookAA9dxUCYueB8v7LQnhpa+54WvnUFoYJq4fpBygsYICDQUoSH1KBXPJ2JMEARdF1VRsO2wSzJjSSQKqq5RsXOouo7n58J1RhVqkgnWrVvLlZcv46E/3cukhmomTZ7J5q29/PbBL7F4yWzuuesefnH3Pai6gRlNIYTKgQP70JQhgkCnUA5YvW4tL7z6HFXVCb505WVEFJ2h/h4iCYO6STXETJNSLotpmjTUNWKYFsfM6uCVV17jks98ikwuy5GubuLxJJnMGCMjI0RjIfUwGg1BWuVyGV1X8b1KqPO2ojTVz6BvfJi1ZoGSlHzi+FNJTkrQ1L2XcvdRmtsbaL/yXNpmnIAiixzu7OHNg8+waesuzjj3NJ598Tmu+/ENIGrYeWSY9oZmlOpahrsGSFU0hIzgKAHZwRL9vd1E1CocWQ6/s0ClJT2F8WyGvTsPU6q4yGGP6FjADLsGZbeLHovx9qe/Td7NYR8+iFoJGEsFOJqOHqkmV7Gp+eSJHHEP8JOLb0A7cBXf+84tKBGbo93bWbd1LQ898hwBoFLG9VW+/rWbeOD+u3EKKeYsmM/uXZuRgcuzjxd4YsUbvLb6LrLOZmpbJaam0nugxOHunRSLNr+650Ham1Pc9bM7eOKJ5zjzrHPx/QCiMUaLxfCtT4jQwWq7f732PvinT3DhQyCajyTE61o6GIaB4zioemjiatQUKhq8s7kLNaFQZfgsnT2Pa6+5Er/okUqbobFPC1D8CBXXCQ1tisGcuRfx1WtKvLqqg6Ci0DplKnsPWWTtwzz17MtY8UamdFTjBw7lXI6kkcTUdBj9B/X3ny2PCCEeBU4BaoFB4MaJzwuYAPQBV31QxIUQ/wZcSZibe62U8qV/VrTTdfXy/M9cTv/RTmLRDM8/+zpC6cDzk3zlK6dz77c+zp/+8ghP/vJPvDmWY97pUzhn+fk8/MOf0yfh+ts+Q1tbLdYgZDI5Vu3qx6mu4YU/rECVAR3pambVJolFanlo20Zq040cfHsTfinDtz60lKXNtUzPVlh48ulssgxe3biJUsckfvXcCoTQOXJ0LwtOmM+jt/2akhWlf2ozLfXV3H3d98jEiwzPT3LjOVfyH7ddS/6xfn7xwMNMqjfYfHgf0z7cQXewkc0776A6cTzPPJSn0NfEA//1BgePbOTlq7/EuU3VpGpqcUyNx974bzZIH0GAikrKijBWKXDa1y9n6QWnctXpn6IRk4suuojtWzvxEIyNVShm+9B1Dc/Tw6GKEiJCdcMIYTiBgpQKQoNAOli6QdF2MFWFciEX6ujcHIrkrx2JZqQRio6IpIhF4yjCAkXBmyDNlYo5XC8EK7nlAiARio8MxF9fXRW80LyED7KMkBWkFOFDZKJnUFUBKARqIryZjNCwoohQVoZihjeAkUQKjUQiRanoUlVVRalUIp/PUVuVxrBM/njnjUydZhAog4yMDbFt2xj5vIujZVl0fAeXXfwFVr3xJj//+X+xa/dejlt8PBecfyHjI6OoqkaAwbad65k0qZb316zGrQTEzSSK4hBLCKobZiClz85tm5k2ZQqLjluIqqqsW7uZzq7DSBUSyRjHLVjE/v0H6enup7W1Fd1Q2Ldvz0SR0NE1k0gsjqqqxONxzGiSwC2TqkmTjKo0WjVsHtrHoewQHQe6OaMvS7E8xMkrHoTmE/BEBVVJTNzEHgQatpLH6T7A1pfeZPQvj9ASSSH1gIou0EuhSmjcddFqLXzfpTxSoK6qBq+iUnbKCFVB+gFGVCFfKuCZKooU+LaP56t4SDIVH1XTcQiwNYnqVWhU65k1bRl7c3DpY//G71bu5s/PPs3sjo9z2UVzKeaH6Nw9zDc+ewZt1afTO3IYIQKEkqW9YTbTj12MMHK8uPJXCPLs3bedmoYWquJJDuzL4NsZHvztCE8+fxs9o89jWjHu/fWTfPbSj2FqBjPnzOHEk5fx0ptvc+NPbgWpUszl0QUIJeykc9ksjhMOrIulEr7n4XkunudTKBQolcv4EwgLz/NCdIPnhZmbsQSf+8q3SaRrqG+NEUvJiZZoAAAgAElEQVRb5DPD6GKMWakGIkLgy1J4f4QaH3zfJgiiqHqME064hLdef5SBgs1IucgN//F5spk+juxJkk7Fce0i+CV0TTB9ykxyuRxtk5p57OHf/p8tj0gpL/k7ux/8X46/Fbj1n533bzdFwt4dW6hKJ6itaaS2qoqxXBkcn8nTOzjUlae+fRqNUZ2ZowGb3jjE3td+ySKpMN0wOPTDx2gyImxzygSKRl8qTqW5kVltM5je2ExzMsrWt15hTPbSPHkS8WQdD2xaxdNPPEJ5SpRZy+aTrWvgGV9wy8MP0Z0tkSofJnbbD2mb1sbWF9+lPOozLMoUK3l++85j+E6Ae+h9Rgplps/4OK9sXs8l517G3oZ+nn7qL7S2ROkplqmZU4WW8GhvW8TcjlNZ9+SLdHudXP+Dk6itr2a4uJ3uQgOpA1VolsmMmlZOueI89mWHOWb+Ms47ZTmr31/D3vED5Ef68ApZ7v3jE6x8eiW1DdOJV6WQsoylG/iBh6YqqIqC0EK+iJxwJ/qKRAYKQjNQhUnZ9hB6mI6txnVU4eOWfYJKCVUR+IGP6xRBMcBxka6D0GIYeghT0oQgFotRLBbRhI4aT+A4FZTAIwAkHtIP09aRPuCGA0rggwsbBKqiImXwVwu8bhp/Rb9qShivFaJbJYaqEgq8w83zPFShkMtkaGyoYWi4j/M//mGq6wzap9cxnhnmcFeB2rpGfv2He9i7by8dczq4+dZbaG5u5pprr+Hxxx/nqacf5/zzP8GRrh4ee/RJautjfPJT1/GXh37DMTMWEU/WM39eB0bEIVtQef7F54mZFm6g8Ov7HqCrq4uFxy0OKYqlEqql8fBjTxCJxEinkxzoOohhClramzFNk0pZUiiUqKmrZ2hohHy5wnipRCZfQGR7qUvFGTCGWf3Oe/SMjTM50UQ0PgXVSlI8VGTEGiD+/gbyA2NsXreB3OEu+g8N4Iz2kvcEDe2TmXbMQg5rRTRdYbRcQCQVSpbGiAjIVsZBVbAaavEdl0haw/HCGYiChiNd9GQcxdSpeC6peIqSEyJoS5qGg2TcyaOrkng+xZaRHEc7onzs81dw7k0PkO8rcfkll3HeaQ1kgd1dHnkxQLHUj64G6JpC+K7nMjxQoao2wooVr/LiS79C+jp/emQVN934cfJ2glkdtUhRyxkXRplzws/42jeGuPSyT7Kvp5Of/uJ3PPTEE+zbt5c3332L2//zZ2zZsYtcvkxtuorqeBzbc7Esi3iiCt3SMc0QVRCGV6tYVhTLskIGjRJqtVUVIoaFUMD1fYJAkqpKULRVegczlIou0WgUv+ShpuPhrIYIQRAL9f5INBSKrouiu3zqsyexe+dO8kaKo90+7shx5Edm8qHjVTy/xMjIIMVSOJDfuXsHiUSC+vraf1gv/yUckfgOH1pwLFd8+SJ27V7DJ86+gOHOGqxEHVMXuDz39gbMUpFyReeOq69n1Zr36A0qfPWab3DfHXcR2dtLv2tx/TXX0DeU5+UnfkMmk+fYk87i5dUraZ9UT62RQitnGOsbJtPVw8r//C1WKsq+Q2Pcc/g5RgPwFEkksNCAYDSPc7gXUaXRurid2pFj2NL9HlMmNbLYjOM2RykvXUxrtI36+mM55czPk3DHeXT3g3hTR6meqWP0VWNnqij7teyvaqBiDLO/fi/HHD+Dace1Ea1O8J46CzVyLHdv3kPetxndd5Dah39Pnd7E+IECxUPdHOjbTVVTnGptGsl4jGuv+Q7pVB0j+RIFx0F1wiKrqwraBA/Dl4AiECq4gQ1YqKoJQZhO4/kqujLBUBEWUhSwYvUYsYDsyCCGruDik6yqwSaKU84TZLrwUPC1KEYkihVNkEzG8TwHtyKIqAk8xUeTEumV8bCRgYsMXPCLodlGCkBFVSzCwh2ukSoApo5qmAReSJLTFUHF8TGtBFJoqIaKLzUKrkskpqBrEUZGukEEdHcfYFLrVF7Zspn3125GNyO8vmolbf1H2bNzF1dcfBlHu3uZPL0NX9N49a3XiTTVs27LNuYfp7N+83Ym1zdwYP9RMiMu729czTvrNjJr5mI27TtALoD26UnOPv2LLFq6nNvvvAXPTFBV38zBziMc6O9B1zQc28NM1JDJQcUDw7IwtRiDwwN4jJGMxRkaHcE0Ymza/gbV1dUU82UC6VLf0IRiQ7FsMX32VJLRQaa6ZSrNc/j3gd2MCZXFTz+CssImagpc30erscgbUYpzpuDKdmTBw0nE2FM4CoogEYvDcIm4ajE0PIibiIRJS7aDEzIfML0Irl+h4hXxAwXXasB1NYojDqauE8u6RD2BEB4yqiADh3Y/gl8uEknGqJ81k4FtPSQ+4vIfX/kS3dkR8l6EF9arZMcrtDdMIlJxWLJkOfPnTuOlp7pobW/gmLkLiMWLVDW28/rrL4HwqG+bzB0/vo4b//3bxLUsvgjAjrF67dOsXPka9dPgqVee5frrv0Rjuoof/OB76JrCGR9dzq9/dS9LPnIqJy87PbS0K+Ebo9AUPE+iqvw1kDoIggkAl0sgBeWK+1eCIgTEomnK5RK2U8TQozhECTwFXxUEio/rShR0JAG+kkHBIMAjCBSkGENREkSiUV5/YzvXfvNr3HnHau7/w70k0iqtbXnqawyisSSqGmPG1AWUSiX27TvAzCkz8dyAbKH8D8vlv0TRFkKhq/MQXZ2ddMyajvBifOzUU9i+Pc+Lq+5h3cZOBg7sZs6i2WwTeTq9HG937+XQI3eTHzxI0NDKSytepPXEGZjrNtK6dw23f+7L3P/cSu585AHOWnQCXzvtHOrqq7j0sxdj6lHOOPs8sr7NqUuOZ1I8wkfTrbQ013NyxwmMqwX+sOJBnDafF3s30F0sMNS/myrnY8T6kvz567egpGJMXXEKr6z9I9/8wU001aY5vGY7Qa7CkSNjHCkPMVpsY8ZShZiv89G6ADmeQx/wyJFjqG4MYXvk8sM8+9qTXDnzDKyaFJunN9B3sJdcLsCI6vSNDnDxiefx1Ft/5kd3/YbuwVEkLoEeELgelpWgWCpP0OXAtYt4AaiaIJACFAWJghQSHR9VDR1+lmGia6FBwNItgkChZDt4fg6EFkKehCCfLWI11oPnoZoKgVNB8Sq4+XHwkhCtD1+r9bAjUaQCvsSTPkJI0AS4AolAyoAPnJFBELrqXNcFEfKMVdUAKdE0AyEkju/hIzFUEQ4yfUK5YOAg9DSqJvD9IpRsIukGOuYewwVf/S4DR7uY0jSJkZ5uprcZZDOjNKSacSs+ZkJn596D2JWASc2tHDl0kOaWRhRs9EicYi6P6/Vz8NAOTD1C33iRRFULowWb7N4D7D/8O9SgTE9vP1HLpGLbRJJxmprryWbz+L6G7QREUya+byM1CwyFii8YGslRKBYZG88TUKCupQXXdYnVVdPSWMXmPduIB1B2PBZ9uINtowepTdZwqNRNrCaKb9sYySqcUglXC8hUihiOgWrVoxWKmJYGKYkse6RkHbbiULaiqC1JSr5K1EyRDwLaYnGihklRemgRnbzrIKWPpobGFLOsIksOQXXICheuRPUEXuBT1G3KShWqn0AtO3RTxCtnMPfZdK7ZRk9hPj3iKCkjTq2YzvHLTG6+/k5WPHw78zqaeXTFm5y0bAlLP9LGHbd9FwKNb91wO7rZT33bVOx8lo5jlmMogBsj748QUSxqqqexY8vNtMw4k3LuEFvfWc9Afw+333wbuqay6pWXWf3SM7y/owtHChTFgSCMgjMsA4JQnx8EEt8PXbyIMEjig+CDD7JQgYkIM59YIk7gq4znsmiqQdlxEAGYMQsRhHx0VQqkwsTSl0D4UZAqQlPYtWsLJy5fyPXfO5njT57Mrl0HcO1RFOGxf89OKpUSR7oOYVkWVekEXZ29tLS0sOaddX+nUobbv0TRdtwKw2OHuPfXv8agmvradlrb97Bw8fEsO+njjGc3EjVqKbgOw9WTqV4WZ/L6JMdOnssRp4bWKdNJzqgH6VG/dCkjOY//evYJWurquP+GO1mzcBFuschg71E6N2+lzxU89ewz6HEdKXSWzVjKR0SabMrgtb5d9A8PsCMH2x9+muO/ehJTOmYwcDjH+r88SrtX4v4/3U9kynwutBIMnnwGowfgwVsfo7mtlsMjGTo3H+TqCz7Buu5dBNkiuaCVI2t9EtEEuteAMwqFo/vRC41QXcuAkeG2Q6/hbVKJKCZv/eomqlWL+sRcxi2d93/6nwzseo+VL6/ky1d+g2RVPfl8no6OU6lUbErFcQJXki9mQIQmGE0JUIWOlPG/Sus8twKOhq5ZE2oOFbdkI6JhmkbJySMMA12YeLaHdCtIOyAyPkDKSpC3ZuOaYDvjqIbA9cZxRg+GX6IKpp5GqhYoAlULkEH4YBEE/M/CyMTNIQIc35lgdRsIXUOREHgS168QBB6aYSJUHV9KpJCofgRdi+OWe2iaPp3xXAnVTUIwTGNLnIGBfQSBxdD6LVz0b2dTt2QRx01p5N1Ja9jT3U1XZgyzmEJ3S/Qc7qW/M8+U1sXs2DNGsrqTr3/tGppaZtHSPIveAZu5s1rY9u6rtLUtIFcYpOiN8OWv3EVDQx2VMnT39JAfc9i1p5+6mnZyWZ+ekWH6R33i2jSWLj6R6dMhGvV5c3Uf+3ZkWbBwNmlliEzWRimb9B8ZxXE9tr65g/rGOkqGYNPuvZxyboDZ303f/t1c/7M7MaVGIZvjyHgfuhKjUCqSStdRW1sfAsIaIpiKyej4GEaNiiVsdqxdjzg0DmWf4bJLU8dMRLbCjsIhbN/GLjtEdZPqZArFMImnalFlgKN6pFIJut/vI2Il0FQTXxhoho6CglYskI4HCEOlTcZQbZVZZx1DdriL7PO7mHLmSQxn8nzj2hPJDKwFP03cSrF7604UAbt2HSJQVM6/4Ex279zD5nXPsOG9jSSTNXz80s/w1a/8EKE2gRzljl/cxac+cQ7fuuajXHtNJz4mA4N5Lrvi80yZPpOewR5OPfVUJh+dwimnn86nPnkJJ550Bqqmo5vhMNFzbXRNp+Q6YSMhJE6lhI8PfoBt27iO89dZjorEdmXYBHke0WgcpxKy4IsOobksnUIXGrlIG421zRN4BnCBQOj4UnBkfwnVms6NN/+eiGIQrw5ZKQ1Vk3CcCicvqwvxCBNZq5qmYUUj+L7PD79/LcuWHPN36+W/RNFWVRXbdUhpOt1H+xkcKpBqmMTg6AgDhV5GR7fxtW9cyrKlxyMCj32d+zn22LvZ+v56JIKbPvJhvnX1F9HVNIs6FrCjaxeN5UYOHNxFW6KVje9vJT02Sp2u8dDKF5DC4GMXnsuLzz4NQuepTW/zaCQATWPZKacyqEsU1ePSz12OGklQzI+hDPayt2kyiSnzuejOBzj/3K+hpqsojQtaYm2IkRSbtm2gqW4K3eNlnnrlCXKaTYu+nGhLM9Ma99BcHefd9zJQsZja0oFrxRitHkPWx/nIqcuZ0jiHR+56kBtXPIDqC5bOXs7MSdPYPC+ONtbIiy+9weDgKJOnzKaUKSADh4GBftK19WTGbHDKqJqOIgPcwAckflBBKAZC1TAUDSsSx/MlhVKFaMwgUCX5fAEhIiQitfi4FN0Kimbhuy5CgfH8KBFfYsbTSD9ACpVA2piJGjwp8J0S0new/TwoNoqqhnFhQQB+QCA9/ioBBEKNNnh+AIpGIEBBmVCXTIQvBB6qlkDTJop2IHFdD1VIhBQEooKiqOSzeYTucduNN3HB+edw8qc+zQWfvRxflDiwr4fBvZt49721jE5Ekhn6CHm7CBGf4fEu+vp2UQlsqqwFmMDsOR088qdb+dzXr0QVccbGjvL5z32U39z3c2YvmMyMWS2cfdJSIlGbH924ktamJurqYsyZM5nunj4CXUFT0+RGc8STOt+65iKEhGQMfrn3j3Tu34Npeih6hISuo0csbL/ArBlTCMknAclYnC2bNnHBBRfw30+uIB0z+dXPf8mZp5/JJRd9BlUP7fZ79+6lVCgwNDREUPaIWCqyKkk65zG7bQ7Hn9BAaWQMS6rki2UKgcCPq1jxuUh8RoYz1NTVomsR3MDHdTx0RSfvFHE8n2mzG0kmavF9kBjYrkNT3RSiqTqcdBVeqUTPru0MDvazd59Eq64i0bCA3e9vYX/PNi773HkcM+vbrHn3Ff78+79gqDGkUqBSKZHPjLNt006iEYNYJo9QbXS9hpeee4NLL/s+sZpZCK/A1k17eOnVDcyd2c7sY+eyefNBXn/9eZ5+6lmuve6bfPvb19HWNonuvlGOmf0haqob6DpwiIAyw8ODCFUh8B18R/41nFo3VLyJbFNFKqEySTdQJobsipA4nouu65QrFUpGnrLto2pmyIn3PAZ6e9CUgJ27NqPKUOvtuB6eDLArEsMwyOdKLF36IabPPhZLMQjR4yqOXUY3LBw7JHRqQsdxHCqOTb5YCNO2Bgf/XqkE/kWKdiB9SoU805aewLIPTcNxVBYu/TCxSJzDAzsojR7khaf+wKYN7xJLJXnsL4+w4rEVfOL8C6iUi3z1S1dyyYWX8sBP72DXcI5aAUuam+guljnlnPNIpmt48f47cPuHmDe5lZrp86iJxpgzdza7tu1h8bQ5zP7wTPq6h9i9eRNH+8ZAakyvnYTR0syh7DsENWX6Og+Q/+Rcak6fzT2/W8F///k+0sYYq9f9B63NUzjnvI8zNniEqbMaufDTX2Ak7+KWF9O5Kc/qzns45aR2Gus+w7r1f2TGuaMUzF6sdIWsXWb7i++zzd9IsjrNeKBiq5LHDx6i3oGm2W3YPVN48jePkUikOXL4EJZmcPjIbqxIjOGxAxgihRlJEXgFVAU8txAywt0coIMewxcapfIwiq5jGHGcckBVTYpsFkqVMkpFQ0HD96KoWgQ9mgwn24GD4zi4xW6iyRRFOwBMZDnAjDYiLYFnF/GCDMJ1CVyHwC0SKvA9JGGHE3YyoU7c930UVUVVNHyhoOsqnmfDB524piHQ8KWKlCq6GUMxFcyERd6N4BfjBPkSBEPMnjKZk+dW45a38ImzvsPzq+5n3vJzyI4d5tj2qajxCEPbd+EjaG5sovdAJ6qiMaV5OkuOO4ldBw5RGFWoq20hMzYEMoIzovD2G9sRwM9u/SWXfPZitm5fz8dPOQFDiZOur+erX/sG7761msn109D8KqQ9zFj/ISqVCoqs4oVnezj/vEbGhnvYvHUNVkyhuroaS9eQIkAGJTqm1lIoaqSr6jA0D91QkGKIhlqVhx/8JfOPncdDv/8t8xbMwAsK3PaTmxkcCmFh+VyG737/OmoaamlorsM0dYQBxLTw75jTRsekD+E7Dh4gojGCwGG8ksWTAXOTtaE+W0rwXCxNw/ddTBSiuonrSaxoEkXT8T1QhULeLoMI0O08TuBQ/+E2zGAytmeDarLn4D6euu4HUFAYm9zCQ7/ZQyYX0NiYYmBwiHgywYJ5c6hKR+jvHUIqMQp2I8I/iDG5hf7Nb/Lw0w+y7OQP887qBxkcbuWss88i77gk61Ikqms5cnSElc/9hfkLm/nzn+5FURQKhRzxWBrbtkkm6pB+mWQ0hhRh2remmqgaOI6Dg4Ki6WE4txLK/ErFyoRGOwwvQQ0oFEpEI0mEC3ERBmALITBMC6IKQviYSiTk8COIxiJUPBc0bQL9G6FcGsdQNDy3jCcFqqpiRPSQcWPEwgZFSqJ/o8oyDAPHtf9hvfzXKNo+KIHJay+v4tMXNZOumcRgTx/+/8Xce0ZZVpZp/79n571PrnNO5erqVJ0D3aSGJkgQFUSMY5hRR0RfwzDG0dExjoJ5XsfEmFDMAUQdRyQJNNAgdKATHapz5XTyOTvv/X7YJfP/rzXznVqr1qq1qr5U1TnPvp/rvq7rF7eZa1UpliKOHtnLb3/7AELEVDoL7Dv8F9BqZPNp5hoz/Ps3P88nbno3mi+456G7uPayy/mHr36VLRdWGT19BrvepBMELF0xxIFTY2y4YC0bjI0ceuY4LUVhx86dVDs+L7r2GiaOT/DIo4/ykx130Ebmwus2UV6xFPv4HBvaXRysGFzRs47f2g6OaHH++Ru54LzLabXq9HXnODl6ivsef4K7/nAf7/v891i1ejlDa7eAJLj9578kiprg61RmJ2iZOmpe57JN29my8hz27hllZvJpUgMDTEwGrCuU6U33UlGPUu/Nc3L6LJrRhRvamJKCpugIBeQ4iyRpzE7O4RNB5KEoCulUGk01kc00QjJxQicpgTLyzE+cYGa6wdDy9cjColMziMMGka0Q4BOHMZKqERPh+0kpk+J0kDVBGEeEvkEYBwR+iBwpEJF0jyxOxkKESc8z/61lx8SLxUeJvQwJRPRXUK0DyBBLSIqWgHajpDtFkmQiYpAhFDKOU0GVdBD7eMNr383EqX1YZzLcfd9tfPpfh3ji0fso9BU4ffoIum5ywcXbUHWTTNHkqsvW0Wo0UbQqN9xwIdeL8+kplnjxS7aS1TJs3noetfmTXHftRWTSBXQ9h5UWXHBkA58a/ARe6KErKo16nasu/SCxgN5yP2bKpNidTaQdxSAMYpxOjUZXmuuvfRWgAYkfOHmILUJ5Y0D4vOOmNzI9OcNlW89DyIKevjzt1jyyFPCrX+xk3cpV1O2YjuPzqr95PcdHD/Ozn/6Id/3jzeimxbMHDlC325DOkLVNYiXi1N5xXLuTuBpCmU7YwleS4FdtroakyBD6uEGAF0Z4boAX+0RSRLhYY4yQiUPQdR3XdYl9D1WTkIRPEHeQOgIliLC6Cnz9az+hmLZxajHrNqzm5S99CU/uepp0vkSxt0hvzxDnnbuRIwePMjNdwUxpLF2e5zg2H/zAF/jAm69AQee6l13Ne9/9Fl7ywrU8u2s3feuW8y87HmT88O9J6Wl6Vhbpl/o5+Mxu1m3YQCqVIhYScSTw2jGKHNKVKuD5Iaqh4nkRigKaoqAqOiExoVBQhJT45NXEGhsFifvJtFQ6jo2qmERBSIiOJAfYnZAwjAiESyxkZJHcIEM/wIsCAkkmdF2EpHF2vIokdI6MTqJraSQJfMcl8HyCKMSXE009jhPtPQxDfD95MITh/96x97yAIGQyViwrNu/7wPvZvv2FmFaeIDBRFJeF9izf+8JHeGDHEf78yA+Zna9xw0vfS1//Sqamj1AulVAsiXe84jW0dxzghRdezFu++XlectHF3P7ETj5969eZmKtz2//9GBdLMrmLz+W+x5/hK7d9g1/89Ac8+eguNAS+lESwQ2RE6CBJOue9dphOVkMb6qZxpIZ4uMk1l1zCVFPixrd9iOteex3lVctYP3wRjz2zg09/9P0YcsxPfvBJguoZ1m/ewHs++QlGVm2kKMoQSRytnOIrt72PgWsmCMt59t5b58Av5xC1CE1V6cuvww8m6O/pZsXAJVx08TWgdBif3IuiyDQaTT704Y+DEJy76WIOHjqGG4dk8uUkGKD4eJ7L/MI0hCFCJNFdScmTyQ1gux3S6RwLM/vZcsF2/vToH+hRe0ErIbwZFD2NZqVQNR3NyCd6ZiRjtzu0ajViEZEplQiJcWwbYgeBC55LGDhJ22ocQOQiCED4CP47SROxWCaFjKxai2GZxILlusl0IalaQsaJdeJIxsp0o0kmwjKJJAlDz5GW0oRBh4J6hp/e9jVqp56gmEvj62XUgsp8p8mv7vo5tekGVi5LjEIkK/ihRByESZpSREl/9uJDQ1OS6ldFjxBKDEREXoyi6khyIuN5jowkCTRNI4piNCWhJOmKnsAgpBqSIiGRBmJkJfkUqKhKGllSkdSYdqtOMWeRzRrc8cNvUZmtcPmlF/CXJ3dSyOao15PWwEajjmEY6KpJyspw8uwYmUyGTLZArlAmnSvjuSHzzZAlw8vYfvk2Dh0+yMpVPTh2TCGXRwFst4WQYpAULD2N67oJDEMIpAgUTaXl2KRME6dSRRUyQk6kgygkGQxkmUhENG2J0CrQaDYpZHUIoF1dYOnSZfzzv36GU4efIsbCbtSJgTe99Y1IwqbTcCj39vDD7/6Uju2z+dwr0M0iy9dewPKR5Zz7gusIQ58la2S+/uH/y9jUSZ64/z5Spsfmi1/Kr+76Gj1GBlUf4tVvupFdTzxCpdKit7eXkydPIqR4Maru0+l0kKQI33fJZruIY4EfLD68hIxupUDIiQtK1VBlhSAI0DQNXVETyU6SEtCHJGGYCrpmoqpJUrFhN5E1lbSVwgvCBDhi25h6olsHfkyEmkgvuobdCVBkA03TnovTS6JJEAT/vyWo74fPff2nn3/p+QtBAMhnskyOT1AoFBCSxfoNG6ksVGgdncW1WwRuwPve+wEK+W6EFHDlVev55MfuY2Skj3/76ue4+7bb6J6DN111HYoiEEEHM2ty7PARGgL+9tLtHHz0cVb0DDCyxuHOO+9k3TmbOHl0hsrsWVRhEYcKMb3oeNjRcS7KXMbQmiWsunw9d6l/4Ie/+gGvX3M93/jU13nNTW/nHR94F7v2PU3UriFNHqDQY/KDb3yD5lyFl73kes5OnOU/77qbbPbPBFKaTCnLd2+/jenps/SMr0PO6Zw9WKd2dJ7rXnwF7kwHN1YZPXaKVM7iR3f+hIef2sX7PvA2Qlnmjtvv4Oldu3nj393I/Q/8kd37nkSgIghwah6tMECSIPyrhizLSXthHCNLEba9gFACmnUbQhgdPcHUqA5SB8KQGJfADQj8DggF1XAxrSyxrGOaFpGfcBijUBDFMVEUgEg2MCIKiAORUGfimKROfXEgiJNelb9+nXSPSIk/O4wQcoTr+kRRcjBomrEYcZeRVR0hBEEcENg2RjqLYwd05U28sMU5G7eQNiUCLZ1MRHEDfz5iZPVyvnzrLXzn29+nMVNhxebzaUU+nu+QsUwcx6GQT+oyDSUJJCla8pCQlMSzHEoRKgpCWgxcRFLyvTgg8ZiryLJO4PmIKE6Cp5ChbPUAACAASURBVLLAD4LF2HSQkFDimMAXBEFMEIbISoQkBZw5fpDHHt6JpcaUlnUzM3GSjKEwPTmG7XYYzgzTXS7SaDYZnxwjny2gKyGaGtJuLxAT0Gg6tJoOwyu2oCsq0+NzXHPlDXziM5+ikM1hmhbNZiPxvkceXuAT+gmE2bMdAAQ+QRDgeC5hTHJTimOatpMsyTSNjmMnJWQxZKwcyAZulFRENOanUTwfu9Omf9UK2q0Y4jYgM7R8C7sPHEU2Al64bQuP3b+HQJdJyRYrN2zk93c9yDvf/1kcH5r1BsVcBqeisHr1Gp78y0487xSpzDLGZ09S0DXAI18usHfXAS67/HIe/PNf6OtdQi5bQlMVYgGaqSX7ETl5+Mqyih/ESCLANM1FtqcKQlp0JylJ8tZOgB+QyHdClv574o3iJKUbJj8fqYuVCpDYXBWFQqkLx3HwQh/DMmjZLeJI4LQ9dEPG8R1cX3kOtIEb/bcFcbEDRSxiDw3D+F/PyufFpJ1Om/Gqlf2kMlnqbejrX0Z/fy9SbPDQjntZmm7Su9rggsuXY5hF7vjBIzz56ERy644lZCI29w2yMU5T8DUequ5nQVKYJqJ7cB2GYRAtnKDk2IxJCi4m6a4ciiyYmZxiycAWiutehVpYhtK9FU0S7P31x1m1xudjt76HleU03//pV7jlQ9/jXR96G4d2H2XPIwf5+4/dxDe/8kXMFf0MDp3Le977DhoTM3z8LTeR7i8ysnwpex9+mk98+rNc84730lVy+cQtt/DgfbtZe9EH6d2wkd/e/VXc++9kZd7BkjNU6jYducb5F5+DlV3L+vXnk+sK2ffMHl7/6tcxdmacwweeYdnwSiZOHWNy4jR3330PThwjKQnsISQmjhIQQRRHgEQM5DIl6q2F567jQsD+3afZeO5a0sX1tPxpZNcntP/aT73Yib0oauhmDtVM44WgaDpeGKAIQISI0MG1IyLfAzyIm8/1Zyfhmuj/8x+XAA3DyuIFAUJWAQkhEkSWJMvJ70Di7jH0DLlskY4dIMkGschQKnUx+sxOHr/3O8yfOUEqbFEwdOKMhJbJEPkOmiST1fP0bVnL+29+L9+844cUSwO0Wi2CKESWJVKpFJ6b8ADjWGCoOnFgLUY/BEJXkfERsUzkQShX0bX0cyGgv36KOFkjBlEyoamqvLjgUolCCcvMEMUhfuSjyzGR3+aCjUuIgzYzE0cxNZ3Dhw9TLvcQC410NkW7VccwTWbmZtHNLIps0GpUSKVMhCJjWlnWbbyAaq1JT/8KWs0OPgpuKOge7Ke7f4A7fvZLWCxBMmQZXY7IF0u0220cp5O0NSpJL4eqyXh2B33RxyzFUXJIGTqev9iFHoOpp9EzGTpOE1mPaDUd4kaH/mKRebvC9kuu4EylTU9+Gffe82s2rutDDqr87Kd3k7YyDPZtYHD1au77/ff40C0/ZqFmc/4FF+O3JbZcsJqsKXHk6AxnJo/w4298i327/5O1m7bzzL57sJSVvO6Nb+HBnb9kyYpVPPXY07zgBVfhOkklbxyHRJKMouh4noKmqASBT8rU8UMJ17Wfm3ZVVSWIQnRVQ5M1oiAkiELiMEqcMpJEp9NJbmWBj6yqyAIMTSeWZWzXwQ59YkkgRKKX66pKFCRNmals8hqxXR9D05LXuhAEQZDAreNE0/7rjSeKIgwz89z0/fDvvvr8nbSFEMRSjBd4bNl6PqdOTXLy+AzlYokXvfhK9tz7M1xbZu+eXfT1DVMum1x86SrCdj/ZnMmTD9xDf38Xm1NDZBE8/PgRLtgyjNi4jXe/7SP09Q6yVJ/l8pG1/Onee0mXlvCT3/yCbdu28cdf38O3vv0rypdcRUs1mJuUkNwG1coEh04f4fO37qfYC1boggVt3+MV7/4H9h75JF//5Jfp6slTm57k6L4plnzrC8RLluFHEdXxeZ6amkORBbuf/gtrt+2m3SNTCpuU4zqzow9w7OQfefv1V3LSqOHMnkRXVDYVChwff5bDh3ezYkmBQ63dvOvml/Pwnx/lqquv4XOf+3dWrlyFZWQ4c+YImip485sv5fd/eBzXFdQdnzAgeXeJZKIlBk1RqTdnSWc0cvkSxa4eZmYneMMb3gCRSuwHEBXQdZ2AFlHgQlQjjBzAQZYUXNvB8xrIWokghDhWCCUBIki6h4mQZDUJ1MSJ/z6Oo8RmhVhcRCaBGmlRt1NkDT+KkSRQNSNJPyYYW4QiY2gmvheAlPy8psrkSz24bhU1Z9L0WpyZGKdPFsSWhSYJZhbmyVsWupkmCl1OPfAkX779O7zola/hzW+9meuufSELCwvIukoqZeIGLpqmoRLhdmwUPUuICpoGUoyIE2+uJuVxvTZRnLxeZVkiiEJEQmBDVRWEpBNFAZFoABFhJBMGgigU+HGyZ5Acm1J+kMCrMHnmBHarSra3zPBAP74fUuou4wUu0806rU6TVCpFtV7HdhaQ0UllTBRFo1TsW9RCfXJplZnpOYaWrcB2JcZPnuD8C7djaolsoyqCYtbCcQP8pkPoBdiNDiIOiVUbIcuEfkzoOqiAioS76J8nSPYOsiwjhwn8NlUoIGQdIQtUPUbv0mi0W4xNnuGzn/gIqmoRBoOcs3kVc7N1ntp5P7muDFGYZuWG83n8iXt54Ws+zMf++e9467u/RDalIme7CDoOuw+EkAro7V7KBz74Hj79mXFSuW60WEEvFvDUpBny9NFT9JT7qVVq6KaF4/pYpk4URAShh++7EKjEgaATCMy0TtNpEwWL0lAMqiYTSTKdMGmddFw36SyRpMUkbuJk0jQDSQLHbpMyEi6pZhk0Wm0adhMAVU5sexnTQPgwP55IKEFoU40CNE1JQONhmNwkJRfiOJnqFyUSN6g/p3H/r+fl82HSNk0rvvbaF3HqzGnOjk/je/DNb3wHpxUQqR0e+/0X2T96hJHVAzSaHaoNB03r5uILL0WSJKZPtjAyRf7l4++nkMog6wYf+8hH+dG3v0Esq6gh5PoM1paG+MPBZwlCiWxGI6VoZMslNCnNmktfh5HLUuzr4zUvu4rbv/whhtdqpLyYV7zpDdy34yF+9ZMHyA/1Uo88tm+/iseO7OX03r/Qn+1Hy6h05mpMzc6wbf0mil3dNOvzVMbqVCsNRBjR9uu85W03EXd8/uPb36Dm+WQyGSpjE6Ty3ThxTLVaJe64DA0M0mrX8GyHt950IyLVT0/vCp7e/Rh/c/01PPbw75k4+jQ9PTncWhO7E+BHATMT47RdHw8LL4iYnGkQhYIgJfHDH/2Yj3z0Y4SxRl//Ks5MnqackTh21CVsTRHrfZT689TrTQzdxOt0II4JXI8otAmC6cQNIhRAoBi9KEqWMJIQaAgpgKBOGNjEfoMYb/HBkcCRiRcb1UTStx1jIClpUBIJRFKzyRJSJjmkYyk5IFHI5otkzALTU1W6B9eRUhqcv2kV29bqmFKLlJelE0rkugNU2cKUBZZhoUkSmqbQtCsoVorhcy9l9chm1m/ayODy5TSaTdzIQzcNfHyyKYWg3SRjZWjWG+i6yvj0HJKsUSj24LQ7SMhIugqxIEgKw4mckFj4CYcz8sjkYwIfYi/GsUM00yIiTNwLnk1fyaQ+cZDAbpBLm5iWxemxcRRZBVlBN1SOHZ6gf7DM+OQc6UyGOBasWjlCEAQUCkVMw6LRapLJZxletgbdMpmvLKCrWVatWsvM5CxDK9fyD//0Mbr7B3ADn3y6QOhHiDBCjWPiMEA2HCRJwnH95KG9WH2gR22a7Q6GbqEYFrbtYlppGnZI94q1dFyHyLMJHBe7WUV4HmlL5cmd95Lr6ucVr3wpf374MaYnT5EpFSgZXQyt38ADv/kp2174Vj706Y9z8tRZ7vn9HzDI8Zuff5i3vuVf2ff0IW649CKCwRTpskVrQWH7ldvYfO4Amwcu4JwVI7RyAV1ZnScfeIY16zawYetW7r3vvzh/yzlU5uepN9oI1cALbaw0tFoNCvkSkYDpqXlMzUKXtMRaKhI9WzeSMq9Ox8EwNAzDYH5+niiKSKV1wjAgCl3iIEQ1TGzHo1TuZWahhqJoxEFyWwudgDByiUWIUFQk2UisrZ5NHHrEUgySoOol0ogqyRi6Ti6X4+TJk1hWQpVqnnnw+Ttp64bOH+97EKfVRtN1PC/g4fvu54Mffg+Hnx1luuoiSVk6nS4sa5BztmxGURS8MCIQMlohQ1d3D2MLs5yZmeMXP/kp7elZXnjpC0jhgqLiWGlCFa7r68Z2ffwwStrW2hGSFnJ63+10mg5aSufOb0zhuAoL329AAB/88LeIkUiVc7Tvexxcn4e+/Rs0SQZNY0YcB0nQbnVIWyZ/PDhDe1FHlNXkT+x0kiXbz398J6Ojo1QXKsQRTDOHABbqY4CEFMfIisHYxCRhmPQmmFaerp4+7n3wXs4/Zz223WK2MkN3qYcgdBnqHuLAmWN4sY8HEAREbpUogq6URCuI8OQ07/jHt7Jpw8sYWL6V+uQYijXI+edvpxb/mrhaZvz0PuqNmFjW8AIfRdERyISOiiTpIM8RxzLEbnLougv4oUdIGkWKCDozSPGitCIgjkXivxYSMQEIA6IQXbZIGQLbTxOiE8UqIgrwZQchy+iyjiJJKJGSwAOsHKGi4YiYwPHJ5nMMZAoUsxrNyhlaQQff6kZIBtNnbYo9JWRVwdQNfCFwW3V0IehML9A/0M3bX/da/uOnP6buOwz0DqBoKn4UUpmf41SzSX1+Gq/ZJB3JGEImNzKA3IZ9UwtsXbuSxlwLLwDPCzCtHIHjEToRXZbG9FwFI2tROzNG5Ed05UvEsY7teFSbs+haltCpYw2YbL5kK8ePHMJpuoQIIhHhSwEK0G67pAsqZtpM6OeKkdDi/Yje7l50XSedzWH7AWEk03Ed0oUca9atZ36+QqO5QCptYloa//G9b/Kpz9xKKVXAbTlEJdDqEZai0HE9qnYDQ81gpASio1AJWqQNmcBzyKVMYkWnZoe0Wz6h0qDjO8xPjZNKa2QUjXqnjaUouIGLGgviOKBht6jWHDRJEGlp+geHyWcGaU3Psur8a/jbt7+DetPhxOlJpidqfPs77+fJx8ZYcMYZ7krRmDjMUGEtS87dyFGrSbF3mH/60HdxWw6HTuxhNvRRgxivXmPsWIq/PPYXhi/YzG9/fTeYGjFdWDk1wYUJH6Gmme/UMXWZhapHybQ4685RUE00WcJxHIRiI1QdWU7hui5eHCOpJSzDQEgRkRJhyIJWo45qpMh3pYhVHcu30FSLKEz6uDUjje06GKZHx/ZxpBhLUTD0AiJIcgu6pEHOgkggooQWJSF45Q2XLiZrQx448+D/eF4+LyZtIUQsgKEl3axbu4FiuURP7wAzU/P09ffTDlSQZOZn68iaidAgn+smly+Sy3STzqt092T5w+9+RCGr05if4/De/Zw6dQqnXUeVZFw/8T+GcUSw6MeMoggpivF9GSeUABeBjCQbaLk0fb0lunuKCMfHb9tEskdAgCuFWJZFs9lGcgPMVIYI6DgeoeeTNsxEByMJucQCiMSiYyEpWnIWKem2bSfXokjBD0DEUkKBkWQGBvpYv3Yte/bsopDJ8L0f3E5vV4HP3fpJ1qzqZer4bvYd2svM2VlOzbZRIhcJmchzCQXYToTtxfhSiOub+K7KC67/J9755u1seeEVFHXAg+5lL+YFWy/hd/d+EQIZpBREGrKeISTCMgziOFlgxbFL4NaJow5CBAg0JNMkjECWJIKQZM8gjGQxJ2URQkdSLTL5mNrCM+DUkGMIMUBWFyfwCMxuZFnF1A1Spoml5wijmNmpBqpiUl6xkqmJBks3bUZpniGtNtkwFKCLkMhXWL16LbXZWdrtJqtXrMSyTAwlOdDKfWXUOMY0TXLZMqu2n8fcQoUzzxyiYTcIVOjKZhhZuZ5CTy+4Lvgepw+Ncnj0BF3FMqvXbGD5xduxQ5+LLriQdFcep9OkZTdQFIVGpUI7UJE1k/5SN6Zu0nKmcOwG9UqLTLaM6/uU8zGFFIwd3snakZVU5hoEkkIkx0RxjB/FuB0HWdUJA0G11qavbwBNNZiem0VRFFYsXU6pp5soFqRSGRr1Fn0D/WQyWcbPTjAxNo7dstELRa5//d/xsutvoJjJMFge4O3Lfeo1h3mhM+P6rHjRVbiaTjPS2bBsA/WGxo/v+BHnbl5J3jTRzRy2k7iS1q9bSbM+xfT0NLJiUKnazNdthKRwaP9eSsMrOHPoPhQRse3Sq5mvd1BCma7yADse/CVrNp3PrV+/g0qzSm16mqmpKlu3rqPYVeYr//oJYrlNuVhCm4O+Qpa3vfOd7J0YZ66rTKari6DpMrcwy4qVa5mdmmRZqZevfed73PyPb+e/Hn6MbZdehGsH1CsL1M5MMz9XpWdwLdV6h9PPHsYwDGYbLURcZdXqPnzHZ2ryLLKcgDhQ1ARV2GkTBxHZdA/pVJ6JiWkkodBVKCQJSl3Gl4BQQlEAGWrNCkIkxCcRqXSqcQI3sVJkjRyTM0cJPRdNl/GdNpIToqoqMjG+3WFgYABd12jU65RyBe76/o3/46T9vDi0BwcH4tf/7evx/ZCJ6QX8UCB0nayRJ1NMkyptJZvPUeoq4voOti1jey6BHxOENmHkkDJDDjz1R7KWhxF7yJJJzY2IZQXf7hC3HGzPRdFUOq6DqaloikoswA8lUlYPHcemMr+ALKtIIqRWnaDUW0RxfdJCx8ZD1hUWGhUAclYWz3WRhEarbSdX5jBCEnFS1OT7+Ivm+VyuQLVafc7O02w2kaQkzBCLxcSZ6yaLEU2hMjfPxg3rGR8fR4iQuYkZunu6UAKX5sw0a1eV6S6kOLDnNFldkClbOE6MpIEuWzQjFz0l024GuL7CjN9iejrACWOenatQb/ocOhFz3cVZ/v2zX+WrX/oaImxj6mnQi0SLE3AQ+QipQ+i7aGo/RB4idgjjBoFdSRBcLE7XcioRd2MFxSigpbqQzAGEmsWLcqjqAq0TDyHFTeTYQWiJNhhJWoIzU0zCIEbyQ0I3gEBGlnUUPYupW+hLRzDNInHk8robLqEnG/LtL72H06fPsmnTeoq5EsuL3WiGhiokms0m5205h7ptM1DuQdUV+rIGTbtBNpVm34E9xCJi7eqVyULIiynme0mlCyi6hlBUesws7aqLIiSOHT1Kbt1mVq/bwKNPP85X//1L/Oap+8loWbRimqXDI4wsKdJTKvLL7z6EIkzi8CDbti+jt7vIqZMBhp7lipddys/uuI3+Lp1Wo0Eh00OATLXVwA8CJmfnE99xLDCtLAINWdXRdYNsqcTg4CCEMD4+jq6ZyEIibSU1r65tkzItXvaylzE2McY3vvd9jGyeS7ddwlVbt3HL577BLc1dLAiJx22H/bM26975ThaA0CrQ19PFVZe9hn+99RayCHTJ49jxozSaU7h2nUKhgF1zWTN8CYHwOTs1x9at5/HKN13D4FCOw6ey/OxrH+aRx+5hxapz6e0ZQM7k2fHgn/mHD36UrRdehKEo+F6FdLqb3iUl/nzfIxw8uAM/tHnta29g+6Zz+PxXf4BbmWVjRXDNqnNZ/Tev5ZH5Wc5m03RqAX57isZCA1l2OH3yNGdPjLHn4DNc/9JXs3LzOmbpcPbocVSzn2d3HmZ2oYJuZpBz3cjNOl0FQbvSJBQh/b1FosBBUiWEpICQsZ05dF2h1WyioCfuJR+8xfrW7nwJz/ZJpU1anWYy3GQtFEVC0YxF4IWBkDxsewHXqVEwLTxXQlbKKFqBWquJLMsYmk7o2bSqVUK3QjaTQokCHrz7E89feaRtuxw7XUE3LbKl5aTSefKlHgqFLgrFAk6QdC2cOTuOpqoMD63izNgYM5OTdBVzmJpJTyHDXsfl5NlRimmTWq1G042p+wGu0yEjac/5MD3PI1gMSMzP1UhZFqdOnUGWFBAhUegTozKyagXj48eJ7AAplIliDz+OCAhQVRXf95FEjC4pxLHAC5Otr57SFsnkfyVlqLSaPk67DZKCaVmUSiUkWabTbiOrEnEIipDI5NLoqkwdl+XDPQz1dzE6Ooqu+px7zoVsGhmmdnY/7/0/f09j9hR33v5jdj16mgeOdSjKMWs25NAJ6dKKzFYadNoRNb+OIssoEczPQanQxcqigyvpFJUOQTzLcO8w41NP4fgSxDqSHAEhQhKL1r6kRpIwQpb9JKquphChh4hiEII4DJGIgIDAqRDGEZaWAhWCOEQREUgGIvRQFB8hC2Ik/CAiIiD0QyRFxUhnkDMScazjhwKciFqjTnz4FPlBQVefyejxQzyzcJKegUG2bb+YP+94lNFTY3SGlpHvKpDPpNEVld0HD5HL5chZGWQXHLuGBMzXGvTke2jYTRqVNnlNR89lUGWBLEVYuoasG1QDh2p9AS8OmZmZoenvpnpoH9tf8iIuvfc/uenVr+f79/+OktvF7sf3cWRPnaU9vRCZDAx10WzlyReKeJ5Du+ngOSHjJ0cxFAXH7SwezjGIpHi/VC6jGBZhBBMTU7Ra8wh0rEyGcsnC7rgszFepVGpYlkV3dzdHnj1M/8Z+stksy5cuxXNcpqam8H2f1WtGCGKZlGUwMzPLQDbPbqWLqu1yOpPmqdmzaJ5H3Q8x2zGtWhXJvZctGzciBw3CQOL8F7wYK5tlaGAAI6hyYO9u9u8/yOmzp8CY5b/uv427fvs1VEI8GXoKQwgJWk4VlzLThw+BN0+xfzm1VpuhcpqF6SpWKocUw96nnqTeqNCqTXDetg3krR7+7o2v4s477mDrpjUsLwxiP/QIlxaHuNcPmDEt5idmaQcRvtckjEMcb4GXvOBF/OddP+Dmkc9y+MgpHt/fYGVXBqMwyMsvu5ChXok1acG3Hxnl7JlprK4CamDjtDsQu4SdgEw2S8er4tgRaqwiBQa6piNHgjCysSyVdDpFWlVphwFCCkinLIIwxHcjCCXkOJFfXZFE29NqP2pxC74d0o5gYaZJqVyiUIiYn6siy4KFuRkMRXDhRdto1ucp53QevPt/Pi+fF5P28Ip18Ue/+AtkScWLYhqtJp4NntTGbgvyukPo+WSKJjpFbr7xMl79xo8wtLobQxlEVTXKuQLjJ+8hq8eYAuYqc6hahjMLFUIR4rZdwjhAhBGB5yNJ0Gy3SOcLnD1+kuH+HiqVCrlskcpcld6BHkZPHkJVZRbqDdKZPFGUGOhVM3minjpzklQ2Q04W+I5NFAW0Om1K/f0gSWiaRiqVoVzuZkn/UrLZ7HOx1VozuVKbpk6r1SJqumStFH2DZZrNJumUztiZkxTL3dxy67+TKhlcfeXlHHjiIb743hsp6xHPPHQPtbkaI93nIoaKKJrKqelJdu0e5f6DU8QSrBkuIUlw1leZnpjhE1/5CR+9+fWEUmLCq01N84abP8PYs5OsKY/zzIFjnKm6oOUwrW68IIQgTLobjIAolBHCJo7kxCrmN5Gjv6YbXYLIISJYtAlKgIWQcsRpEyG6oD6ORJvhrI8XCvwAmq5HhISPkfhmtQQ+LGk5olhCUrqIVIn+JRsxrAIHRx/los391GdOIjsVKtUaqAZvvulGnvjT/Txz4BlUIcinM4wMDaAZBooIKZSLmMgM9PcShj7V6XGWDgxR6MrRabURYUCpVGRgoI9sNk8u30e70ebImZP822e+hJxLcX4px9o168j3DjJVrXDui65l/TVXIemC8sAW5ufOEPkdXva693DVNVdxwfbV7HvmL/zTP76D//N3/8gLLt/Ov33iRkxT4LZmSKezxKGGFwnGpyaJBISxhKxohKHA9yLKPYOYRgpJSd4fQkj09PYThxFOu4PvOVhWGt/3adYbDA8PMz87zXBfP9fc8FK+9K1vsTDf5HMf/wKP73iS3aOPceLwKG/48M10RJ7Lr3w19YUmb7tyK5aZIpDraOk02D7NZpM4VtHSKbxmg2JZp9quUepdSrU2Q0bLYdttRlaXwJNY0ldmxdot/Ncffs/8bEwYC97yvo9z+RXX0mjMsOX887jvP+9j2bIelEjjF7f/kHmvzqmZUf7wm18zuXCa/mVl2pHKKqsX5ZndjP1pB6sPNSESdK69jtqaYQ5paZqhx6te/ko2XXktBhaP3/523nPLo1x56RCHxiIWpkaRlSy7//IYO+67B7k0SHj2CFImxfVvfye1k/MQB+SzBvFiUrhSqxLGIQN9I/hugIyfdKV06liGgRt4GPkUU02bMIB8uZ9mw0HTDPKFEpVKjYO7DpPTPTauSzM4sIQ3v+Vv2LA8TRcRcSwRAAvVgKcnZT760c/S1ztI5LbpyhnsfPA3tOvT1Cb2AdHzd9IOwoiFtkPQaOBEEXEkEStOog+lFVwnKU5vt3zyJSCKSGkdCtkhPDrIjkStOs/4+DjTY8exiEEzabbqrF2/hjMT49h+gCXrz22KETKGbDI2NomWMnns0aeYX5glRsdMGwRPPUa2PMAll2yiq1+QUhRsYhRZo6urC0mRWbthFQNLBmjOzZLRdXTDIEQwsGwZw0PDpFIpdFknjiIOjx5jYGCAE8dGUVUVMXmWGKjMVwFYObKS2ckJ9u/fj++7pEwL22ly5NgJNA1kS2FhfprIj1jSXcapjDM8WGTZ8FLcjsaOpx/DCwK2bNzG37zqSgZXjbLr4ChPHptHTUPW6sUN4dP/8hWqc9Ms6ZGQNJcPff4BbnjxtUyrLTafs5Ge0hDf/+3dhH4N4Zuk9DSNOEAoJoRVFCEReBIIiSBsE4dJNF2SwkUG5GIsmzihs+MThS3wLPIFCZ8856xcxfJc4lSQFAPbVeh0HE7P12g0GoxNj+N1msTtDqlUAc2ysF3B9OwEUi5gw4YNTEwcwJAj4khlaGg1C3aHXYeOseaCixhYs4pHH32cE8fP0vFcsoaBHofk5iugCuabFRQBfbkc9U6LQqFIx/aZqUwTSDFxIGNkXdboeQaXjXDZddcxNDTERkaCfgAAIABJREFUBevX8J27fsm6vQfpXzVEIZ2n4gXUmi3u/PGdvOrNb+SL3/0OxWVL2bDuQtYUVIQcsGrk1Vx29cvpLqj4kzMIIJVKYaV7adRbuO0OthtR6i6QzuSoNQNarQ6O75E207i+S75QxLZd5ubr9PT0EMeCWEjYgUNPbzehG9JqNFm6aiW+SLR7zw84sGsPg4NLibUaT584yVe+eytvedP7eM2r3859ux6h4Quuv+Hv0XMpIkwwJXShYmQNDCPNi6+7ganpMfafrJDJtgjcadJmjvmZFlGoksqVqdY86vMWtcos+58ZR9z7JEQ6seSSL29h1cAQJw8f5bwrNnPk4GkkFcbOnmTfU0c5NjXG9a+4juBxl57uLua9BZDTKIHL3tYZLlkzQmfHLuJ4GtCZ2fUU/VGA3zvAkiUDXPbKm9D0mHSU4YZXfJbHj+zhP758jMiT6RpZinDaNNtVaI8xOOAwrlX42Bdu5cTxcRaUgLjTpN0JiAMX33cplftw3CZzc6eRFAU56uA220RxyNHJGS688mKOHZ0lWx5ieiYklnUCyaE50WDXk3u55JLzOLz3VoaA4wcjjp0+xMzue5h4KgFCG5LHD+99ksd37qFT7+OSGy5jYnKMvqzFn+67l5GBLqpyg5I1wvHRo//jefm8mLSXjqyPz06p3PDmN7F25VICSaCrKookEwUBqpym0/YJCcnlcqxes5JW22Fq4hidpkfHt3n2mV28792v4gUXn4fdqpK2CosYq79+LC67YBEmm9htwsgnU1yCVVjGjTe+lffe9GLUSOaJfbO86+arGKv2cOObriL0K5RSJSSh0Gq1qNVqbNy0FkyJob4B7HabZ48cA6FgpXJ4dkRf3xCFbAGiiAPP7sC2baxsllOnTrFxwwaOHTtKOpvBNCyKmV7GxiY5OjpKLmWhahJ2q8KuXbt45StfiRyHVOfHuPqSLawt2Ywf30uzPU0cC2ZmZKwIli0ZJlXq4/TEHH6+jy9+/WdMtj1KfQVm5xtEnQDT6mJk9eWYuSwrVo0QRSHVdosj+57mHZeswiXm6dGD7HjiLzRtFUnPI8VdSMLE85tJCEX8NXzjIaJOclgvZmdiQiQpTkg0kgFRDlkpoaYKOK3jvO7l16LYZ1iRc/D9EM+P6O5dRdpMo5sWhWwRQ08RCTgyNsnZ8SnufmAXc60KS9a+lMLAJXSvruLOHeK+X/6c5YNLWbNhM7uOH2Fk1WaWrl7K6ZNjnDMySG1+DuHUqc7Msn/XU9QaVTZtXE9rYYqslWZ5dzcp02Ll8DKiIGbnzp04Xp3zt1+EEWisWbYeRda57lPv5fDuA2y64DxCTWZNbz8DqQzzJ05SyKQ5Z/NmNl92BS+/6lqOGln2T5xm84oeJmsTXHLRC8nIYNfbGDmTP/3iF9zxrS/gB01adrK40tQ0juciqdBsd5DkHMSC0AtxvIBSuZ9isUyj3iKb66KvbwBFN6jVakxNTVCZm2d4+TADvX20Qo9cuczsqSn6LI1qrUFh5Rr6V63jvEuv5vjsAt2mwbMHdvGHB+6hd8kaPnjzB9g6KKNKyfvFSJuIZkghpzNVd9h21et56tEnCIWLHC8Q+m2Wj6xFN0w6LYFhZXDcmDNjJ9m0aRMxDWYqNV5+1etwEPzoOz9CMyy2XPJy1p23gqsv2sie/Ts5sGsfb7rxJnr7u1m5ehBPCxhbmGBZ3wCzk5MY5TJVr8VKRSX32z8xefd/sVqsIEoXObtkNUuvvILf2nNs2tTP6i2voUetMD+/n94ly5g4eowg6oDsowmTKLRR8ysJbBthrmRo86VsvGAtU9M1uq2IKPBIG1mmpqeRMcmWFEQso4URJ04t0HIalLPDHDoxS73WIprbg6QL3vqBf+ZdN12Hg8cnP/Npdt55F63GUZAlCAuYGRU5zqIKC18x0eUUcXcaJVa4/OoXsXvPUXpSOpmCweTsAgcfug1VU/CDDkTx83fSjomRnP20m/MIeRUZSwPJhTjEC2JSeqIZ9/SUCXybJx9/AN9TqMyMUZ2vcPTwk4we2sPP/uOT7Nt7kD/e+1vOnjwFkBjaJQnHSQ4aiaRpyw8TSrMSa7Tnp2kuzPDNL0+x4487ePzx34GYo7d8MTe96UX0FtJ0l5dz8MA+ZFmmt6+fGJ92s4HXirn9tu+xceNGcl1dZDN5KgtzbNywFbvlcOjgHixDBy8ga6WYrzVYu24Tfhizdv051Cp1KpUKTzxyD61Wi0q9wqYNI0RIZPNpfN/h2LHDDAwtoekFfOsHP+PL//Iu1l20hKwFvm/TjgqcOfgUvmdTDxyGVq7i2bOTNKsO5aF+NCNDEFQhjCl26xw+/gjDa0doHZ5m8uw0Vqqf1lyVnp4y47OzjPT3UL76cn7x24fodKpoeiZpiUNFViD4K/UjBoSCJCLiOHiOsJ4g2DUUJYUkp0kbOpX6KEuWDXD9tVvYee80vaUMJ0ePk8oWyBoGpm5SLpfJ54q07Ihiby+DI2tptjssXbWGp/Yc5hd/up3U/Dgf+9uP0JjIcd6GbZRyXbRcl+zIWk6fPks6pdOVzWDbNrYfoMUqg8tGWLN+He12m+9955tsXjmMrCrUOzaNTpulK0co95ToWbaCQ8ee4cTpCYpGDiM1wznnbmXygScZ6u9lZPUKjh4dZXT8DMdYTCNXOjz25/s5/8gBTk0f4spXvI1NQ1202gts7B/idz/5FTse3kkYxJwZe4orN1+A3aogRISh6GiGQaXaotVqoad1Go02pmUkziYhk83naDRqtO0OiqSyfv0GZFnCdTvIhBiKTCZtkUmZ1BtVVqxbx+HjJ1gyvIQlmSzN/fuRJRjs72X33j2EQmI6bLFy8wq0nRq9pSLHD8/wyY/8EuJBELM4bRVJsUn1XUFsH2RybgJTVWl1zhCpMrKicPrkMYQsEwmDOISBZetQLY1IRFx95VVMz1RwI4eaHfC6972HXY88wd4nv8t07VKWlQzu//0OPnPLR2nEDktXDeKKADf0yWbzzMwukDNzyEKn6XZYEDEDV11KbxAy+5t9dNcksqkJZn5zJ/0XXciJYxO87y2v5yu3vA2rrxdDcgm0DKorCIRLNvAIzAK19jz53Ape/bdv4/d/3vn/mHvPKMnO6t7795x8KnZ1dXXunhwVR2GUJYQAYYmMsQkmGRNswBiDbeFrk7kmGDC2eY2Ba2wwCIHBFgIlQDmOsjQjTerp6ZmO1V25Tg7P/XBaMl4XXr/X7xeftWpV11Ph1KpVvWs/e//3/0e3H5CGq0hrDCdMaLhrbNi0k0MzBzg24+I0mrRdhbjRRBSG6a48w1Qu5PyLLuQ7P/hr8sDC4iqve8cH2Hfj32QJCymqNsrI+CYqe85n42iJrkwokMNSCoh8gePH6uya3EM9WkJFZabn03rgYd7wtteydnQ3yyePkBMCl1+eUP+3yLQnN+2SF17+Vi66+sV0VhYoD1dpLLfQDJ1er8PM048TuX2eeXI/zXqD1tpjCFIkCmedeREXXLqbjZvGeOrJgwwMDNDtdonCzMfilptupl5fe87g/Fk687NHlnWDasPo6CbOu/A8pqbHGBmoYA7kwe0TIhnM16iO1IiimCAIUBSFbreD73h0um0gJQwzLwfDtjh5/CSO4+D5PZIkprnUotHqEJFJ+9aaPXTT4PTNmyGOmZoeodtrsWnzOGEccNe996BrFu12n8mJTcR4LCyvZEDdjoPrBhmZRkpAw1BiTAP8UCNJMpcz0yrQ9/ucd+FennjkMXw3QsuVUIwK41M7ydn5jH5OQnN5kVf+2umoQYjt9xFxyOziCk/NzvH0ag+haSja5HP2lCmZix+pSkZ1cpFECHQQFoo2sK7IcLBzKT/4158xUG5w24+/ydFH97F3wyaklDRaPSamdmJZmRvh0Pgk2uA4pm1hAKaqsdRqMbVpCweWJMd7Phgqai6P1NVM2uj0cHo9hgdNnvj5D+i2exj5Ms1Gn06vzeTECC9/2dXUV5d54WUX8btv/C0efOA+0iREiiz4PlfVIZNdQspF23dx4fnnopkGr3nD67jxR9dTDzqYmkFloEwaJ3R6bTQEJxbqLM8vcKLTxXE8Ngzk6boeB2bmuerFr+TCS86h2T7CZaecyuc+fg2j42P0+h5hDImUpIlCJFNypTJ+ksFzm80miqrjOAGbtmylWCyzcrKelecUhVarxejoKLlcjmqtRn15maWVZc656EIaC3Xqa10u3HseEpjavBG1ZJEbGCCNQnodn5/e/TgPP7mfTdunWT4yy4G7byHER8/DeRf8Orfd+n3+6OuP8OUPvZm4+QwoKcQaugqmloCwcCIDYQlGahtBxFy49xxaq/PEXkBLt3jxi9/A2aefimlM8IVPf4K77/hnvvWdW9l78en87N5beemrXs7M2gyFagnhpAgsSFI6QR89TBkdGqHjOCiqyi4zR/zAPvZ9/9+43MnhDo8iggrW5lP4zql5FnXJdR/+Y1YWG/STEOfkA8TCAN1CaALcHjJX4x/vnmFupsmJwwsMTw5Rn5/FVIoQOlz1srPp+3kef+THqFJl5t57EUIjjCTNxiMstPsszAf4a49kNsYkfOXugyzMH2bk9KsZKMZYIxoP39viqs2CnFnmscMps3Mhf/eZL9A5foi//M7n2LqzgFx7mv3HR7n+J9fhz9zOkw8+TCp6qJqNqliEwdJ/30wbKXj9W95BlPRxl5rUT6yxsjRDp93n4JP7OfT0PUT+ChBAqvP85/0a559/IXYetm06jcefupNnDhxCaCr9sEuiRhiWQqvZZMfuLYxPDTMxMUWpWGZychLDMBgZGcG2bfKlIoVCnn54EpnkyKk2ruNz7OQMTz76CLZh0ekF+D2YmZmh2+2iGjr9fp9ut0sYZFsrmaQIJYuhhmlmDDop0bQMTpvPlSnkbZLI5ZRdO9j2wg34vo/fblO0LUoDJYypIfJlk/sfvofqgE2Czq5T9pLPVeh1Xdoth+WFBSZqQxSni+RzOoVCgaKVpx/16PdddKGiGzYL9TYD1QoP7nuMTmONJFVQhEYSByTCwffXOPOMHfz8tvs4ZctW6knIg/uPIiLJ7qkRZvYfxAkcRqc2cnLtCQLpkSQOmipQdYtYpqSp8pyVpZTPZtmAopFEGY1ds21Gx6f5q7/5LI3lA0yXNEqylE3lCYlt6rj9XkaeL9dQhIahqCRRjG5ZmLpBtVxCV0z2PXMrT606lIrDNDtNVhpNLENjvFbDMk0WZ1Ouu/5m3FaD8y55EUsLK3z20x/Dc/ucfe7ZQMrq/DF+5+1v4b577+TSyy7EDz3yxRIySanPL9HzfOonFlB0nXuOPsPo0BCn7DmD5ZNL/OyeewjTEEWz6fsuYeQT+R79fp8gSDAUiZOqFAcK3L9/EamEGJbK3fffwdl7z+O+Bx5m0+AIUQqabhEkHmGSEMYJdi5H5KWcXFhECo1yqYKh2gRRTLk0RBqB0/Hw4xQ3zHxAuq5POUpQ4qz1G0i47LLncej4MWI/YKhcwHObOFGCtppnx8S5GELniaP3oek6u3dPMzhkceTgUVqrc0TSR0OlsmGMA8cf40vfu4/H77yJeO0oA1aFftQgFgqx0IkDB0kAmof0VEq2zvDICH6vzdrSCoEaMD6xh9WlY7z2Tz8H2jO89I2fROBz8x13sOovcuELLkQqUBqoEAYBuqJlQ1WKhkwtEksQJynqQAkZRzzWmeeCF17I3lKZpb/+NkncYTypoDx9mE2nnUu/qPDpa3/IX378f/LXf/UhDh9a4RMf/BAP3fUd9DDmifk6ofT4f+44yebNm3nzFVP0ZYst7jDpVB6blLnZLr//mt9h7vFvkqYqAo1UVhE0kULHUAtE8RKqUeOUXZvZ89Lf5tcu3o7S38Y9QlDJpywutNi6J2ZPeYggcfizP7+fW771FTacfTkf+MQn+OgffpSCs5+9r38jN/zDrcS9E0jjMFvOLbIwC77rUy6P01xa+qXh8r9Fpl0dHpOnn/cC5o7NsDJ/HN9zSKM+iqpyyqm72LVrF8vLyzTWWoRhyJHDh597rqJkxJNnZVPFok0+n0NVVfL5PEeOzCLT//Ocz2bcYj1ZHRoawjRtnn/5C7ngwosxdIX7H7ydJPXRNZs4EnieRxxnI76O01u/vQ4IiCKiKMqmLH0Hz40QQtLrd0hiSeAHSAkTQxUu2Hs2lg4lW2esNkygCo4dW+To3DFGhifxvFWmp6f51g9u4vJLLkHoGp32GoePHEBKQaU8jhAKdt5GExaO20MqA/iJIGfrWU0s6NHtNOn21nA8FxGDTLMsUlEMjMoQXjdmesM4J44eRhE6r379b/PU/oeZO36cvGXzo+u+ycKJGb70l5+k0W5w6EQbRTOI0wRFscDIIYA0TlCUPIn0gBzoNopSwTJVrnrRWTzveRegWitMFKr84MtfQvF99m7bjGrp2IUCUSjQVJPBia3kCmWMQpV8uYyqSEo5GxeFfG2Imx8/Rn+0gN+OcNwIFA1DNWis1DGFyuZNWygXEgZHqkyNDnH4mYP4QQ9L0dj/9GNUKyUmN0zyx+94F5WBEvMLx1hq1jFMk3KpxO4tOwiCgMBz6Xf7iFCShBEzJ09QqVYQioJtWSAEruuTpqDpejY9l8TrIGUdt90hSkKeePJpfnrbvdy97z7e8ppX8qmP/SEffu/b+asvfh7dSJHCIpIhCwurJEB1aCTzME8lQZhSKFUoFQcyiKyqZQqFWiXzSS9kCptms0mtVqPb7dLvdAllTLGY57ILzmNm9gRjo5Po+QFUw8IoDfDk40cI4jmSMMomGC0Ft9um0WixcWSS3lqTa6/7EQiVEJPJDacQOS221nLs3LqFi869lLbbIBU6N99yI6MbNpErlVleXqTdWWN5aR6n08aq5Jg5scZ5572cd37gQ7zyFefwwT/+Ot/4x2/ynj96A7/3njfRDvokQtLvNRkYrKCkClqsoakGqRKjpgrtTh8njTBqg8QipBoolBTBVKtF90f7KB2oI40CiwsO+itewmNWyjs/8ymWHv4BYmgr51x8JV/422voygLX/Oa72Hz5ebzvVS9j5v77Oe1Fl3FCL/KNT/8lN/39h1CQnHHuW3nqoRvBiLjwzPOZXz3M6nKbwfFRtp97Jnf9+CH2nvE87r73q6jEJMoE3zo4T6hJ3vbqa3j7776El1yxleMPH6F87ijnb9zOuMj2oE/sX+LR/Wv8zTdv5yUveRlht82HrjmT1733y3ztvS9n+/ZRLGUCVbZAjUgS/vtm2r1eiztu+S6QgkwZGqwwNDjJ6Ogou3fvptnoosiY8bEatm1z1p7T2L17NxdddBEnTpxAN1SiKFx3zIoplUpEUcSdd96J4zg0m000Tc++DGlm2BKGYdaITJJsKCHMShm33X4Ljz6xj7lj88RJZvDT7/fXg/z/aUyuKFqmY/73FSBFCHX9duZpnUoboUQkusE55+xl9cQMql3mroNHkEEDZWgn1/zpX3DH/T/nyUdbzC8tc/aZpzA5McL9Dz2MpsBFF1xAz/GoL/cQqkpjrZ0FYU2nPKgTuB7zC4voqkARmZew1/dQEKSpRNUU0gikTPH6DsQBJ2bW2LL5TE4uLbLaOs746CQjw5M8/fRBXnT1K9mxdTPjw+McW1zBtAw8PwBVJU3CzFZEllBSlSTpgzQQlo5MdDQjxm2vcNVVH6axdpT26izt5CS9XoeSlg0SlUsFkkQiVAPTtCkWi+imlSm9o4goCcmbBvmhCrpe5MH778OqTVAeGUIKLZNnJZJqZZCdW7chdIUo9Ln3zvu55IIzOefMnazUV9FTlempYVSZkioqK8vLrC0voekpBdOm57ssd/qszi1iF/KUSiV0RSdyAkzbZtPW7SRp5pYYhiG6pmPZOlKC47tEMsucAcIwMwH6ypf/ngMHD3Ddv95Eq9vCW55jz8bN/PWnP0MiBJVyGTeMCfwE27ZRLYt2t0vOsskbFrm8RbvbJ44jCvkytl3IYLRRjOd6hI5LuVzG7/VpIyiVSlTGCwwOD3Lw8GGOHTuOROA4fWzNZnx4FD9VmV84hmUEDAyUGBuv4UceZ556Kk7XYcfkVh556CESQcZPFJKV+iKR02TX5tPYf/Qw9+1/Gj/ssVZv4AcBZ8oEwzBYri9h2Qbdfg/T0OnVO4hI8OB9t3P5lS/ne47Ho7MHUMsGWzZvoGDb+NInQWLXavhhgG3l6PX7lEoWq6traKhMT21ksbGGpuiomo6mqwRKgl/cQPElGsePfJtpW2fj1mkev+mnXPaKq9k7Mc25732QD3/8T9AqI5SGCjx8Rwtt+lSu//xNuE0db/4Yna99jpmlLkH9ccztb2awNsFj934bwQgyfJq79v0EoSvISNCbWaUx8xQRBe6571951bv/iicOHGShE9EADh4S7Hne87nlp0/z9pddwsQeAWPDaP4aDWWRgia4+NQNXH7KGFe/aCfzdYUXX/4ufnzdBqb3nMbNP28wX89RPuVlPP/i03j4kZ9x8qEbfmm8/E8zbSHEFPBNYISs7PdVKeWXhBCDwHXARuA48BtSypbIRv6+BFwFuMBbpJSP/ifnkFlQFIh1hYdEQyggnlUiyF+wZF4Pjs9my4ry76/1rOwsTdPMp3Z9ZP3ZNSHU58gQisJzDTUFE5mCVBJ0XSWN5XNBWlHTdVRRhj189jw89z7kv8vdnrtP+SWBPrORvfrqV/GiV7ySC/aewVmn72LW04hNuPGHt/Mnr3k+O84/k+biSQypce7ZO5g5dgLTztPqtAnDCFSbKEyJI5UkDel2QzZuHiEIHHo9b72WnLmWpWH2XvwkIAg8hJo5zlWqo4xOT9Js+og0oVo0cdt1pFVkeGInTz59mFwxhyoT6gszDI+Oo9DB1A3mjs2DEkOqoCkl0jTFzJmkUiNKss/iggsv5eqXXIldCKiVLG748ffor6wwpgmsRGXLyBCjU9NE6zYCOSvP8IatoCjkirVMp40kiQJOueQy5lcbXPXad3LFFVfQCgzitEO732Nyy0ZOnFzg9a99PZ1eF2d1DoRg4eRR1paX2LBxnC2Tm/n+9d/m6MHDVCrjHH7iIfI5C7fffm50HCkzpJauY+YLKEKjWqli5ktohkkhXyRcL0v4rkcQBHieQxC6hGGWMASeQ9G2cDo9UhllEAEzj5JIkqDDw9/5CieWjvD3/+ufaXfbTO/YwdJqnbWegx8nCN1EVwU5M8ve00QwPDzM8MgEs8dOUKkOMlatoasanudh6jpbt25lYWEB07aplMscmZll++5TKJUHWaovsHP3qTS6PtXhMcqDY9z6s5+jaQEildRGCnSdLoO5AdbW1vju928gSUDr9hiwNdYCyeadO4GUXn+N0kCR+bkTjI0MZ1OZisLh47N4XkDfcYhkROKHxH6QufGaNfpOhAxW2LDrCqzpKldd9RLe/u7fpNVdWQdQC1IEfhBQzBWQASiaSqzGxH5MXs3RbnfQTZsgCjFyOomiYcew6ra5cmiY2b+7kYrjIKu7SEKdL999A7/xpT+jnrh8/KNf5LZv/RlqOsab3v8nXLI9R2IVOO+sF7Hj1AIGJlIG3NMykUHKpWMKayLlX/5tP6ecdzpPPDDPhl2TPLHvAS7bMsShuadpNo5z46GTiNYCd3z3XxGpjxS72XXla3jru15Lzu+z5+xtnL+FDFYtLSLPZ8WtU7IKKLkChmYRopMnRUHh4GE42ehx449v5B+//lFqhYijx2b+y5l2DHxASvmoEKIIPCKE+CnwFuDnUspPCyGuAa4B/gT4NWDb+uU84O/Wr3/loQgNZA5NVRBKBEiM56Jjmv1TAaGaomnqcwHSD9YDb8ov6bMqz1keyufsDyFN/71WkvmbZxFfss5kSyEM4nW6ShZwk1QhjjLNMZB1rQDT1BmslCgUcyRJwsTEGNVqjeHhYSzbRtd1ioUCQkgMPWF0fJqVRsoH/vB9pEAf+OlCD0UrMl2Eg7PLTJx5ESdPHMYWsLy2wqFDCsWBIRRNQwoDPwxwvRau45PEKrohMIwSTq+L43afK+PYZg7byhEAzVab2vAQYRhg5E1SKQhjQX2ljRN18ToRfj/HcEljsbHCph172LJlC2ESsGnTVmYGyuTtHOVCQhrFjI1tYfb4YUI/otVooCjguT6gYFpF8vkCF124i82bynz+859lce4Yi0uLTBQNdl95Cd2VDn3XRwodVcvc/JJUEEUR+XI584WJE6SMmJyc5PjcIgwNcdrFL+TIyiL7fvhPTF/6Ygaqg7zy1a9A10xmjhxjvFamH+Y5sXSSseEyr3nFlXz4Ux/jJzfcwKe/+Bn+x59cw45dO3jqoXsIQ49S3qLruqiZTQyqUNdr8SqpUImkgi4VbLuMUAxKJQvHcbAt7bnySBJGRIGHooChZYQfQ1NRdJNUSrw4JGeYiBAI+/idNhvHBtl82fn8+LY7yZcrNHs+qiJJk5QwlmhCZN9LRcEPI+JUUiiVMXN5PDfCFzFjo2OEYchas4uVK6EbBvW1Nrt3nU4UJywu1EFVaDRbjE1vYXBohGNzK1SrU+QLbaIoYub4HK1Wi+Nz93P8xAkMs8TmrZuZ2fcI3VAhDRMeuO9BxsZGWG0uUamUGajY2Pk8K6urtDptVlstFJF5RftRhEgV4lTDEAqdQEeGxzlr74sI7TJve+sbuOwFL8APPQyh0nc9ciUbkQjydp7ID9DUZ7FfCZquoOkaxWIBSzdJFRMnDikaJkVhsq1aYk465N79Krp/+y/k4w7d2gTq8CBqFUpqjq27TmP+yt9n9yaNb3/163zDmUPIHlIrMmptYdevv5yVR57Aa51g1Uuw5CCVakyxWCReO0B9NY/nHUeZeiFfSG06iw+hcYLI2IoIYj77+b/l4kufD6hcf3g/tz/hsGZYfPiGW1n65q8jFYHCGqFVZEodR5g2CPBSn4LU+cS/PczhB+dIRn5D8p8AAAAgAElEQVSdxPf58d9+lmp1ir0v28vRv/rUL42X/9c1bSHE9cDfrl+eJ6VcEkKMAXdIKXcIIf5+/e9r1x9/6NnH/arXtG1Lbtk8jaZpSKJ1A3JrHfOjksubmKaJaWhYlsXYyDBxHDM4MIBhaFSqtcxK0rbQNI2BUhnN0Mnn8xmRZN28SSbguD3SNMV1XcIgptNt4fsOrruCEJJoPTP1PIcoymrl2RSgiky1/xD0w9AnTTPTl16/A6wjqcKQJMlqrnEYkkQhxbzJwbllOgzxrvd/jB55Ljr3FCatgKppcuDQEQ4dn+P973obtvTx+j3yQ1WmJiZZ7fbpdRy8XsaTsy0NUIiigCSRdNstxse3omkms3OzmTGWSFF0g4HBEWIJMpBoZD7Qpm2xtLSEpWnURjajlnLMHt6PEScMj0wwNbmZ+fl5em6bIEjYvn0zrXadKJYEQUIQ9hgerqFIn97aGotL8+hIBvKDbNg0weLaSeaXVxGKQqlk4Ls+cQhnbhvngl2jNOYbnLnjdGqTGzFzZQytiKEZ6DkTu1gkl69QsovohqDT73Da1Vfx0c/8HT9/8OfsefVb+Z3fvpobbrmXpZMneeqhh2ivrPGZT3ya2++5l9PGh6hUh/jJrT9hba3O8Nhm+u0Wo9O7ef6ll6LbHX789b/ne9+5lvrKQoZ3UDJOQ8GyCWLQcwOkCAaHaoyPb2RgcBTdtLCtHKurqwROj0ZzBd/rI8M+vtslcru4gY+qa0ShD0Jk9G9dZWRsmDdcupeLN+Ywgoh6p8mZey7iL778ZY7Nr5KvjeKkAmnmEIqGphk0m03qKw10PVOPFMtVxsfHqRSHyOVytBpNSqUS0xs3oGkauq5TGaoS91wKps3ZZ5+N1CMW1paojI1RHqhyzf/4JMcOH6JYinA8D8Mu48cpWnGQxaVlTARBr4NiDWKWhilWdaI0IHQDdm0ax7AkvfkZOs11bJei47a7+L7ENC2SRBJLlZ7nkbfyjG/cyPs/+BHywyWGN1bRiwoSBV2VWFKhWKjS9TrYVp4wjkjTGKlKVE1Di8jI58QYSuYlEzgRLdchNnWmikVCKVCLGn0/4ByrxEPfeIhb73kU7aLdaBvG+OT7PoIykkPaLmoEtU1TrCzNMLrxFOK1AHMgxcqZrMYuZlql1e6TptBTAkbHqujVApaeYpQLdOtd8sWE7nJEpVRBUw10e4Knn3wKwxqk6S6h9XvUpsfpJgGy66E3BvCkIEp9pAwwaxUqhUF8qaAZBhYO4cIR3HSF/qGTgMFFL38xlq1Qd1d46iN//v+/pi2E2AjsAR4ERn4hEC+TlU8AJoCTv/C0+fW1Xxm0x8drfOZzf4CUklhmFAdVS1CEhkw14iijfyQyJkkiwiCAJCFabwB2utmQQn/BIUkSnF6fOA7x/TBz5IqCzCdEUTLT819QdmiqhabpqNJCJilJEiNFimFk5kVJIlHUCE2XpDLMSjhCAFlDUqDjuD0MI0McJUmEoekYhRyKopCz8ggloZQzqE1s4bg7wlC1wgvP2IpU4OZv/4T7Dh/g9n/7PsMFi4nBPF47ZGh8FFEskCsOkPQcPD8mkRDHCdJL0DUN1+0TBhBGPsdn5ymXaoSRYMv2LeQrecrVKqFUeOjhR6kWB1GjFKfvEcUu46NjOH5EoVKg4/ls2LCBI4/fRr8fMX9yFl3kcfwjwBizRwPWGouQFhisTdBb/+H7zVe9DDXyOXHyGH67y+jQBD+986bMFF6kSJnSbcfk8iqjtTHGxkbI523SSgU/CFhbW2N0okBMAmmMahlEUYJpmuvMvoBcIc/JYyfJ6Sqf+Nq1zLQO8Uef+wrHDh/AEJKdE1OYusZf/MUn8fseN544QKU6SK6Q5+iRWZzgZ1TLBRLlUe744b9QrvV4+pEDrNRXyBfyBFFEHAcIAY7voap29hkLlTSBdruPmYvouiFDVQtFN3CjiDhDS9JqNvHdLjoRAjIDMMjM7uMY4phc3mTrpmmcZA5VKMgooddsU84ViII6QoLvh8weWyRI1neAQrB54xaGh4e54PyL2bR5O77vk8QKpmkyUC5jmibdXo+e02etvkqz7RH1HHo43HLTrYxtHGFy6wRxHDM2OUGjsUp98Sj1pRQEmAMuqmZxzo4z2L5lJ6Ks024u89mvf4/b9+3nf77lDew590wGc2VwGwT9Fno/ZFC16AYu3X4fNQLLtCFJkWECioJt5+kLlc/+zRcYGtvE0upxRkaHaHtNBgcHWVur40sw/Bg91UnjOJuf0DT8JCAOfdTYRMvpeEGAqiaoAswBHV1qaKYkskNcVcF0A4oJHPcanNg8xAdf906+8JEb+NDbPszmzRs5ffgsjuy/i7AYEz86y6lTk0SLKbpp4B88xuhYldxKk1rVJl+pse/wIbbnTXpLS+hikNV6g56jMV4bY61XR1EjWtpREi9AoDE5WmaZZ6hpOaQXo53wmBI2aqtHPrcfl5S+UkKaKWGjSiW3SGyqCCXl+TtH0TZuYGV1iOYZKqbsEz12HdXKAMaiw1O/Il7+fw7aQogC8APgD6SU3WfrtwBSSimE+L9K2YUQ7wDeAVAo5PnZ7U8gU0G5OABAGvbQFUGumAOho+kKyBhVVTP6xzouyLZtKpUynU6LsdoUlmURBQGGpme8tjDEMAxUoZAK7TkaRRQFWdkkDDAMCz+IURSNMMyGcBIlIQpj0lTBcTr4gYPrqQSeT7fdYnl5CU0VKAosLi4/N7TTarUQSQapFUIQh1nN/ZRte9h2+U5ySszTd9zDxt3bWFus8+ANX+fMM7az4fLT8CKNWx58kEXXZdBQOGtsA7XBIg/fN0sqNIqFIqqSY2hoGMMwiKOAiclpbENycnmNubk50CT1pYO86JQXsrS8yvx8k6pq0FpZxrZt7JJF4Pk4Tp84CVGly+XnnMHs3Bz1ydO44MJz2L51DzOzT7J75wfJFco0Gh5dZ42xyWFaK2v87PprWTx5mH/6wU/5gzf9Fgd+chtJ/SnmU5PyhlHe8abfZ3ZxiScffRQtDklFipLTEFqC3w5ora6ybXITZ5x+OkEI/UDgRT55cxhNz/H0k08xOT5CsTZEsTRIyda56cff5uMf/hTT4zuZO/kQG0/dhqkLZh+9m2KxzFCtTGOlwRt+42pWeh1e8ILX8ok/+yDF2gbkQI5usMSebdNEiclXvvgVrv3eD7j229/l0FNPQpoiZYRlqiTSJ3QjFNPGcXRcr4+ZC+h1XU4ehr6/StD1iXwHSNFNQa6gEkcCXSi4vsfwyBiNlSUUAR9+96u55ZZb2TassjoDvShmfHIbB0+cZOLUPWzJVXneS1/N6MAIk5umUMw8jz59AkUktOqLlEolntn/DE4UUx2dIjcwnPVmVBM7n8dIEnZUq1RGq+i6DqlHtWahKwIFSZAI5o/0MdQC/Z6Cqp6HFPNoskXU6hKKLp1Om421SXK5YYKlhNZTJ9iAyc4tG5Arh4hzOvPziyjCwHFAENJoNLDzOfppSEHN0es3Cf2AW2/6EW953xf45If+nOWGw5q3n4uef37mBaRadDo9CrkypqLh+X2EqmAoOqEfZY53mr1Ossp6L0WjTJqmREkCoWSwVAWZogQhwnGJtCJpYLAk27zi3HE0Cz79zX/i3CsvwAsd6s4scU6nnC9llr9GgW6/hwgEqpJjadkhnx9kzXWITJOh/ACJhLwG/d4a1YpFpZwiqTM9XUDRDPr9PPnxPEKotLsd8iHEcUi1WCRwPYRw6ag+njGCbhiIIMBUTYqWDlpEQaokUcKB2WUq5VE6rR6kKrqdQy9M0otMapt2A7f+14O2EEJfD9jfllL+cH15RQgx9gvlkfr6+gIw9QtPn1xf+w+HlPKrwFcBNF2V//C1bz0HTw2DzNeaNMnwsM9OwCjZtaoIkkSiKpmD3vhIKRtk8XxUVSGKUnKWRj6fmZlLKdeBsRqmmeGrmq0G5XKRwPEIwxgpoTJUpFqrkKYxSuQRx+A6PoMDJUZqw6h6nHkZT08watU4dvQIimayeWyQZqtFbXSYYi4zKtK07Aci9AMsy8LrJYyNljh6ZJWGvkocQa/n0XR9ZpdWUaKIrhdTbzoMVoZYWpyldN4eDh48yOpqH83OGHT9vsvs7CxJIinkbQ4fmUGkARObdxLGZO5vls0NN/wEyy5gF6oEQUgxX0DVBL12hzRN0XSd6uAAaRrzD//wNWoj45x1+umszq/Qaz7CWmOFZx6fQSqC2tQkoZfy5H0Ojz90Bwg47fS9kB/h+htvZam1yER+CDfxEUHEgQMH2Lh1G489+hCqhKtfeiVXXXUlD958PaYmGKqNUxmo0eu6tDoOW3fvIVV04sij01jGMBSkptD1I5qLdUrmEEePLFHZXsMZ6zO0YSt7zzgHJUxJXQcZxnRO1Cmrg3zoz/6ZSOnzwr2/yW03347QFN77Zx9naGgzUbfDofo8x08cp1ws0Oh2ef9HPoKtxbTri9x/2y0cPnyERMRoSUhvbRFBzNNrM5lcEh3VAKQGRFimQaqkeJ5HPm+zfeNWFlcaLNeX+J03vppur8HJlRn8nkOCSk9oeCbIooXPCH7bZMOurTz2aJ2YJQbKs+vNcZ9NGzZw9OAzqKrO6afvZbA2nQWxfAndtEhkxtLM5/PZ96LRpVjKUyhq1Bd6WYNYcXHCLqHmsKZVuevRnzJRyVEUKqqVJ4wUpoZq5DWLAcvG7XfYMDpI0FqiubSGs7SIlg9ZbvaRoSBVJK7voGkm+YFRwijBtgeQqcaFF+/ljz7wx3z8k3/O9T/5ET+76w5efMXVRMKn022QyghSBUPViPyIhBjLyme7B5HxKRUFdF1kZHM3+g9zDoqSrXc7TXJ5CxXJULnGWsulMBgwImpc9eZvc9fN3+fKl23Hd1QO7DtA0Sqxc/s0lmUxMzPD5JSKApSKRTxtve+lqSBUXNel3W5jWZlSRzcMfN8lTiWqbnBycYHJDVup1CaYO3YEKwe2XUAzC8gkInAC8naBJA4ZHhmn3mmiGipBmBD4PQqlIoZQidOEQjGPooestlbRhELgeZSKeVSZEMcp8wtzvzIe/6dBe10N8r+AZ6SUX/iFu34EvBn49Pr19b+w/h4hxHfJGpCd/7d6NoCmwMSQxnBtkiRKaNRXmR4fxzQ0wtDHi7Ia9MhoeX0k3Sf0M3JyHMdUh0p0uyYyySjGaQppGlOr1Wi328C6zC+O0DWbKIqYHjEIAo+WTDAGTAYrJWrDFQYqeZIkYrXRW4eDhohEousR7TUHP3Dxui75nEUSK/iOQ6KqBF5Ir93B7bmIWGDbFmmS0Gq1qFQqxLFJnOQYGcnhOA5BCOWBAZIoopQvEPXbDBYsKnmTk/U1zjz1dO688y5Ghse45Hnns9ZosLy8SrVqsWnjNqIoYrW+TLE0gKEInnziEKZhs3XLLjzPo9vu4LkRqfBQtcyOVkmgXCiSIAmjiG7PQ9NNTj/7TPbv38+999xJGASMDo1RHhgAqeD3Hfbd8jBWcYjtp5zL5S95HffeczsHZuZIvQXOu+Qsrtz0em6/7e8YTBSarQaShMNHDrLvwQeYnTlKGAbs3LqNR4SCUFRSFBqtNuecdynLK02azTZDo2NEYYrT76IbFkEYo+iSEEG30cdxQ644/0WstGdJI4WH9+0ncUImS6MYUqN5ImCuvszn3/83vPczV4Ke0nysw4uufgVNJeDKl+7BazXoSxXfdwmSlLXjh3nswbspDw1ipi5XveR5vNy4gh/+y80c2H+ckeEhRkZqXPOn1/Ce33sP3Y6flT/SJAssgYthmaiqwHEcnnjyCRIUBqtV6ivLtNuLDO+aIBXZtKPUTBRD55mFLppVRS0O47dc/MRhaKTG8WPH0JWYnBGSUyWKkJyyayc5y84YEXaeQqEEUuAnCQPlbMQ9SRJGx4YxTYVur4NlFUDtYWoReskkUspofo7Vro+dAylSgliFNGVlZYWxLSHEKSoBQoR86qN/TLPRY7xWorU6m+1OY4UUia4V8MMYKWIcx0HKFEWzeN0b3sADDz/Ey1/96/z87pvohX0SNaDXayH0rNdDLFFUQehnTX9dN4jjDPoslGxHmq5/tohshkIov6goEximQNMU/EASBx7VsoGtW9x8/SzPPHE/A9UCi0t1yqVNFMsVbMNmtblGtTq0rhhTkOv8SE1RsaxsUMx1fKRIGBwoA4Ig8pFpVpKMwgyxJ9Ho9XqZrYOEMIlRAg+pCHRFyVRsYp10HwRYhollGCSGCUlMr9NHKClxlGDnLEYnLIYHx1CFwlzLo9MNsZ418UmD/3rQBi4C3gg8JYR4fH3tT9eD9feEEG8D5oDfWL/vRjK531Eyyd9b/7MTaIpgOG+ieF3SIMZIfETiEHkJUeijomHJkKSnkYiUOAgIPI9Uz6gnrqHRbXZJkoh8Pp9BMdOUNIxI0zSzSC0W6dWXUHOZl0sQu+RsAyoWhmFA4pN6PvVel1K5QK1U4uTsYkaoFkpmk0kfoaf4cY+ZZ2YolXJYqomZy5EnQVNUZJIShQGVkk0oUwxFoqQJYdBFxh1UkSeNUuIIWs0+SB3fS0jjlERJKQ1WkYtLJEHMrh276fV6PHPwadodh2KxhOcGHDp0KGtI2nlW19oUc3kMY4AElb4LtllifHIwa+RIaHXa5O0SqpD0Ol100yAVMDI2zPz8PLFMueiSi7n71p9TrJawihaHnnmc3GCFWnUj51xwPmlqEAYBj+67j42btpKic/Tg08zXm0ydMUg/iomEIA4ktmnwgksuZf+TT/Cda/+ZJx/dx/XXfgcbhWani6XZPHVohq53A1u37SJfqhKGceYxrqk89tQBnCiitrGEXSzywF13Yqs6F4+dx5G1bWg5h+e/7QW0+/N88mMf4bfe9Go+cf8fctN37+JP3/5bvO+LC7xx7GVstQeZSF1cr0NsaaSFHHrkY5omqpDsOvMc7EKVUqlIf7XD3NwcURywbftp2PkxHtz3MCtra3zkox/Dcf1siCsbJ0KQfa/CGCy7xPlnn84ZO3Ywu7BAx3Hxgja6rhL1XdBBtW3aao6lRQd1cAP9VkR9dRbTtAk9l+NH5xgfK1O0bIrmAINDZc678BzCMCFIdGIRk4Z9OnMnME2T8alpGmstNmycIk1T6vUViiUT01KI4i5pZKCYFYQS4fgOfVeydUOet7/zJ+jGBoKojyWVzLxfF6ipRzmvkCQBR556CBUVJRoEITDtEo3VDooiQAQITWfrjl1cdukVDBQHmTs5z1e/cR2XXnY5ey+6gPL2GoPVAm7UwyyaBJ6PpZvopoVlGEReSLufwXALhQKQoukKSRKuK8MUFCXbHcdx/O8qMAGGYeL7IaZZJPT6jBWLXH/THO/7w48wWnOxYpVdG6+g119DSwQjAyUaq0v0RYtKZYB2pwUiU4y1221M3aBQKmDnbNyeSxgEaJpBmiRImWDqGazXDQPKpSEWlufwowwlaNs54iDAUFQ0JE7g4nt9ivkyYegTRiFev0fOtkARFCyTOI0ZKFTwPQe/0+fQyuPkcgYTo0OEvken20HVJLXhyn89aEsp7yGz6PhlxxW/5PESePd/9rq/eAghCMMQTdWJZaarNk2DKAowTR1J1pEvFHO4rovruuh6pg5xXBev14U4QhNZgEwCH0XTicNMotfxOnhBgNt1UKWS+Xf0HcyyiaXlyZk2br/93Pvouy4XnXEaC3Mn6HY66MUShmUSS1BUDUTmHzI6MsnK8nG8jpdl5EqCYUh0XZAkIYrI9N1pGhJ5Jm7fQVU10jjBMGDz1lGEqaPlDJJUIZ8voYms0RTFMfWlVYQQbNowRYJBq9XGHrORqcB1XWSaNWo6nQ7TG3eSpgJTFei6SrNVp16vMzg6jKquyxdTgaYomLpBo9ehvrKEqRtsnJ5kcWGZsZFxlpaXGKlNs/PU8zi4/z7qYUocjxMlMcWBEaY37WSgWkUzNNJcmWMP3k3pokuQKViahbThe9ddx7XfvQ4kTG8Y5w/e//ucfPoIecMg9gTFUoljRxeo1Twc10UzCzyryRkcHKRUKqHoWjb8JFOmprfz5je8h89/+bNMFs7ii3/x5/zuu9+CkY+59V9upNVbY9v0bprza1yGzzmjlzCY95ntPIJq6ZhCYKsJUdAnCSGMExSREmDgo5O3bUJNJ45D0jRmfmmOQ0dOsn3XVmzb5onHHoM0U98gBTlTEgSQRDEYecrVDJN24MABMLK+SNnW8SOJohpEQNP1WGi5aFaVQ0dOIBKFgVIF3+2Qt0DXLYq2pDaUZ6g0jJWz8QIfEExv3EKnnxG8MSu4rkcYJZQrg7Q7DrZtMzo+RrfjECcRrtdHNwr0QoW8YjNW1RkclDyzAI8/dD9p4KOIlBSFxFBZrS+xa/duTi6cZG7uGTQFkjih03aY2riZnuNh2QMksURoKlMbpnn8yceo1mp4/YBKdYhzzzuLN//2G/nGP36ddz7vXbTWGii6CjIll8vkfF7gEXk+uq5jWRZCCBqNBtVqBdu26fUC4jghip6ln6/Pboisj5WkKbpiIgwdRcZUihXueazHP1/7r+hxgNdro5oFGt2AKPWJZMr88jyGpnN0bpbp6WlqtRqNZgt7XZJrWRa6rtNttUgSUDFI4hTXcUgVQSIjDNOmWMpjGzleesHV/N57X8trXvEefD/B0jScbgekREGgawq+7wECw9RJU5Uw8ADQDRtd1dYFD+tDVZqk1agTu10mJ8Y4ZcdOms067ebar4yX/y0mIoXIthqpzOgdQS8kiCNUTeA5AYYhCEOfbjfzW87lbPr9PuVyEdPQUE2DmAw7nwgFxTDRVTXzUi6VSJEQJxiaTjFfQAjB0GCVYrHI4cOHMQ0NM1/AixJyxRJRFHDTT28jChNCqSJSBalqJLHEjzPayOTkEKuNZRKhUCpW6Hb72LkSEo04TAhjgaaZgIXEJEl6hJFDyR7H9T2SFDxHRUYJgRcT+AFetJyVMWQ2EXjaabt49NHHUTBptVZwXZ/A9tANG8MwWKl38DyPwcoovuPhBiGkEQMDJaSUDNVGKJWrLHpLmbm+ACVnkWoKw0MjuL5D4IW47S5JHDMwPM7Epm0ceGY/pVKJraeek/04kKKYOiuNZYL+cSwzz9jURgqlYUY3bebeB+6lYNcI3VWsCMpAeXiAcy6/kHZjkU9+9C/5+O+9hSMHn0JJIzrdFmeeezbLK2vEx45SG3EJ0hDd3kW5XGbLKacRxBGu32d8cJAf/vgf6Hs+H/ntN/GVr32ZT390P4McZ225zu9cNcKm3CDn9xzscg5CSRQfoH/SYjDVCIsGutonRiGyc0i/j6EZ1IbHcFsdDu57kAvOfDMHn3iQDVMlVhorDI4MED1zhMnJ7Zx19uk0Vlc556w93Hnnnf+bufeMkiytznSf7zvehMlIn1m+qst0VVva0Q3dgBCNExJeIMRlEAgh0Ix0xSBhJMQdmUFmpNGdK3GFEEjCzRUSQgjoBpqmob2nfVWXT5+RGf74c75zf5yshJm1+N+xVv3JFVVRERlnn/29+93PS9hPiLMcTVdkheLAwStYWtkgLmoYeolpO5TpgCzp4tkOZ5cX2TE3xxOnBmx2NDxXY7bewnZ0Tp99kiga8VMvfSF1r87FRw8TBim6OU4uFKUOrtukH2t4jUlQAmWYVaScYyNMBXmDKFOsLvao13U2lgWO2+DY4TqJKnn5a/+Ax+69B3tsFzvnLmJy/igvvPLjnD1+L/ff+VkmXJ1XvfJG8rLke9+5jdGwi64JSk0nykrOrKXM7dlLzbBp+Sa7dx7ke9/+Z7S4z/23fYPZfYf5lV95B91ccd8T3+fdv/kuNlaXsTS7Oo8UJaudiiE+1ZxGKZCipOXWieMYTbcYDHsMhj2ajRaGLirJIs+hFAhKikIRpTljfpOV9iq5lnHx/CSPP5Pyjl/4ELW6YnwmJU+miYIIzVjn/Okl6q5FrztganYO15ghHg05sdnh4OFD+LU6hmMTRyGqzEmThJpfp8xNkiSl6dfI8py0UKBU5fBJ2nzpH+9iZnqCl770JXz+8//MRXtnUEVK0/eIoghZakizMkGopCTLU6TQcJwaug5FoVBFSqPukQYxjZaFbbSwNJOV5U26nZBG3cG1vZ9YL58TRbsoFaUUpKrAlFv+1rLEMi1kGoHUEVKnRFJvjLG+vo5pmmQ5JKnCMhWlgChLKMpqEzLKUgzD2HKKZKCqBZsgCHBdl06ng6ZpTExM0OsPmZ6bJ8sSgmREniQIzUCzDOpurSr6hUKWYGkWaRize8cunnnmKVSeoZzqNeIkYxREuLZDiaQoSgqqRaCiVGRZhm3pZComTUCXilQpsiJHSonpuJQqxzJMTj97mqZrMRz2sTWTMi+YnJxEiJK8qEKKTdPEdXzqtSajFCzHRKoq5CFKYgzdYhiMyPMcy3XQNJ08SYiSmEKvVvkNw6DT3mB6epblpVX8ukc0ioiTjDBK8Oo1duyYY6W9wfRsE5UUnD11nhNPPs78gcvYs/sApAPOZpXVzZI20lCc3ejxqukp7vj+t3jDa1/CoLvO5HiDLMtYWGzj+tNIoVfeZk0gpGIUxgjDRBomAoUQOaNBh7e95jWcPb/MJ/7wd5kb8+ivrmFlIw41LNy8oBh2aEvFgViQpyB1GBQxoWFTNBswCtDiDDmMkVJSpIparYFm2GRJTM2tEccxpC4H5uf44v/8JkEv4dRTpwl6G3zw1/8jn/m7T/ELr3sjt97yfQbdNkHaIy91FldXuP7G19DfPE+JII8GVZ6mb5KmIygkN7zwxZxY2GCU+fhNizxc5dSZRebmJ3neFS/m0MEj5IkkThRJKtFsG92w6IUxpWYxOb0LKXWSMCKVBn7dpBSSUaghRc76xjkwXEaxz9GLDPZOm9xyW5sPffjvOH3iIS668iCmVUJmsrKwzFTdZt+lV9Jt380Lrz1GlAbcdff9jByf94kAACAASURBVIZ9hNDIiwIhcmQpyHrrjAazJK5Gmil+eM9nKbIBqkgZBRknnriXL/7tX3HpS25i97FDZCV4lo/KS7KkQLdMvFqdKBgRxhGapiFQJGm25e3OyDNVDf4MiyzLkcIgyypipqFbUKb4nk9WDkiUYHqsycqqz6f++guYVoxpCLLMQklJFI9wPQtNKoIkQQgN23IRZUmuCmwlWDi/iF+vEeUJtmZQZNUuR57nxGGCShWmWW1IUxQgS3Ih6A9DJqZrHH/6ad781jdy22334To2mgqxbJ1g1KMUgizKyfKiii5UCiUUo1EP0zQxDAPTdBmNBuRxiO25lOTEsaJRb1EUJYbuMBis/8R6+Zwo2pQC23Ioi6LaiColuVIEYYjUDOI0QWmichQMh4xNTdDr9WhMNMk2cizLqXCkMqnSvB2HOI2I04RGo1FtT4YhFKIqZoYBVGyOTmeDUkiWV5dwXRfbNinKoloTVyXdXhfPdbFNhzzPSdMU37U5d+4cV111DbMTU3ztW9/Cdfyt7cvqJiSEqHDTQlAKAVbBcDNBzhcUYkg4VHi2JBGCgox0FIBukWXVgoYQAtt28bwabrOG79UJg6qLXl1r0+sNaDabaNKgVJL5HVP0hiOWzy+i6zqu56FvsY9d16XMq2RoQ9Mp8wIBtBoep0+fZazR5NyZ02C5DIdDLMchCQK0OgT9Hg8vLjAzN0dtfAzpSSS7kcJgmA55/NHTXHLkIDoCU9NoFzGzfouP/OLb0cddVpcj7vret/mXv/xTdK1Etx0OHtnPervD2PQkSZzjeC5ZXqA7BnGRgOFguHXcPODo4SPcfP0NFEnILnQmuqsI0yHOBIyq3705M46TFISaSX+UUZaSManQMpNS1JiwNcbnD1Ia6/TWlyq3kGmx59AlDHtdduw+yOTMbsYnPRo1jXCUIpCUyQJle4o//tjvMDHR4nOf/jS//oHf4S1vfQPvfe8HueHGl/Bf/vTDrJw4j+aUTM5M4hsB1rhJd+1ZDM3h1Te/gvsffATp7WTl/BL33Xc373jbzfzc699BmicMRxFPnzmP7ozBwEF3Wpzc7KFLg4sOX0xZKpSs0d2M6fVidh6wMR2P3jDC8gy6mzGOtYMjB3SE0Lj26hcRLJ1CmznKeGsGu9FgfbngwN49RPoyu3cUdNZSppx5Duw/yC233cHy0iZAdR1lirwsKUs4dvXL8MfnWV0d8DNvfA2njj/NRGuSB7/3JdB1pC4pY41vfvs7PHVmka/d/m020xENy6DQcigEuSoIgxTLqjMIQoo8Y7LVQOoaYRxiWTY1TWKZTmXPNZwKfax00ixGSoEqM0ZRxrAnuPzALO0e/NyrfpthtMjcbEnQL7HkOE59QH+UEvR75EkKZYFhSpZWztLrtzlw8Aiu43Pi5CkMy0A3dMYnxpCioN+LiIK4cqzYOmmcIA0Dy9ZRWkkaxjTrDpZX59ZbPsdHf/fXePs7XsuXPvNZds21eOyHDzEx2UQVJZajoReQKYUuNIpCUJaKMOhi6BaRGDE2NkaY9+ludJESfLdOlEaMT4yx1l5FN36yg/o5UbQFoJVQCkmy5a2u+CA5mqFtd8ppGmOaOkEQANUgIcsy4jCqrHWmRZ7nJFFMmmW4rkcaZ6RpRr4lmtZqNTRdRys0giBANzRKwPYssjxBagaihCxJKYWkVvdIopQoCrBtu+rik4yxsTGWVlYwdQvDMIiSCMuycO0KHHRhfV6VJSUKpQV0NgM6mwMaY9VrjAYF0jZRlGhCp1FvkmUZpWFQODbdskBr+NRrLmVuoGtV9yuljqaVjAZDarUGcRxgRpVveM++fbSaY5w6/QyDwYDdu/aQRCmablbSkmOhi8pdkyU5jUaNmuug6zq7Dh0lHPSp1+tsbm6yvrrG1OQktd270aTOqRMn8Xyf6bmdGLpDurnGavc8cbGLIAvxzQIl4ON/8vscPHoZ5sQElz3vCp54+Ane/3MvolGrMQpTRKYYG29UE3bb2bJj2ltbdhKh68RJjud4CCFwi4CmPk7DgiQvCLIYUxdYlkmkFeQqoR/20TUbx6xRFgWWZhKWOWmvT7vf5TOf/QrtQY+bf+oqXN9jcWODxx57lOH6BqsrK3zty/9SwW2KggO7dnD15VfyxAP30l9ZwfIdVjcHjHTB1KV7+L0/+yS3P3gvqQGUsLD4DG9/5/u5+/5vc/ud30RswfCP7J/j5EIHjBpLiyeoWSnveefNvPl1r+T8whr9SJAXDXIskrSB40uUYXBgzyFWl5ZZWFii18m47gXj7DssOXVcR9dqDAZdNtZTZndIgkHB3v0m9z68xkc/9HHURp+JXdcyV5csDU5RZDZRshfdMnGKTUxjyLGL62TDx/jWt/6dIpcYulO5q5KICxif51//AsJM44P/6WN87Pf/mL/6r39AMTzDq3/pd5jvvIDO8TuJ0hzTm2G60eD82TZX7T5Mkq3xaNalv9HHtXwsy0TlIZpjkKWCPJfkhYVugOWUpGmO7dhVSEkBnudDphDKpIgHWLaB0DSSWDI+3mCQlnz2H79Pd/NxxmeniYY5Uki6/SVULyKLMyQavW4XKRWFSomziFqzxuZmm7SWsmPHDmzHodassXDuDK94+U9z27fuxHXrxOEA17PpxAPCwRDTtoizmHqzgWkpoiDBNRrccdtDXHLkMH+yeBbXSDh00X6Wl5dxPA+oHCRFmpGpHE0ztvZKKlujbVlkeYRhUs1Itho+05IVIMz3SdPnetEWlWVK103Gxsbo9/vkaUpJQZzHsMV4EK6LKoptMT9PM3RZ0fSklAyH1US61WqhC0mWVtuJQgiQ1fJLEATYtkkSx7iuW9mn4hDLdcizFBTIsiq4OoI0jNG3Ot88z4njmFarhVKKzc6A1fU2lmGCKsniEUkcY2omUrhVgAsKZIHh+JSZxDYFZZoRDEaM1T0yUbKxscaMbrO5vsnSyjIzO/fTaLRYOLPM1ESDJBjRGyna631syyJNCoRUSGERhxHrG20G0YA9B4+Qx5JTp89Sr9exzSquLRgMcf0GmqGTZhlxHKGbBirKtpeUskJw4vQZZqcnefDRHzIxMUGt3mRldZ22VTGOPceht7nJykobFWcY9RZXv+hl5EmA4U+yNtrkP7//XVx1+bVceuXzEEg6UcztX/si9//LP5AmIVJzQFS/C9uWpGlGp9chTjIsr0VzfAy7blAkFYTKtg3aaZ/ZqRppL8J2xqmjSKMQrTCoNXx6611mrGmKIoZigC0kThFRyoKgSBH6gF/6xZ9iOR5hxiWDYZu5HRNcd81l3Pbv3+TYoUP83Otfx4FDLaIi4NzTp1jrnOU3f+8D7KzP8vK3/CJCd8lzxV//90/wxEPHAZOHHv4OmmYx6q+yvLnJej/hTb/wVgxG5HnMlceO8eQPT3L8+BKv/4U34dQMsjTl/uMDpBznzMoQw/LRzRrloM9jC23uvfNWTtz/dRQ2k/uuZm52D//9z/+C9uICU7t387H/62McPnKU6UmYnCr49lfv4L3v+kuCtcfQ9SlUUhCtn2a9a2EbPrv276dpGgxWH+anX3SE04sn+Js/+WRVnA1AKHRDkeUpv/3B9/K2t70B053gL/7y7/j0Z/8nb3jFbkoUL3vzb2CbKVnY5j/+6vv4009kXDzbYHVpA00zmd7ZYv+BfUirRZEMebpl0+l0MS2P+blZkjRFkeF4Dt1+DyFL5nZOkKqUUrdojjcw0Oi0N6vGaBRi2i7Ly338Rp2JyQY2cPVlb6O/mTCzcwKVBWSpRJUxE5M1wpFBFEREwQjb0kAKkCaOM4YQJWEU0B/1YRSQpQWmpeM6Og88cB+9Xo/hIEGojPb6CvWJCWxPw6t5mJFkY2MD13XRpMX89BQf/o1fYWbXYS697GI8vUSiiOMQw9AIgpI4TWi1miilEUUZmqa24HGSJI0gVUy2PAqVUqgc0zBB5BhWSpwO0Yyf5P14jhRtyrLCTlJ5sHVdR9cNpKajlCBLU/JSbfsse71KH7pAV6vX6wghtkl+SiniLN0uSJqmMRwOcRwLTUrk1h8hBIgS3TC2aIHVDUCYW1AqQ6tSyKluChd0L6UUw+EQXRNEUUohDXTdRNMdXMcCUZIXoAkJSPKsAlUVcYhpGBh6gVYoSqFRq3uo4YBIJDTrLcoko1lvkCYZw9EA03HJlULXNDQJmiaQUpAkOWkeY+oWruty1TXXsdLeJC9gx44dLC6epigSpqdntq1TxtaigmG6FHmM47iUaUqmcmzPYBRJSqUxNT2PJiSmFJhmUKWmpxUrPMkyHL9OICKyeInHHhJMTNep2TW6wSI//bOvZ6U75M3v/hU++MEP8sB9d/Pwww9TouG4PqV0iMOQLEswjRq2o6NpOtKoPPclGkUKupBIFHmaogFe3UImJmQFQVqgZEmh5XiWRWm5laMnEfhuhsgKYmmjNAPNUAS9iHZ3nV6cs/LkKa656QW0lEQPQ3ZdvIOot0rU22B1oUuQZczsmGDkWXz2S5/loj1HMGo1mnUf0nl2H2jyxEMSZEocCXQzokgErfokMzv3srT4KGQRhw7NEecJjz/zJPNze/Adn69+9evM75pmR+JSH5uiMb6bzuYIU2n0YsnnPvUX5HEbZI0dew7RHXQ43u8wu/MwjbFL2Nzo8r63/h+0jhzjwPQuDl93DZ//rx8G32T+wFU0mw2SdEgYKvxGHU1r0HRtBqPTHDm0k2eeepx77rx1+7ITWVXXsijh+hdcwZve+LM889TDtEc19u7fhWtqdDUD09a55Z/+G088eYIzqxkf/egfMzU+wSBSSBmz0Rtw0fwRHnviaVx/hk997Z/55Ve/nse9lCyOaI3XGUmJ51qM4hDPq1EmGZ3NAbZn41o+w2EfTTOI4gzP0hCeRLNqpP0AW6+hspTPf/lB+r1N9u3ZQ1kqYjKUTDGFzmgUoMnqei5KxWang++5GKYgKAaV9VevAG5xnKJRbjtbvn/bd5idO4ZfM9BNieOaZHk1J1N5juM4jAuNKAqQRkqaKg4cvgzLtJlsNHnq8YdI05jx8UkEGnE+QDM1gv4AiaDUBKbuoeklhm6RZRlJkrO5uUnNd9EtjUJF1OoupVDkKmFqevInlsvnRNEuy5I4rmLodV2vgEdFgWVbjEYBpmlWk9ktBusFu06WZdvFO8/z7S1EpRR5nm8jWPP8R7zrOI6RErKsSgNP05QwSjAde/s5UlbcZH2L+2zbNpZlVTjMrb9jmua2BFLdcNjSoW063U1sx0UKuRXSUA0OkyTBMQ00ESNQpFHMeGuSMEkYm6ix2elwww3P5+6Hf8hYa4KNjQ3KQrFn90583+LkyZMEgbFlgTIJRyMKqzp+nT59EqGZDEcZnY3NqhPXIMkKTNvF9X3KsvpcPM/j1MlniPSKslfiYJaCqdY00bDHxNgYG90OoZI0JqeJgpDRaESrWaNWq9Hp9am5HnE+ThDFjMKUw5ddydrqDNIZY2X5HC++8SaefuJx9u2YYuHsOealhW35ZErDckqIdTy/ztraBlluEiUFc7v3Mwj6jPkehmbgu5N0NxMsduI4h9jIj2OFI1qWTy/vs54NOb+2giZ1hipnEpeL/efRG3U5E54kLxVJ5vAUiuefCDm9scBqHNLZSHDGQdVszn7jUQbEeC0fzzNpYhBEIdL02XdskjjOeOkrriUeRvh2DdOv8ZZfnCeOAlotl0//zVdAhDz5zCO05vYRjB7HcSU7du3ijrtu5+ZXvBy/Nsmf/vn/IIhCbv32rdz40gFvfvN/wJA+47sm+fu//yTf+eaX0GQM2RBdt1k7/xT12YPM79iNZdd54K4HIC1wxqcR4YBREfPA977D4Re/jKDdpigVtuOjmwZR2mGzI5EiR9QGvOhFB3jwwe9y/x13V0d1Kkkyx0F3xviND3+Ml9x4A1/416+i8pCTJ0/THnY4euxy7rzj6+SJwHZdjl18ECEmKJXFoee9gLh3njDKmGhZ9IMlxgyBWZ/lm/90K+95zZso8gIFdFDVsLtRY2Z2iseePUnDqdH0a8R5Slpm2J5PFieMz0zRWWujaTqd3gIzc3sJYnjf236f++/5PlccOcaw1yVJIwoqH3We5zi2RZ6n6DrkabWtqkvQEJiWRZrmSFmRJEGRJBG+77O6tsCd9zzAh3/7L7nz7m8yO7UL1ynRTANDN+n3u7iuT7/Xo9ZoEMYRUuqIXLG+toRWZMzOzrKysoTcYu83Gg0GgwFN3yfLsmptXsvQhCQKe5Ql+K6D3/BA5HieTn+4iV3kSNNkfucE8CMw3f/+eE4U7R9/XCiweZ4TBHlVlONiu2MuioIkqbaFLiBaL3TOwDZDuwI4VbqQZVlbwb4K+8d+fqFLl1qlV2dZTpZlKKriZtv29hr8hde8UHx1vZJMxsfHKUsNVZQUVP/e2voqUlbyjKGbKCrveRLE5FmCoUnCcITt+diex5n2BlYe4jYaSI3qqBUFSATtdpu5uTlsTeF5Hr1eD8euUZbFtsZuWSYL588zOTNPFKTMzs7S6bbpdDrs23vRFikuYDgcsGPHDoIgYGp6luGgR5akQITUbRbPnebAvkP0+30mJibY2OwSBBFJFFWoyq11Xtu2q5NJoTM+Po5C4NTqtJSF6dQJoxTHs1BFThJGqLwg1wW5go2NDoahoZsWbMH7NzaHGIZFnIbU601kCYZmIEqbM2fPc+2Nr8STDkcvfwHtaI31oEfT1bn+isuY2r2DZ06eojU1w66LDnHyySX2WRbGIw9QkiHrY+zPY+xL9/LGA7tYuuMRzq4OmdjnML5jN4bVZHpyP543iRApw25AvdVCKzKCaIgqNQxNJ0VQkrK+nOK4EXXHYLO9iuPohJGilAmHDx3lnuP/xnjT5amnnyVJU1oTE5w5vYJpOjiez8R0i+/f9g0oM2ZmDvDUE0/zxKMPAV2KosDQc7I8BgqitRXO9waMze3lqhuupb25weLqOunKCpubZ5keaxLSwPd91pdWWVvqYjoaWRmTxAkH9h9kYrzkvrtu56EH7saSJmmhsHSNtChA1rjuptfx+c99l/seWmDv3l088fgjWLpA5Q5rq+e2WPOCeBRhmCae4zE2cYSab5LFJQ3TIhmFzM63KMKCftzh7DOPo1km7/7gr/M7H/owfnOMA3NzPLhxnjndYLLWII5SoiQBQ9IbDGh4PmEYkuuKiekpNE2wsZ4QpXD2fJellZPMTM8RByMG/S71pl9xgUYDLMui3+/SajXxfR8hS8bGGkRBgGVZdDe71Ot1nK0YwFE0xLJMHMskK2x+4zd/k5t/+ud55LG72LFzjvbaeYq0kjgMs+qMXdshjeNq8UYpDE1jYrxFWSjCMKpcYrJau8+SHF0a9Ho9NCGpu3510i4KXLfCODcaNdyayUZ7iSwdcs31V4AsWd9cQ4mCKIp+Yo18ThTtsiy3kmSM7c7YMDSEAqUq/VNKuT2ANAxjWwopimK7gF6AWOm6XhXfLQRrBZaq1o0Nw8CyzEoTz3NKqufolklRVMVV6nK7IBZFsc3jNrZklOFwiO/7OI7DYDDANO3tDnw4HOLYLlFUFasLJwSr6RHHCYYArVSMen3qjXGE1MlLqDWalGVJo+Zz4/XX89Ajj+I5LkjJ2TML7Nw1h5SC2dkZut0elXlfolQVEuF5Dmkc0WhUM4G5uRmkVrC4tILr+1gKNF2nUCWGadEfDpicmiOLRoyimF6vx/zMNGkWIFCsLS2itnjjczNTqAIyVbLW7jJW84njsJJPDEEcKzY3emSZwa3f+i6H9k1hiJAsjQmHVQCtYzo4bhPfr29JWCWaYWELA32YosqSOAlxModer8fYuE0qNH749LOkZY3HFtZ58NwqRw4e5YVXvYqyZXN6eYF7njxNUuos3nOaAwclV157BZ1Rn9q+a5FSwy4l11y0i9NrC3SfzHnRy95OfVedE0+e5p0f+AC/8ZGP8v995l9pHbiUl1z7PE4++Syths8ojhB6QbffY+HcAnv3jtFsNkHtYhicYfH0d2n481z5vIQ773yMH95/CxOzBxkMSq695nK6m0tce91N3PH9exgOM4IwZn1zgyTqY5vw4F23k8Tfrb4bRoqmSdIsASS2bZIXJUUxJCsyNjuLnF85h5Q6u/fNM350DoTF4uIil83uoB8F+AePsHvXQe5/6IekwSqXXr4LUYTs3jnGP376nq3OOkUgQKujcsH0gZdwtm1z+KZ3MDUxhV5vcO3US/mrj7wZQcSBo/v5mVe+nm984yt4jkuaZ+w7fIQ3/fzPs7Z8mjNLKUunn+DEyjk2NmOaTp1guEIaCHTH4L5v38bP33Uvj518lqgz4JO3fJkbX/yzODt8NtIIIUoMTZAVBVkSYdsmltBYXTyPZU5RH9vBZ754C+urQ3bs2kev3WVz4SyTE2PE2RBN15icGqPb7eLXbDY31nFdl/bqCivLy+zcuROlYO/e/ayuLqNUjqZLmnUX0zDodzZpTLR44P77+f0/+mvuvv8BsmFIre4xCmM0KrdVs9kgywr6wwGaZmK7LmkYUBQZicpxPJvp6SniIGJmYpxnHj+OZZh4Nb/CzWY5JQXuVgxiRo7vmrQ31ilUiu0a1f8PRVrkuK6LkMZPrJfPiaItpMTYWhe9wL/WdR3DlAhRoFRVoF3XrRI9VOV5FkJUDO6ySkupkmmq5+q6vq2Pm6ZJHCc4jrmNavVdb0sqkWiatnUjKLa79guvcUFHtyzrf7lpwI/Sa4QQ1XJMFOF5HirPsU2LTGToUlaEMqpTgCYkpl4lk+Rb70GJLb08rXgOjeYUB/cf4LY77mVmbpZub7Dl7zS35Y0s3fKfI8mLdEufN9CEoBeMOHFiA6/uYNs2umZSqOoU4TiVU6TauiywXI9RFJPnOf3eJmW/jcBkNAoZG59CCEUaJ9QadbQtlSnNsoovXuZouo9lCTTNwHQ8NtprXHZ4hiKLKbKYLK9ulkma0d7YpFGrE4QjCgG66eA4HoPBgDCI2XPwMHle4tUs0jQmzobc8t1/58yp81xy9Bpe//r3srTe5VTW5tkHz9IdDiilhZAmv/TWt3L23GmeffYhhr2Ag/NHKU2TQdnh7OIKnmtiWj4LK6ss3XUX17zkau791hkWlha57nlH8byjfOFzn2ZudiftXogsJYtrS+zetZ+kyBDOPMPM5tyJDklURZjlKmesOYkQOclwk8318zh2nc3NEEM6uFaD5eUHSBJBp98hiUIs1yUJNympjtlZoZAo0gxs3cWv2ZTYCKlTFGCYNppZXRdJGnH66WdYqjWp6YJOe4Bu+GRBQZx0WV1a5dCRYzz7bEjQXePgod3cc9c3AY0SiRI5IImTFKRPrTnNnkNX4XuTpGHJmfNPsXfvXq7+2Zv51fe8g3/7h38kWHkMTWjEyYhSaTz8wK1kUcxwtMHV1+/ggXufRoqcfv9MBXUTYOpQ5nC+OINSMD47z7GbX86v3vx6+p/7W6565SsYs2uMOzaLwSZTXouQEsOw6C632bNjHlNqPHZ8Dc9qUPdzlJAUpULqOlmRMxqNMG2T4WiAoelYholeb+B5Hp1+j4nJcQqV49g+GxsbtFotHMciTiL6vQ2C0QBTatWA0Wtx/NmTHLvkYr7ypS/SGndIkgjX9SlUZfMN46SaDSU5iYrIix9JrlFaoRGKPCNLU3zLw3NtBkEAssS2LHRTp9frbeV7uvT7fQwpsGwHy5KYpkGuCpxajTAMcZzn+HINlNtF0jCMrWGfThzl2JaGplUd9IWsRiHEtu6tlEIzdMq03Naw0zyjyHLKstqS9Os1TNtEbNH+bNtGaJJSgOHYGFkVzitlNYBEsf0avl8nzzPKskDXJUpBnis0zdgC5pQIUWLZJsNhQK/XQ2jatmMlyxW5yjGkheWUxFGObtr0e6vsLg5QaiaeYZFkOVmRoukKXZeMT7SwbZMsyxgOA+6//xFuvPFannjiCer15rYslGXVRLrme8RpwXDYx7VtgrggGIVE4QKXXfo82us9arUGo9GQoii2XDMDhoOC2ZkpRNGivbKCZdn4vs/E+Bjd3qgammQp3X6H1sQcmm5QJBFSgzTKkFLH8Y3qfWYhX//qV7DlgKuu2IMuFXkSM+yMMH2fUXuTVquFMAwmmg2Gg5AkVRw9epSNdo+gW+AYkjCIcaTBY6ce5mznaRq7Jjk/eIp3/c7rsRybcLjO7kNHEEKQxQqhdL75b3+NUXq87OU30O5uoC5er7qs/YcZP+Rx+uQpxhpNet0pnnlmlROr3+LVV7S46OIx/v4LX8EYnIZ6A9mYZW1jldXFHhPWHCdOKW6//TTrC/fx6re8BytxEcaAtdVHsAU0apJd8+MsLA449cSD3HjtzRx/6hFe89obefqhe1ld7TAaxYTDBNv1sCwDR9pkRUaUj0AoNMOhKFLiXJD1M3I1RJMGStloWoTjxERRhBCC1sQcZeaAlAg9oN9u02o1GJucJRUZZxZPYdk6NV/gWT1OnXgUsKokJjFEUuDU9nDDtS/ih+cCzi+dwcslhu6RqT5PPXs/QoNRXrK4uMAjd91OUWYYEjKzgFRy4vhdlCrny//0GIbpkuc5111zHcePH+eyq3bxg+88TlEqiiCgVBCfOcXiqVPsuepybvnqN3nzm36ekQZLaxv4YxYLnRUcRxCsBBzZtY9RXvL1W57mox/8z3zoE39EP+qQK0WhRnhejcmJcVxPbIdpx2mGVhYsdTY4OjOF3hui2ca2lHqBFNgfDSlLhV9roEmwdIERJng1nb/99Kd40+veTBCNMIY5ZaowXEkQhXieQ1kW5IlGrlJ0qwrI1lBEuoAsBZVDVtBpb+A6DmUhaPl1MhVTKEWZFFhI9BKMskQUBfO7p+j01hifbGHYgjyKCAKo1ZpEYfoTq+VzomgLIcnzipV9oVhCNXDMs6qzdhxnWzr58fQYXa/sf65lk4QRupTkaYalgFRXHwAAIABJREFUG0RbkkYaJ0gESZziuTVKJUiSDM+rVRtYUkMKgzzLcWwDSralkApYU0FrdClRJTimRTgcMTk5ziAYVdmLQgMUlmNvZwhqhkZZqkqeKSUDSoRjUowiVB6QGzmeM4FGiWsbDIKq+4qTEZ7nkZcpQTDCtOR2gZ6dnaffH1QSQnOSLAuJoorkF8YJnm9g2y6OP4GmCVbX2qyvrtPr/0jSubAZKoWOKmJWl89Rr9WwbI8sS1hcXNxaMvBwvBqaaZMkFcfFsS3MeoUDHYzW6XU20XRBXghKJRHopJmG1Jt0N1YxPAvP8/B9n37coSgFmm6ysNBmz579jMKYohRYrgOWQNqSXBUEUch9d9/D6dOn2L8/4eKLD/OR3/8fIB1+9ZffybF5l12TNZ544G7sWos/+OTvMr17P29927tptzNOnpNMTUzxz//wuxx53k9xz13fYWmhTScM+cMPvIHG2BG+8iffRWOWxo45Rutt0mID+yv/hDCbRIM+b3nvf+L82ZO87C03cO21N/H//t2/s8OYY+nseU4+9QhaFrN75wS9UYwiYzDsMLF7Jw898yDHzy3z5KklomiTOA5wXYNcxZTKIQiroA3XcashepxSKcclqswRWiXJaSSoQhEmAqwmhbJJywyljciiFE2WGKQU6YhO/zz1sX1ccmyWpx97iunpJg/edz9CFqBSKjJGhTt2/HlyfQy/LsmCgnLYpdSGjNkBo3zEO2+4kpn2eR74wZeRZYKtu5R5QlN59EgpSREKDFzSvMDW62y2N+h2u1x79Tv53nd+WNlSEAihtmTLkrOPPcZn/u+/Z3WwRsyQ6fGDDMKYKXsaaaTUWhZGrnORnnPjb32CzeUB3c02Ya9LqSI0zaTmWYgSPK9GEAzJ0hQNi7X1JVy3AUCuCsbHpwjDEWUp2NzoUlCQ5ZVM4Vg2lqFXqYG6Io0iOounWV4+y86ds6z3NxmfmyAYhkjpQ1Gn7pssdZeZ3jFLGAeocoguFXoc4zQ8Ov0O1hZ0qmnqkCtUXuLaJlmq0CSoLMPSDLS0wNFMwkDg+TN4/hiDqINhjCO0gKRIiYv4J9bL50bRBkxDRyJAlpRAklRHfkOXCKExGPTwPOfHtGuJUhV71tQkhSq27Xx5moJuoLKcPEkRWyvsQjdIi+r5qpSEcZW2LoWJlNVHoWmVNp1lxbZerlRaXUxKEAQRWVb9fDAYUKgMqWmAIE4T0jQhKzJylSNLWaWXaBq2YbKSdsGy0VPFaLjGMFjHMmfQNIM8DiiLhCjOyMuQtc0Nbrrphdz6rR/geBbhMGFjY5Pdu3ezvrbJjvld1Yqu7bK+vo7vu1up8kNiDYSohpZzc3PMTc+wsdFGaj5RWBBEI5rNOlEckkYDyjyit5lguZPopoFtVfFuQVqClEzN7UaUsHjuLCPDojk9hWnaOI06jizRpCIjI0ojWjPj3HHXD/ja17/MTc+/mt/+tfcyPTNJd22NWsPn+LMnmZqZY3xiFytr1Y0kLUC3bCzfBr1ixuzbNccjj9+PY+skSUiadHj/+97Lnt2XMzu5j7PPnmPCnOPI/nEsr8EPbvsKfms3SiboumS6NYtWVCe0iTGbpi1AmLzj/b8O1Dl28DB3rT+A34JofYNcJdTG6sR9xVxjDOXUWDj+EP/hV9/HmVNr/NnvfoSrb3wZU02X6V2X8KIb34MtEmQeYtkuf/DxT5D3zjE+77Pn8JX02h06o4A8trFKwc6pKdZ7g2phq1l915IoxZAakCNMQZFVyS9FqVMCVZ4LlBmUuUDTIVzroOwUy5/AECab64sk+j5UHrC+cj/L52s03DpPP36G888+VS0MiQzdMChSgcJl9sDFrIxiNNMjiTeZn7oIXVeMuZIjF1/BZVdN87Xv/QuIAYZmUhQJqSyI1QjGNLJC4ed1kiznkoMHmZye4Ls/uJ23vf3n+MQf/jkIrYr1kWCY1tYQX3Lj82/ija96Mf/lzz/Ju97+Ou5Y2mTX/DirwQn00GLcmueRJ4f8zKt/mZ++tsmjuPTaa8zXxznjGKwNB5R5SX8zRrcFumZSZjqOIZg9eDFrnXWKvES3fIajmLKs5mHTs1MMh0MajXGQJVlagKaTFCmO62M7BXVX4/u330Kr1aIzGpBkbYSeko4klJJuJ2Zq1uPpp39AvWmglzWyfBzdGGNtcYTnzSKGKXYiUJpNVETkWkaZ5RimhWOYyLqF7tgMh5tEKmI26dLudJDaDLpr4ToNtHLr+yCe6z5tSnTdQJVUa9nlBd6uQX+zQ6M1hthieZSlwDAqi10YVknY9Xq9ivpSqsqXs2yKosA0K6eDlHLb9ZEkAXmu4boucRzTaEyT53k1uc6zCqmYptsAdseRRNGwkiN0Hc20kDoYps78znmWlxe3bIf5tjZ+QW+/YAksyxI0QOREwyqpOhwFpJGiNtakKCWa4VHGBfWaThjFaBh4tRqvftVLueuuexC+4NkTZ6ovHJLl5VVarYmqiygqb7rvu6ydPE9RK9GMnPHxBkvLZzh56ilm5nYwGgzQ9CrKq1A5hikI4wypJAhFPFinUatjORbdbpfm+AydTpfGWEgUh4yPTdBsNivG9TCk1RxHFgWGVkV16VaNIAyZaNTwjJxer8el19zAXN3kphteQF6WTE7PkiYFi73THLzoGGEcc/7sOVzXRcU2YlbSnGuw0V+h1rLBKjF8g24QcP2NN3Hm3AZmQzIYxbQmpxBRSjDK2L17L8euvo5/+s6ddDZWME3JuTPPgPJZXT3L7XfcSb+bseeSi/jC/3MbT594FF2PyKOCkgZ6mRF3R6CaGL7OyaceJbQTvv/t2/nObXfzshffjGcaTFktjKDDrV+7lZqbkIRd5mb2ooRFWUpOPnman33VK/n4//k+ZmZ2sBqfoe41ObvURZqCJI9QacVpsW27ukl6LkWeorkeSVyQ5vrWVVHJcqpMkCToEvx6ySCOSYc9krQAwyMZjqphV/Y4wXCW177jXXz+H/4YqSXIUiNXJXlaAhaN8f2kcY4sM5IiQBqS27/2acKNdeauupTv/+A2vvjPTfaM1Zmev4H1xWcxyBgzSoZpyqt/4de43pvgX7/wL5hS0E43uOMHt/NHf/rb/Lc/+0sc3SRWMUJUc6Fki/+xf99FBEnKviNH+N0P/R7v/aU3oLKUJzttuiObi6Z38eVv3MXHX/cilLef9to4V11xMaPuCK2s0axPMz0zRA43MKRNXlaSTmSFiFKie5LT9x4nmpRMzU2R5xlolVyqckHN96tPNM/RtSpfVRUJumHh2BZhlhBHKQf2H6K/uYpVn6HdbrP4zBMsPnuO2X3HWFo8w9jYFGVeIgxBanTphylxGBFFJg1XYJoSVytR8QBfOOiahSgyyHJ0XSBjhZUFTE60mLQPQOZy9okFrnzhJawvLlOrV1ZiS9N+YrV8ThTt8gLdL822U2Yu3GdqNQ+KarB4Yb39wmKMJnUEkmazSZ7EhMPRVsEVSNsgjeNtW2CaZ+R5sTVErG4AcZwSRdH/MtSsnCvGttc7y6qBX1mWxFlCEFbYxSLIsRzzx+yAP/JkJ0mC7/tVoPBW8RaqxJDV+3IMnXYYbQGbzCpOzdSI4xjHd+j2EnS9knVcy8GQglGWYVqShYUFduzYRRzHeJ5He30TXTcxdQvP9TDMKjU+ikaMwmGVDG9bFGlGUaTUmw6qlERhTKPpMzExwbC/Uc0U4oxOd2PrxpNiWRYTYwZRMML3fVaWlsmynLHpaeq+SzgMMU2dvCy3bIURtmHg+z6ybrC4dJ4rLz/K/h0znDp5mp2zc5haiqHbIDVcr87E5AydXpesKPC8Go7jUArF4uIizWaTMIwRmk5jbIqNTpfp6co3fj5IueuBRzi6w6IoBEurKxyOMwQmopAoFaAb1bzBcDROL5xi0E8oW9CY9hkGARgOplmD0sB166yubqCI6HcWECgmJxx0mXLD8w7y1c/9Of3ReQzXIosiyBUCgSxdFs7l1WCWlCcfuhvXsNCNkuuuvYRu+yS+61VNhG0xikLW11dQWUwcx0RRiOt6gMR3DDRN4FmVTpylFT5VlDp5EQGKzbALuaQxNs6B667koTseIqdLWa5z4/Nfy7Er97CxsUZZJpQlyFJVkmEpkbKG542jlElJiWUKgnjAoSuvYrOzyqGLLmbMdzgv67Q1nUtedZDLd+1GZhE6Qy659HLOt5/ij9/9Af7sfR+i9Ave9Yn3UAr46te+ycZ6iKe5iALkFnNHCMHc3DzXXHMNT554Bk3YXH/N1dz9YMS7f+u3+KtPfIKhXqfbh4+8/l3MHD1K+/QzPHzvEnsHCeHTKxRmg8svvgbHakISkYQdSk0nzTOE0MnSlMXFRV5847VYRp0fPrVIvVkn27oO0zQlHIW4rr21FV1de60xHykUaZrieR5xNMC2DBr1Se576hRSs3jr+z+GY/vU7DqOa/Gpv/lrPMclFwG6W6CT8tIbXswD9z1EmgwplKLueHi2h4g0iNka2JfIrMRxTVQSsHxmmdr+KRIrIyth5AtKrUm4ZQn8cQn4f388R4p2SRZXLN0LjgqEIEkS+r1ehWosKnqfrv3/zL1ngGRlnfb9u0+sU7k6T/f0TE8eJjGkITpERRZERVxgDcjirpgDhlXXNWFcM6uAqBhQggQVEBQQB0kDDJOY2BM7x8pVJ5/7/XBqGt993ed9nueT9am7ukJX1an/ue///7p+l0qz4SKERFVjo0mtVkMTsTojm83SbDoth6Myt/JVWgqVvx5kHoNJ+X6I4zQpFAotaZ+JkdAxTRMhArxA0mhNdFNpC88NWrxvH5Q4/NeyLJLJOJXGNGMGStOJtZZhFJHJZ5ivJbGdKqFi4tsKYRhgpC0S7Tk0RSOTz+BH8fuhKgphIKl7ZS44/yKef+lZJqdKVCoNNE1hXk8/dtNl6fJl7Nq5Cxm1MzQ0hOfEUkNfQiqTZuTIQVRV44yN5zC4bz8KIURxwk+z3iCXb4st/gImxoaJAtE6YCSzM1P09vVz8OgQPd29WIlEK6w3dq8l0insRo1MJoXTtElaKTTFYXp6FishyOfb0MIGk8UK6WwuNjHpPp4PqWSep555mgULBmjvnMfY2BjVapmklSLd3cO+QyNsOOs8ntz8HJVijWpHg1Ktwb994lquufJq+he0E6o6dTtC+gFd3RHdhRz9fb2MDh5Bo4Eu6ghNkE7kmZmaYO/gPrr6F4KioMsqaB6JvM30cJ1q06C9t5/ipEFxpoJQmnRaOi8+/UeyKYNKfZqzX72E8y9Yyst7n+U9738bCQs+dO3P2PyX4Th6LNJJqPDUn+8lmWryh0d/i2WZhDIg0kKareOmZ94AqFCvlPE9G6dRRAC23cDQdVTHpW1eiumyg6pmiHzAnqaru4f3vfvTbH1pJ4NHS+zctpXfbnqMmZkiZ5ywiheefoSf33YrTz29GUUKErrA9wW+EiICgyXLTieZS1GrGwQiRE+GWFoy/rwUkz/fcw+rTj2bJKsxUhmwshytV5iaPMShJ39H1re5aMVKfvDxG3juyT/w+J7HyCVzvPs9V3LDN28haSmEzYhIU5GBiAMjhMLatScxeOAoyUQbpq6g0aAvZfCLW37ET77+Ldad/3Z2/PlPnHHeBRzYdh+W6pPSNCrTJex0D6+95CIO7DtCEPrQ9FFkEoGP06gg9BxJU6VSCvjjsz/nyEzEmWddiqaoaFYKzwuwzASqAhAS+Q5WUkfTIfRtiOJWp+84mIqKrsL6E49j9UkbuenmWxg6MszwkSFGirMkUbniH9/I5NA40xKSKYPK0ChVp40zz7qSbdu2cXjHZsamI+b19CLCOmkrgy1tVF+hsy2LYwhkfh6G67Dv8WHWnHwC+VQ3qZpADRI0pieJfI+eeR3/Y738uyjaiqKQzudxfQ+rhU2VUYCmqFiGia7qKFGEZqjIiBjCoilIAgLfQ4gkYRj9ld5bRQiJ29JxHwsDdv1YpnNsmnwsEUNRFBKJJEBrde1DJFrGGoGqMidDdByvlRpjoarKnLLk2IBUtLgax4T0nuOClFTLZUoNiHwPLWFiOwGO4+JHMdmw3qjHri1VI2FmUYROvTlBGAj8dJH+/oVUqjZBEFCtlbCsJkNHp+PXIiPK5TKZTIZKuUwYxrLARqVMT08vhmHw7DN/IZ3KIlHwI4nwfcyEgevGenbP88nkCwSuj+/F3A67UaNSLqIbGjMzU+SzBeq1CtK2ybe1A2BYCQIZkstnqVdqmCmDIPLQdRVkQLlaJ3Q9MpqOlUoQ+BGGIfC9kEWLljAzU2T+ggHq9TpmyqTp2UwVZ9mzdy9nvuZsVEXHTKmUa2WuvPxKDu3dy9nnn8/g3q14nkd7+zyGDx/h0OABPvqxD5JYup6QJpXyGM3GLN0dnbS3t1PIt3PqhjOYmJjA1FWmK7P0zG+jULAYP3oUpEOjaqApHUhD4jYD5vUvJDFT5vCh3WQKNZ56Yj+3/fpCNm2a5sEHH+Cb/z6ErsX+wiAIWLS0m/HJXRhGDs8VyDDE10OiUEEzDBTVxAvB9Vx830fVLExhEgYKrmMDAX4Aim4zMjIbD6+wkUiuvOo6zth4PD/6wbeYGJ/mkje8hRNPfRVf+/LnWLVqFY3iAR6+7362bN2G6zWQQmL7EkMBggyCXiJFp+QBmoy51oGBKjUkBpoWtwymGrPk2iqUZsfpGeihnjFYdvzJzMzuZPrl7fxk98/4xu5fgBKxqNDGGy49h3t++xCgoAiTUAECiSQOgFi8dCWqniRXUAgij8CD4oxLOttPOHgEBdjx+M+RwuTZx+9CxSMkoi4a0JzipLWXsPr4pQxNNTmybSsrB/K4zRqIkISZQfMjPFdydP9uokBQnjhKR3s3gR/iRW68K1cChKLiOR6GGaddqQokNYtaVCL0m+hqmmxO57FNj3Lu6RtYv3EpA8s7uf4z/0Kl2OCjn/4Y/mSVzsU51Az4U0P0LVmJ21ng5R0vsPnZP/CBd7+XQ6ct5YXndzA1tof5bRqWFqCGBtLymCqW6GzvIKsrNIMSHX0epj5MNqdy5MhRBC7CTFCvVgjKI/9jvfy7KNoAbqMRw84jBV1RCRSJ63r4nkdHOoUb2qi+iqqqNJseuVyGKAwwjCQikmi6SrplGz02QAz8CFBwXadldAkxTTGXyA5xX1zTjNhpaJnx8FPX51bLpmkBEMoQ1/cIwhDX91FdBxOzZVWXHCN7BYGP68bhC7ZtQ6un7QURmpXCqRVpt5KAGpMJdZ2UlUHgIAINJZC4bgWERiaZjwet0sQ06jh2mb75PezfN0oqZWLoklB6qLqGaeo0Gw2C1oGaMBXSqXYmJoZAqGQyWcrFSRYuWYEaghspuH4EkU/CsAhVg4bjtjIPVRQLyqUZarUyXb19zEzNkkooVGs22fYCYeTheg1CGRG5IZHn09Hejus6hEGdarVJwlCwkjkwfBrFCqrw8ewq+bxGoWDRaNgU2jt4/sUXWbRoACdokOtq41f3/IqnX3iB0y64hES6l+rMAd5w+cXc/PWv0N0xHz3fzdjYBG4d/OO66F/Yh1MXTO3YywmntiOQlCpjNJtlli5bweH9h0hm8kQCiuMzzOtJMnKohIxyVMtNNC0kxKBpVxESIruBbmi8vGsfXlWSTi6gTInVJ+VYnP0eAwOdjI1P097dhm0L5uVXYyomIohIUCF0a6QSgkhmcL24tRdKJc4b9H0ssx1FcWg2S0gpSeXyJJIpms0mvlPinddexYeu/wiPvrCDX97xe1RlgI0XnseH338Nl158GqXyc9z24x8io4iTTzqZzY/uY2z/Qh5+5AGQsa9ARBoRPm5kYqQ66OzupomCIi1UtQRRSOClkKqO9APMzk4EgvrYKF2pPta0ZXj+6UdZtf5kdh4e4rSN5xKuW0/xT0t4y3uv4IpPXMUjDz/Kqy4+n6npOqBgNwA9DvAFePOVVzNdrDNTdQhCn4QusIMmjjDpXrqW8IU/gJZDRDaFgqRUtAmUHEQCIcpI0aQeeqhqN//8/rdwyzerVIsHiBwXTQXPD1B0HSE0CGr4muBDX7iTVFs3peI0UeDEJjopsZ0aRlKnXG+CiEhoKsVGmVw6jy1dUu2CpG6xb/sMd/zkFu78xY0IGXL5mfejBBFBrL3hqx9+HBma5PJZMLupNKZBNlm0ZgU7h/7Cy4cO8/Xv/4R7br+dPU/fx8TsBJVyg7S0aCYCml6dDSecQk/nMox1PZx00kU0PMlxYS+NWpXa0CiR4zBx4BDw1r9ZK/8uirYAhKqBCJGKoOo0UVp29o5cHqdhEwYRNVmJbapqhKoLZDNugcSyPDlnvDnWW1bUGNRkWAlUQ2/1xNVWmKjX0oR7c8Ycx3FalvfmXPSYlCJelbRgUnGwgiSVSsVOycCn2WygaX5L661QKLThus4cqOnYY+mJFLbnEyk6UejQrJcw052YyRRuaRgZRkQiTvuwkiki6eG6HooaYSXzJNKCMFAptOk4tk+hkKfpONhOQEdHF5VKBVFSUBUV0zSZnJwmYaXI5XJMTkwjhMLQkaPkO7pAMRFCxQ0iQt9HqPFsQEXiO/F2slartXAAIaoqSKZSeL4fG4AKbdiNOqlcFt+X6JpBqVJDUySGkaBcnGX73l0I4aAgWLts2RybpWnb9PenQTE4tkodHx9nzeoVdHS28/RzT2Gm8vT1DhAEKoams2/3HjaccjKrlq7htnseZGBBPxtPW0dxZjeK79Odm8/rLnk1xqIFzJvXgR+EhNJhYmKKZmhTqzbYsn0LA8tXxrMGoFwuoWoQBKCZKhKD0HPi4zAQ2HWfXHoBqshSrb/I88/sRwiDsZESfqDhNtMsX3IijieZnd6CooaYShbXDomiFEIouHYYA8QiiYwUVC2LJyN0zSCf7kQICCMX2/Pp7iggog6+9/3vcmDwKB9+//s4Y+PreeLJP/Pe697NZVddwx9/cxOzUzMkEiau02DntheRkeCEE04EGe8aIxkBKgoCRfXo65mHTOdxwyyOkJjSxjQShA0PEYWYviCoVlGkjW64OEaJv2x7Fm/KJzz+dIxUhj8+f5gNxx9PtX2Gt/77x7nw9LPQEy6mHj9PRLwICoMA0Fi1aj21hk2xPItppQndCFdLESgC1JDBkT10d59O2Z3Aq8zgVR0MQxBIB10NEZEgUPIUSzNk+yTzenV0y8PM5/B1BSUMMa0QNUpSDWz615zJc9trDO7bQm97P6qMaNhxqzKW9YIMI0zNQNMMTEOl4du4ooldLXNgYopqzaHhOqCHJIQA38a0CjhRhTBlkjKz2KUaUTIiEAkWdizAnt6FF0mGtrzI4c2HEUS8a/t1hKKBW6wR5vs5fv0JWPks7d09ZHJtKIrC5MQQE7dP8sQtV6E1AiZKhwkdj9Cut6ri37kjsr2niw987v0IRaFRr5PP5zFlqxkfSbxIohsJvEjh6KHDbH7mWXa89GIsNQuaWMk0iqrg2yG27SElWJaJZsZJy7oUcYp2C0xlmmZLhaIjlBDTSNBsOqTTaWy7Ea80VTE3nBQoEKkgBIau47sBipD4gT+3EpdSEEYuYRRhOwFRpKCGYCaT2HYT1dBJhA6zxYCFx3WgiUHUoIhpLCKR62T26EsktCTJzhxK6ShaokxQX0IqXeWe3z2HVHze+a8f4kc//gYLuleQTVWZmJgAoZHNtFOcLSGJkFFEAJRqTQwrjamlKM40MYxY824lNOx6iVyuk4bTJJdvp+K6EEVMjI6gIujo6MB2XAwzSRBCQjXp7+1nYmaWTCaDb/u4toOVTKFGgigSBEJQaO9E0xRcu0GbopE8IY/0SkjpohAgtRCfAEUzcQKJjHxyuQLLlh6Hrqt4oUahowPwEYHDw/ffSbM8Rb1SxXcjxqemmK6+SChjI0NpepasngAU8B3K4wF6skZCy+B6Ab29K1i+YjF/evoJAl/gND3GJ4rkC51Aimw2j+OVQKnT3ZemVIxo+iqLF6+it6eHZ3c/zVVvP5NnN20mFAonrjkbN4iPm+niJLZTZnR4D6rmkTQzeH6DsYlRgiBg1ZqF9Pf3c/bZG2hvz5Fv16hXqlQqVQ4ftKk3JfsOztJseGx98VlQKrR19bNm5VK6OlcyXZrltf/4AVasWkuxmuCaqy5BJ6BS8untPY7J6aFYoSEifAnnnncBm1/azOHBKp7XAD1gzfrT8L0eGnaTIAJdq6I1dKxMnF+ppdN4QUjZL5MIISRBs2lSrbWxZN2l1Jo1Jkam6eruYEHfYo4MT5FasZo3nPw9nvzzd/n4V27ihJPPZ+R3dyNMFSUK0HyFa69+L0emZgilQTrbjqZIUgZEzjSW4lEzbTo6ctz3+FMMvTzLpa+5lEZpFC0o0dfby/qTVvHA7x+GZJWZl+7h9s+ZrDnnXex/cT5V9yn6O9vJawa6miXVLUmIHHue/BHnnL6SBfNOpWbpCCVDodvCC2PiZxB6iGiahOIze+QAvZ3dnLJuPXdt+gvfu+MhfLWf7oLO+LbdfOuz/47mDuN6dSrFMo7IoNo2aqjghRqWSNMo+VTXtfOa677NZMVjdP9+Lnjfu3jb5SdTtEPcUKUy7VNtROSTCkEQ0dNukiqA1CMyZmzUs5R/Y3mo8tU7DvONa1+LFIfjfrxi4Pj+36yXfxdFO5lKs27dyXEvOgxImCYz1Vn0lq29UrcJIsnqletxHIfuzl52bN2GDAMkMXwpmYx70qoKhmnN9aw9zyOKFELfnhtCqv9NThOvzmlZ3GP6n+vZRFGrlRLEvWpTj+WDRWeWKEihqxrNuj23yjg2/ASlVfANFB0M2YodC0O8SAUzQeg38e0anhsRhIIwkOiaju35aIZBaSYknyszNFJBqGXuvf8F/uF1J1OtVtn0xH149Xin0Gh6KE0Xu2ZjmCq6nohXs15AMplGCANVDXHcMqmkhaYCoURVJAldi5NqErHkTIQKUsa9fMOYcH68AAAgAElEQVQw6Ovrx7ZtDh04RF//QhzPRzRtHNtD102UpCDwwrgFFMVp2cVKlSj0sVSLbE6lOFNBkQCSarVMdl4Ozw1pNm3m9fTTaNhz0Wk9fQt4YetLQIShK6xZsYTDB3cyWFVQFR1h6rhCoidMAr9OtVwkVVDwGjaFgT6WrljMVLIDoUgWLJjPnj2D9PSeQ0fXPNLpLJdc/Aa27N6HHzVAQGfHfEpVnXrZiSPstByaJjl0cBfzF/SR7+xjYNkCnnpyC6EXcvTIPtzIoL+/D0VqsX3acrEbKmPTE4RRk4HFC1m8eDFnnnU82WyWpAmOXWFmwiH0QkLXx7MrNBuSJcuWsmjxUl513mlsf+EvLFpaYMWyxVx9zQc4Olbkgcef4dd338W555/HrhefpV4tkU93oqkpopaZCQIQKprRzsazL2dw3y2gSPTEWq56+38wbTf4wX/dSEek4wQBiCaGzAAmjtskDAS5XI6ueV1MyoisaZJPptAUQdZKUfJ8ZuwyXRkTQ9WYKc7iN2ssP+5EUGBy+Jn4S6Qq+K5Pp5qjNF2mXq8TGQq1posibLxGiUJHjiCMaE+exJbNL/Ctz9zP9776Jt79rx/kxi+/HankaO86ji987z4eeFCFaop/edc/8pHPfoUV89pYMNDP0qWv54VNz3Ngz72IoJ2XD+zDAN7x7i/xhwcfZvX6lezcfZRMRuXQy7voau8hZSawnRqd7RrlygSXv+FiBpYez3hD422rLqAYdLFvaJToZYd5QsXMruKEtStxvQYP/PJW0EwiT1JUHFDrrD3z1Rzcf4SRZ55mfNMvCLUMSmBxz/dCnn9gKSvWbWDJmuMwMlmUUKU+a5NImkyPVnH9ED2XwfZqFP0JVncu4jfDKt942yVIJlFMAwVBZ6ab4Znq36yXfxdFe2x4hJu+eyNCVRiaHI0P9myKmtNEjSCrJlEsk1r5Vq65+p955PGHOXTUY0EvZFIJwsAmmUzSbMZ41yj0SaezVColBBrxbtgC259jk+itRBzdiIeGdtPDsiISlgEidjEKmKMHKjJOzNF1vaUTj8+U6XSaWr3+ymMFEikEoecSSANhx3RBV0raDJVms45bb5BNZwjDkEQuRy6bpZpM4ShVghmfoNJGIZHjN3+8B7sBUSTjQAVhsPbEk/B9CUpENp0knc1QrHhYhoGqgmkY5PN5/GIJTRF4ro2qSpKJNJ5n4/sC3UgwOzuLUFUUNUk6naLuxq2g+CT3CuUwk8nQ3pGn0aixfOkKmo5Lvdack0kmEi28bbNJOutTKLQhoxDCJpEXUC1NkDQkhmZjmBnsRpNUsoDnxfpdXTMIQx8hdHq6C/zy7h+26Io2O3dvZXK2SDZpcmj/Prrmt9G0mzSaJVYtW4jt1dCTOcCgbjeZ2bOTzCmL0BMGe/ftYfmSpcyWJ7ASOrv2bae9vZ3D+wYxtASqniSIQvxmHUXX8OsO/Ss7ObTvEBtOOR0igT8bMDGskG3rJ9MxQ2DXWLy4i8nJUWZnZ/ADl46OPCtXruSEEy/EdR2mZ8aZmJjg1h/+GNkK2AjDEEUIeru7SCWT9Pb1oRgm2zb/jif+ZPO6172eSLr86rZfUci28drXTTBb9Ti6e4qLX/8mcu0LeNWrX8fOHdswrYCTX3UGb5j3L9z69c9DHQI15Opr387g9Dg/vfk28v0ncek7ruaT//4f/PDOnxAOvcwU4OGA8JkaWYiwcmTblsY+AnwmJodjn0FbF1HoYts+aSvJvI42hBCkTItUKoXVMIl0hajehRcGvLj1eVTVIgxcULv5969+h4ODuxHqIgzdYrZqowkFFUFQDqhWbFTDoqd7Hs889CvW/vEO/MogQgSEWoVt2x/g4x97Fy/strnh4z/nsT/9hLddV6W3u4v3vWWA1evewZolJ5Oa5yKtPDf+58944Kd7uOeOm/j+PU9SbsxyUpTgpq/cyKLlgqlGkndcfx0jY4fZ8tTDLFlzEk8fGiKzfhHZrh4SWp7R4QpJEVJ3bfaOV6hl0ow0LSYnhtlw2edYMrCEhu0wfHCQbFuB49at4fnnv8iic07m+BM2ous6+fmLWb54EVKFkdZOvFkfxw0ECU1QKoGRiFDVJM2pMn3daTYuW8EbV12IYuh87KNf42c/uxGrrYbjzTLm/p2nsSdTKf7prW/DD0OeffE5FvTNZ/6SBQRBQGeuQK1Yx0wl+clPf87Q8ChLliyhrfNFTNOlVKpg6MzlN+q6OVd0DMNoydeUOWXHsQHkK5psg0h5ZfV9zLoer8pb2uuWDO+YgkRV1TkZ4bGWyzF0bNSy2vueh+b7EHj4oY+qgqNLfM3Fdd34Ps0mSAWhgu2pJFSbhJJAlRZHD++k6cBVV7wfKQN27TtMoauTvr4eBvduoae7g1q1GrMrRIgb2CQ1C89z0PRYCZC0UmSzGRQpqNWrKGqci2kYBoETF2dDp3WSSxO4AZYVxknSUazGKZfLZNJJIi9+f0ulWaIwft2VahnIzwVEqJpOw45NIPlsBjVU0DUNQ/dQRYQqJH4QEcoY/pXL5dDbDaaKkxhWAsexcV1nroX1jmveilQV9rz8Upw25Lqomsr8BfMZHh0hnzIJoiyRVAgijbrdJC1DsvkMzf2H0C2NI8NHGT58GCEEXV1ddHdXeGbvM4Sex9DICG69SKGrg+LEBHbdRVUVHLeBG/hUyzVEADuf/BPSjzhlw/Hs2PEkru3Q39/H0mWLWb58GRAxOLiXsbExhoaGsG0X1wmR/y0xKgpKJIwGlVqZfHuB+f0FdG0ef37iUQ4PHsX3QQiV3btfZnSihGItYNOmTVz0+rcwsGQVe/YfpVKvsvn53Xz9qU9w+WsvY+OGDvDb0cMyN//4dv7hg19gx55D/ORzl3Puq09nYsbEJ4FqJDESZUy1gLS6SaYKmMkUfhCQzZp09+Y5uvnZmNXRqONL8O0muhHvLkulEkIIVq9ci5rTqUY2U9MzSFKEYQM9FPjqND+9+wEOD+/i/Z/6N772g9u54o1v4/Yf/5grLruc+zb/lk999OOUSsOsXZJnz8EGI/uextYUutp7mWoWkX7IwcGXeP6pQZ7c9BxNd4Sn/zLI4lXzmaclWL5sJYXsUeavP47q0CxvO+tMVqxdRUo/zD+dqjH/uCu46qOf5qtfuB5HEUzum+ax2z+PmW9A0+HAziHeee37ePUbL6TSgCDy8RSdTE5iKIKZyYAnFiboyvfQaDhMz86iiYgV3VlWLJtP3RO84bKzaUoPNZlk1cp1nHRSG/3tETYKERGLUFBlhCm6cSMfXVHRUZAhuFFERReUEXzy+sc5/eLzqI4e5YE/P0wgfAKnQSrVRdPQqVL8m/Xy76Joe0HIbK3Jli1bMBSBFqjUd49SnprhpeExetavIplJ43khZiqDmc7QdOskVYVk0kKNvJYjMI2UgiDw5laCcbFW5yh5mmbMFW5FUahUKliJNLquowgVx3awLCsePLYKdpxLadPRWSAMIirlOlq7jpU8lv1mYJpGHEDc0kArUTzFTySTOJ6DlrTQEFTKJYT00TUFx25g2w6RSGD7M4gQMkaKLc89yWjU5D3v/QTf//ZXufs393PF5Vex+vg1lIpTmIZOFIYIJbbya7qk7tgEgRdnYAoIPQffdWg2AtLpDA2nEas5LIsw9DETagy/8m2mx8tks3k8X7YQtq84RnVdJwhDms0mE+Oj5Ap5wiBu/TSazTiT03VBMynOzpBv7yKdyVAqz9KeNckXCjQqR7AUB/QkQtORQsX1A1w/oFxt4Dpx5ubWl7cxNHIUiDMsJyaHkdLB8xxIGXS19bF5y1Z0NUMu1UMofcqNBG4joJBuI93bh6Xr9Pb10dE1yv6De7nk0tfT1pYFKZmanERT4LTTTmPr5mc557xzmRrbjx8GtGdSRISkMwaDe/fwxsuuQDM6OWH9Bmx3jKee3s8nP/Ze3vr2NxIFkt279nLo0EGeeuopfE9CK13xmP34WME+ZgSLopB6o0qtDlOzoBwcx0oLzIRGWz6H7zVRFJgplpmc3YxEo3/lfETYxLHL5Dq7uPjyy9m+7wXOOe91nHjiW6kO7uPNV3+Vk864AM/wefDxp7j15g+zdV+R7z58iLHREm9980l8ZvFq/Gae/ryKoVepqSrCN/FsD0XTMHWFRqlCoq2Teb3dIDKohoWMgni3YHvUq7E2f9funTTwaW8bYO2KCxk/8iRHBx/kRz++l8vedBmJjMsP7nkSxUnxmQ9dx+Klx/GaM9bSaDS48+YvcMP172H9pW/C9Rrs/dP9KGoJJSrT2abQl+qgLX0uX/7Wtzn73OVc9c8/ok1Zxz13/Scfe99FzLoOB569h8O5Uzl3xTL61i1l3v4mZ599Dr/59a18+c6tvOqidWw7DGOHXiYo7ef1F5zJl6/5CX19fTScaZLZAnfd9inuu+uHlGYCbK+KpetEtqSju409R/axoG+ACbuKltAJnRr5bA41Mgi8ADtqcvt/VUlks6hNwb2+IPBtQmmQSVpEUYhvatRmi/Qs7EVNpBnd9TIkkyiqQeQ5GKqOV27Q09XL1de/k3UbLueMxR2onTm8okO3DNlahI3L03+zXv7/Fm0hRD/wc6CbGL74Qynld4UQnwP+BZhu3fRTUsrft+7zSeBaIAQ+IKX8w//ngf/bpVZvYCYs9m7bTnF0itNXrmH7My9iqAYLTtLIpjN4nke5XGbN2hNYsKAHSwqqlWmEYM56HsUQ6DlIzbFQBNf1CYKAIIjm2iOmaZKwsmiqSXG2EbcGJHOrTMcJsBJJFEVroVTD1vPEK/solITBKzTBYyeJY5pt3/exWit/LwjwJYS+EhuIZEjgx7sBRZjMzI6yon85M1OzzDhlgijBl776JRAu/3TltSxYMB9F+kQeJBNWCz9rtGzysXvRsV2CIGhJDSHwXZLpNIqixPB13yZCEoYRmojT0x0/IJdJ43oOimq13qNgbudiGEa8/cu3UW8FKAtFo1azY3yo72GZBkGcX46QMu5Tm0lS6RRhoFAuNVAMl7TiYlqxrjlC4voeCEF7Z0dLSunR0d3FTGUaPwiZmJiI2TFCZWJskmq1gSFMujrnsX/vbgLfYXJ8hGbNY6ynhlQVkvuHaGvL49kOWkLlj488zMxskdPPOJW9u/dgWQUWLlhGJpfh8SceJ5uMcQeFdIpa3aVWr9KWzTJ09ACnnHgeHYUkX/7+PdDwWNA/j8MHjjI+PsLevYfi4hzRKtjxTs7Qk3GbyfdQFZUwchAiogWPRNPUmGsTgd2UeK6PqsQhr64NEJu7fF/g23VCRWP/vn2c/qoFJJI5+maOI2Mlufc3v8QdDyGaRKoaWwfHef6nX2Dyax9m1eI2nhwbI5lVOThe5+3v/CC/v/NJqhMzGLkaWCq249Gei3GlYdggZSYIhaDZcEilCzQcm6RhomsGesbESFixnNaTiNDG9xpsenoT5553JRNDO/jWzT/mpl88QiGZYMXxA4xNjDE67ZJLb+bRh35EWC2hJ9qIOjs4+zVn8cym51l66lLMYIyBhf1oEYTkePCuR3lq0yNs3LiMgiKIdzGDSAF5Q2fj5Z/i7h9+hhVdG/jl7d/Fn5rkGx/5FjLZy/0/+ArN0pu54YZb0Eee5k3v/jceKRYhEoyPH2Xpgi6qTZfydIlTzjkfLVulzToe3ylhKhHVasA/XHIpR4YOslbrRDVUpmbHmRweZd1J68imOxkujbFmZTvl2SKFdA+mKch0LuSFTX/CSGsUsjqFRIpIW0qomrT19DDSngA9SVs2R821OTgyxPjBA5jhGI8/9gi33XkrDz/wMEskLLzwi1Re/hp/eOTZ/7FW/u+stAPgeinlS0KIDLBFCPFo62/fllJ+469vLIRYBVwJrAZ6gceEEMtlnGr5Ny8CgQwVFi5cxOjREaQQTPgOJdclqpVZHgZ4rks2m6Faa3DWuWfT3duDUveo1acxdXMuqCC2d2cA8DyHul1HKAaKorYGkz66HlvGpZQkhEYYuHOyvGTKxHV9crkc9VoZYcXXHzsRBEEcW3TscqxFousxD9dTw7mi7/s+qppEURRszyZQYx623aijKSq2G9tp08kMuVyBMPJ5adtLyJyJKCXJJkJ2DEPfQJqF7QWmZqbJp7owDINKpUIql8G1HUBgWAl0XadWqREEAV0dncwUSxQ6EtTqTfwgJhUmEgkgIIx8JCGCiEa9HFMC3djmn81mW62m2E3qeR6eF2BasRImm2tDCDWWUErwPQc0ndC3adQrJKw0eiLHxFSF/oXLmZkaxkrU8PxXIuGkFJiGFa/8I598PgfJeBDa3dOJ67t89cvfABmvYHURUavV8QOYnSrHnBlV0AgjIh0OTEwhVJVoYgTdNAg9Bb9qt/IZEzzz5JOccOKJrFu9mq079iA0QULTMExBFPnomuBVG0/D8wKK47MUi2UefOgubvnBF8l3L0NIh+LUMIgI5CsGLUlEXI4VpFSwErk4TioVEx4RGqigqHLOnuyXikBAJCMUNKanfJRIRwoPoQgSKQUzgomjm1FVC19TKLR3YSQz9PbNY6Cvn9eecjrh7BY0EgSKhMjloqtv4NmHdvOaM5fxrgvXYEcBH/r8Q4zurXP5NW9kavoo9/7qHgqEJJPxZ1idKdI5kOfg/kE6+xdgWgn8KERKhaYbYpoRpmnGAkJVQzegO93GxEyRpcctZaIOJ7/6Izz9u0+jGQkCReGJZ0ycUpG+ZeuZHJskbBaRCNQwQTj8LF97z2vYefEZnLLkayxafBGXf+ALbN7+GL//w7MYxg4e+PVdnHfRGbz6lJMBi8bMGC9sf4nT1p7I7Tddxr23buHBe25j7+NPU6o3qVbH+Pptz/OzX/ySi6RFspBh4dp3sn+ywZ7x3ay5+ANYPRlqM1P0ZXIc2r4HpbAc//B2RhtHcBwPvxlgWSbP/O4gl735cg6+fJi2MEWvyLFk1QkojYCpSo0ulnL4wEH6VixjeGqE/TsG6Vtd5z0f/RSf/chHaEwdIdfdjZXTUTyHnr4BVDNBrTjJ8FDIgt5+RnfuYWDJYl57yet46Ikn6G5EnNx3EoneeVzzjqv4jfXPvOP6n//fF20p5Tgw3vq5JoTYA/T9L+7yeuBOGVOfDgshDgAbgP/51CEliqIRRBFLjlvBsmVL0F3J6WechqUoHB0Zx/Y8bDdqBQ74NBwPM3LRpDq3sj1maw+CAGQM5rcsMQcYF0Ki63GrJJ2OI7tkEBO/QhkReAGIV84tryhNorngg1d632KOayJlHE10zE2pJ+LcRkIfP/TxifCFJJQxrtINPSw1QeR4iFAnUgRT402WntDLyEyDCMmSV72RmoAPffwTLGzLUpoawdKTRK5POp2LA1CtFDKMLfae4+D4HgJwbJuUlWxlU2rkchkqFVCUACElumoQiBYuQI3dcUCsCFEUnFa/O4ZtabHV1zCZnJhEaAapVMxV8YgxmFEUYSohSujSLM9gGSlqdY9sysJ3BUnDYqpSxDR0fD+G9Gi6jus7+GHEunWrUBSD695x9RyfXAowzJgBE/oRgQRVClQkKgGhiMmOUSiQIQgRkElmqNYcpO1imAmsZJ5ScRZVFYwcOsK2F17ilA27OfXscwhlRH9vN7rus+a4xTgNm8ODh7FdB8dukNANQreILnRKswchiNDRENLDF7RO3hqgoggNQ0+1tPtBK5knvo2qgQwFkWqiGUkUTZDOGXiuje9WCTwPSUiEAlIyv7+H8YkpPMfns/9xA+e++lK+9J1b2b93J8et20CjYaM4HivXHM/uTYcRORN8F7wsG089gUatyK/vfoTFn76YQMCSJUs4emg/zz3/Mm9+64WsXLuCz7/7ego5FZH0SSWShLUapWKVJZ29mIpJ3VNQTB3P88H3MRMpdF0jCDyEKvBth/aONBPTw8yfv5ZEykFNJ2PTTtCLdEZRpcYnP/xObvn5r3HGIDBNVi19LatPPYtv/mKQ9csW8uOfbsezFQyrjcnpAke2/JSrr7uZX9z6Ab7xg1+z4usreOuHP8Ht3/k6+/cd4tTjT0TH54p3XoY7McjoovUsXnYpp73hMnzfp773IV530X2cfelFeL6kf6FAJaCBxugEbN81jaWluf83dzE6MkMmqRNGafzmBJGq0my6rFo+n6V9A2zd9Bw7Ro+yaskqtjz2AD3zeylNTfK5b3+HtdVTuON3d3Le+RfSs2CAjJXjO1/4Es3JQ6QtA9+tkYuymPl2IhFQ6MzhlmPD34xbwinvZu+OMSZG9vHqN17P3bfdSE9nBzPlIZ669zvMi3wOTCT4ny7/Rz1tIcQAcAKwGTgTeJ8Q4u3Ai8Sr8RJxQX/ur+42wt8o8kKIfwX+FSCdTuE2Gzi+Rz7dRmWmSYRgvHQEJXKplaoxXc6pEXgNavUKkYBa3SaQICKJHwZYqonnx7S9MBIoisRzAhKWjqboSCkQKHiuj2vEAznHt0kaFkJRSCbTuG7cx3Va7ZRjQzY/8ImQoAhcX5IIA7zAx9SNueJtGAamGaErKg3bxjR1pISUYSEbAUFKw4sq4DcItSxBIDCjWYQm6cilePyJ58i0GVTkOv5057f50jcf4om77uas0+ZTqY0zb347xUqRZDaHqkjq9RiQpaCSskxSFnhegOvaNOyYx+u7NqlkBt8UgBVL9IjiXriitXYDKkEYEEiHVNrCcWpkMhmq1RkMw8D3QtKKpLOnm6bjkM5m4vw7PR70aqZBw3FQDBPHc5maHqWzewDH9ejKdXHqOa/j7ttvJJP00ccmWNhvoYrYjZlMmkyOjZMvpBhYuJjDRw6STCZizrQXoigaitAJZXwiEQpIRaJEIaquxMoMVSEMIuqNMhBTQYMgwHHKc5zzul2N9ftpnz3bN3HmKSsoFsvUazZbn9uL70aE0iOIXGTkUwlDbCfELJh4JQnCIZAx91pKnfb2LhRFIwziNpiC2gKHyb/aTUAkYg66CD18GfNzAs1CN7K0dy1FVUAVIdX6JKduOIETTziOm27+Hp0dfWzfOc3KtXUO7NrFmRdeQaK9nYXHr2bX5BC7N/0kzqOpAJrG/CUbeeChP3Px+ecwf2GGGz75Xdau3sAXrjqTpQvn88Jf9vCb2+8jUVD4/A++jRpofPq9H6Sjq0AqnUZRJUZaoVidQTfmgydJGhpeFFGv17GsFJpuETg2fqTSKNlY6RT10giWlaJ3wWmUJvdhpKbozK2nWKnxiU9/isDzCOpFQi3P0MQjPPT7u3nzNZ9l30vd9HRbaJrBtukXaesx6D/9q5i+RNLLv37ow6x74yfZ/OB/8fC9z/DjW37BxnWnsnBFP5//wlqW9ZToWjBLW/8SPvXef+Gu39/I0Y1XcvrACjqXncn44T/xtnd8Ghkc5fbfHWLZmoUU8h0M9A+wLJln68HHMKI6wjDpyWcwpKRYLPPck4+w7+ktNMK9iFCwZeopEDAxNkgq38sn3/sPoERccPkH+Ol//huqoaLpBURYBzFL3ZEYvs+sn0Ym+/Acj3+YvwI3neW5FwZZMHA8Df/nXP/NF7npW9fy25tvROUQUyNHEWqOI23dVIeL4Mr/XjL/z4u2ECIN3At8SEpZFULcBHyRuM/9ReCbwD//7z6elPKHwA8BujrbZCIR41OFZlCp1slaGTTTxPV9cp15ErpBQo+B7oVCga7OHg6MTBIKDU26IBU0reUiEgpSxs5IoSqt1PbYhJFIxBQt1/GIQokfuSiaiyREClB1nSCKUFVtztGoqipqSyJI/B2Zw07qeuy01E299dQybhn4MV/aNHU8xycp0wShoOnYFCdH6Fm8ECECdKYp1xpse/EFTCONJwN++7ufMn9eG//5mRvoX9SOkoCFS5bRtGtYqSRt+TSIHoaGR+e4IU4zliOqRkwxjNs/gnKxhIJo/U8RYQiKIjA0g3o91rf7fmu1J31cV6DrGp4Xp9DHcW4O9UaVVDqOghscHGTevHmomsHUzCy6bmIlknjuMdiXTxg1CRFoZi9B2CBCp+74GF4DTwmYrTZZf0oPIlJRdYUnn3sGIWI9tuPahGGM6Y1TgiSqKlqxc5JIihhZ6kYxb1qAEBpSxi5aRYlhXELAipUDLFq0iFTKolKpMHTkMLVak0w6h9PiqYehTxhIwkil4ciY4S5jy34kAu59fC8XnruECMiJTMxgVzR8L47vgjgFSVF1IEIiiCQgBMj4WFQ1LQYoIWJDtFSxHQlRiMRH17Ns2rSFRx56AE31KYUBo6MP8JsHfgZhg3qos/qUC5iqCfoXzAOrl9AZJ5QGSmRz692/JRAeg08/T7k+zYqVA4hokk995RZu+MzbecvZp3Pz/X0c3HWEp3a+RKPmcMtddzA2fIDPf/BazEwGJTJx6w1S+Tq+69J0BOgWUrcIwwSeG5GwdEzVIKGYVOtVqk4NzU+y7uQ3sWLZPPr6bNqtdl546nn61/aya98uNpxzBdlsG9NeBSf02b9tK5t+dQelWoXTzl5PUIO29n56CtBWGGBoywD33/x9Hr3jm2yvSDZ+4DU89tl/5M4nNnPdoj6WdEtQclTrNWaef4LL3nw19eAAH73+eu6IPFTbYMmF5/OrH11HJAS9q87g6L4dDE4XGV6+nsroPpz6GIvXn0nKN9k5NMVFF12EHw2zYuUqhBKye7eOVH1EoKCgkzRN/GYT1DyqdPBLs0TeBIGfIxKNWCFmWCR0je50B2bSJLeon0iVvHxkByeefjL23fcRhQo/fanOrx64iyv/6TpeHhxkenwxiq5RsDSMzj6SJ+kU8t08dMtH/++LthBCbxXsX0op72sV3cm/+vutwIOtX0eB/r+6+/zWdf+LJ5BIEeGHHuVihUQiyejkCIoCET5Jw0TksnHQpq7jucHc4E+R0SvM6vgr25LsqXPXyWMtaKEQIVtIR4EmwGzpT6t1e65Im1Y8kDu2ggbwWtjY+LUzB5qCVwaXx/rq0p9EJ40AACAASURBVIhRs0rQyoVUY4wnQCoBMgogdHGdOuWZWYqlKjVb0tFmIrU0px6/Kvb2+9tp69hI5M1iGBmmZxq0txcIkfh+CzqkxgakKBGnyxMqr+wO/BDPc7HtJoZhtkBaca9fVdW4beT5CCUu1FEg/l+J0VEQYbtNEskE6bRJsVSjvb2dZjPWHkehh2WYRCJWSOiqimYZOJ6H69lk0nmiICKXSSOR5NvamK0U2blvDxmrxOrj13PahrM586xT2L53L7lcLg5I9n00rVWQZawkiT8LWu//K20peewDaRXsFSuWsWrVKkZHR9E0jYUD85mZmWHr1h1ziN2EmSYIohZf3UcR8aDZcSMUXcNueniOiyo0tCDkd7/6Eb79Nn726wcR2PD/MPfeUZJd9b3vZ59Yp3J17unuyUEzEtJIQkIBJMAiyoCFuVgYHABjBL6O1zjgd+0H2MDFRGMb22AMNphsY0QUQQghoYCQNJJGk0N3T+eufPLZe78/TnXPcJ+5661117qPs9as6dVd1dVV55zf/u3v7xsoEYYh5XKZwA/RWuX+F4NrYcOgDEAJhZS5G6QlHMDA1Blo0JgDy2FJJiVO0SNJK2RxGzBA9CAzsN0acdjl0I8e5heueR7nZueoN/bTWWgzfeAS3vqnf8G5tRW+c+cdTLkObkmxfA6KIz6NRpmvfPMkNz3rEq6+eoTYX+b0WUWtWOVTX/wcz3zms3nuL/wyd3zx84SRwvVKBOE6jgme7YGjEZZCkGGZFgYm/bBDpe4yNFyl14pp9RVFz2Bxqc9377qTThDRqHos2HDl1c/h9GLAie+fxHY8fDvg6+96B8iMd/3133LZ5ZfztCuHePBIGxUVMBOP0dEeP/jOB/jV4DdZ8cfYceAyer7B7V+5gzf9+ssQKezeNcSp0x6intFcfoJyxeG9f/iblGrjdNQYpx77PrXde0n6bRaO3cPQyH7sXZMsnv4GW8b3Ud19kBOPnMQbduitLfLZT84zPD6Jdktc99RrKY1PocImK7NnmJs9Sz8KMc2Ua294MQ//6FFOnTpDwR5HkzuHFgyF6RbI0JxZa6JsqHgWSRQSh4KLrqjzRx/6Cgs9yfjQOK985SuoCYfrbryZOJOcnTtJsVRguFZleGyGY48/xld+Qrn8/8IeEcA/Ak9qrd97wfcnB3g3wC3A44OvvwT8qxDiveSDyD3AA//L1xhkRDqFEjWrgJQpQ7VhLGHh9yI8BAXbRRsmUuZWqENDI5xWae7r3I4QphgUTZXnwJULJEmIYeTbVtsq/JhH7UacWBpnBP2QLElILHMzwd2r1UFo4iQCQ+TBnVLiui6GwYBZYW36f8N5etdGAd/4ulD06PZDnCjvwpvNNrv2ahp1WJmfY2llGatWQVjw3P9yG7VKhtAGeye3URvOUCsRfVL8Xpc0TRmbmKBYLG9yxaMozjF0cnvPjU4QclVou90eJFNLMhnhuCZJLHELNihBFMcDU36POIoI/B7FYhHLsTEMgWu7ZKmiXq2ilGZyfALDyDtR0zQxAccwaDebDE+M5QXc9QjDkGa6TK0yCQLCKGJ8copadQitS7z93W/KFyftAIoPf/gj/OVf/iXHjj6BEIJarYRlOew/cICt26bZtm0KwxQ06kN4hQJpmuIHAe1Wi363R98PeeTRh3ji8CG0hsBPOHt6PrffzRRS5ue/l/XJsoxi0c3NxHQ24ONrkjDBNh327t7J7NwcIh3iy7d/jo9/9OMYooDt1rFtQb/fRUpJtVKj3+/nnf8FOaeIfIE3reIgNDq/FlB59BQalEoJowyJQckukaIo1koUDUEmJM3Fo2gi0hj2bxlhYa1FttZk9ewq49t2cvDaG7jrrrt47S/9CXufdQ1XX3YAs5rv8sqeTd0apttfZmnpcd72zq/yq298I7/3yoNM3b+F73zzIYb3TnHqxMNs2b6VT93+ed7/1j8j1F1mJoqUXIe2dKiNT+N4ZR57YpY0BUUNLaG91EOZArdWY6ze4FxzjnJ9iL9455toDJfpFIeY6q1wRMHzZ8Z4dD3k+pkRSsP7+finPk4anOO2V72UTPm42iY2FUiJgYkSEkz4x799L5/6qz/nhNjCe40R7v3mf5CZf09PZbztXe/kVbfciyOfwKuVcXtj7LjhMgr1GRreRdz+6Sadkz2EV2R84mlkaYgZVRkfv5xet8vC+llmtk2w2OpTHZ0hDkPOnprnqmfexN133YufhXilGouzK+zZdxlbd+3DK9aIVYahBHOnH8BQGcqogrLBKYJZobZ1K087eD0Ft4HpVnEtieN5NJfXiYI68co8x86eJY76jOzczom1JsKEuCsZHrJYXfKxF47Tbf3vZUReD/wS8JgQ4pHB994MvEIIcTC//DgDvB5Aa/2EEOKzwGFy5slv/K+YI3nVNpDKIerntC/HNVH9mHbQRwoX4UQ4qULJvMvqdFr4fo8wSCnZDsK0yLJ0kOSeBwEbBhiGTRyHOE6JTA7SlFOFzgy0CcVSgSDOwMhTaWzbQakYofJAUHS+jTWFsZlPmRdmMAw2b0THcRAaMpkNshzTgT1rOth+ZxgDnzBTVJCZQBNtslFWVvpMjAzR7bV51k03I7CIBVSqAZ7j4Zs2vVaPWqNOzw9B5F1iqVSi3/fRWuQDPssZwAgKw8jZFVJmKAm27RDHCa5THCxeAzn6oNgLLRCpxNAKlSqQimzwnqVl4douQRRTLDuoLGV2fp6ZbdvRODmubgnsgoFQElRGFoWUvAqGVSCJNegCvh/h989hzJiMbKlz9fUvwynY9MOAhcU5Xvdrr0MAQ8MVxidH+PmX/iLl0hBFr4bMIpTdQQibsBswPzdHpVpFScnI0BA7ZqY4duokpuFQrxdYWe5QrQzR6XXJ0gzLNoiTENMoUCrZdLs9giAccNEtlMpwXZf6UI2yV6NaLeNaYBU1SZQwXC3QD3y0yPNFLcvZ3GlVKhU6nc5mShKc77gVEmFo0kwilEQpAwMTRM7GEMLAxIDMJNUBOgNDFzBsEJ4HqYYsxG8vYac2H/7z32Fq71O49TWv4NzcAs964Qt45IknKLslhFTIRNLzA8rFCrLZYajeIAoCDuzdw0fe/0F+7nk/z83X7mXKK/Pv33iIbdNbuPObt/PZcw9x6aXjnD3eJfBX6fcgocrk9u1MbhllZa3FwlKA69Rzz3Zb5rCaH9GO1qg1Rjlx9AF+9qqXIkUFChdjBKdQhmDXwadzrjnH2//uo9x0089w8omH0Erxh2/5U7bt2M7unXtIBl43J0+ept1c502/81pOPfIo7/jQv/O5z3wVwxIouUKcZXi6yK0vKvFKu0Ic25SjFs1gmP5dd3Lrb7yZ+UWL0fpWnMk+WRYghMfo8BgLc+coVapM799Kt9eiXC2hzEVk5jG2ZQqNRbvXpTpRp3U2QvoRQzv2M7/eZm7+e1iGzY0/+1Iuu+ZG5s8cZam7ilWuU6tsYWLbPqK4z3I35pqbn82e3TvozmeEcULZqtHqdtAEzC21WT32JLIAPROSKMZzXSbGRmm3eggtsVKLcvk/52jn9+r/LNv6/+EYHxvSH/zA+0liTau7jmVLEtXBsWqkYYFaRVEsWHz/vruYmJzieS95Ge9+97v59he/xJbRBjrxUSqlXm/Q7XY3C6fruvh+gOPYOAWHTGmUyuETUHnKcprilYr4fkCxkHeHjmNju24uuS6VWF9fBzSOk2cnbrxGoVAYuIilSJkRxhGmaSGwsSyHOA4plfNotF6QUbQhlgrDtHn2TS+g6Sd0wyHWw5j+6nGOnnmYfrOEjtf5p//4Hh/9wG2kvmZmeIh+ZDK/vEiz2WRmagtB5COFxZEjx7EHWP4GTHOhAtQYDBuHh4epVCqsrq4O4tHyFCDXdQnDcLAINNADzxYl82BlwzIJw1w0VK42SDNFtVrHtm0KxRKLC6uUShUMK6dGup6Ftiyq9WlMw6FcrDFc93jskTsZqxvEfpvjJ8/iRwHgMDQ6TTdsY5hw60tvYWbrJCXPYnl5ldu/+DVOnTqD4+SpRdM7x7AsgzPHVvi3L3yG7919Dx/76D9xyVMu4tBjD+VQV3EchCJL853O2toq1WqDdqufL+q2GpxLh7W1QUpPFv/YLqxWq2DbJjrNaZJpKnPqoWGDIZCKgbukytPoPY84SjYj7pTKjbu01khh5DsxYW5Cba7hYFguscyDogvlGiiXUAZYOISdDlnSxCq1ySIfM5NMbj3A8MQ2fA1bJnYxNj7E1NQulFnGLVTptxfxEMT9JmkWUmtU8DxBGnXZPj0BwNDQCGfPncJfN9m1cz//8PHPcvTEUezSKmncZbJqEvZaFBvTFCtTjE1chjPcoNnt86KXvoKHHjrCQz9YpVAo4FUMDMtkpblOu9umUrSYGq/wqlsOUIglpeIQtpUwv7rIbbe9nIuftoOqG2LGISNbdtPp2qzMdohkSHstd7Z7yhUHGRsbo9Npcd89RyiZMb1uC42JI0xwXf7qI//KK1/6LLSR8MUvtnj1rx3ATFP8YC9J9hDXvOyXiHvjFJOQ+37wdWqNOpqA1uoK5VKDRCoKhZy5ZBgGXqGOYZkoVcUrGlSHLCqVCm5hBKV95mfP0FoNieKQNI2ZGBqhNjTMk4efZHpyisnxMZ6YXyRYWqE4uRtTRfQWQ4xijIoT6nsuptyoMH/fv/Omj32afk/yo3sfIpHQqG/BdV0s08k1FcUiSmWbdNIvvOtlD2mtn/o/18ufCkXkRraYzDSea9HpLpGKDs1uk6H6NjCKxFmKTFLSNPer3vTISCWWzjvFDYvVDZjC8zyCINjEny2Ve/DawkIIjZCQyAxrADMA+H6AFkVA5LGqKsdSbdvZxIo37GA3uMw5UyGkPtSg2/ExTLFZBDYWRWGkYDgIWUApje05GLFCmw5uuUzcPkWxUqUQl9ECjj70MGkcEceKlXYXmebqS6UUQRTiFj1SpfGKBaIgzucCKod3zYElLYBh5Jhbr9cZ2KzqzYFqmqabsvyNODfDMDY7bEvamGgsy8C2vRzqKRRwHAulNCdPngRt5WGozSblchm34KAMizAMKZZcOr0ujqGxrSKJ3+IVP/8ySrVRfnDPYY6efoJuv0OmmmzbtoODl13J4tIsn//8Zzh76gxDQyO87vW/yo4de/jSl/4Nt+Sw2lzkv/3BGzh5+gTbts1QqXrs2DbNk4cfZH2tB8OV3GSsHWLZUCqV6fU6FDyLvt9EBimQJxopnREn+QKes38KZFlCliW4bgVsG62j3C/dMHIPGASmldvnGgZEkb/pwR5G5681OD/3MAwDqXLIzEAgDVBKIoSJaeS+HAiNiUBlkmqlRGO4TrHkc/LYYZK+TxR0aTUXcYdHMYRmZGISZZu0mitUiyGOSjAtG2E7ZEkP2xFYpqAfRwRBQL/X446vfZ0gzPjhg/ex3uoyVB8dQDd9ilZG6CuSDOpuCcN2kAiWV1fo9HzOLZyl0ahhWS3W19dxIwOvVKBcrWA7BnHQYWH+HAuLM9gigKU16qUGvSDFThVWK2Dv7gnGxmvc/oMH0MUqSSBIVW4b4XklvnvHtzZjBrUwiKoVCrGPZ8KSAist8bo3vp43vCEmivZgSsWefZfz2KPfZstMg4U5g/knH+WSq17J2RNHERWDULYQaYuhoTKRTDCEgema2IaDwMLvt/J0ILVMt6NYW/dp1OoU3HWqjTquXWTvvmla7Q6GYXDs0OMsLKxQqVcJ1tuc7HZ5+c/eykJnnTvv/AHV8Qn6XsDQVIN29xiG0YZkHVGaIOv7jFUbXH5wP07JY3Ghz9Li2mCHD8urK4yNTiBVuEkx/s+On4qirdFE0gfbwMBnz+4xGqVJop6g2zVoBRGWWzgvaNAa07BIEkhTSZaleEV703skTeMBgyDnRtqug+W4CNcmkT62k5tCaSGoelUUgm4/91bwKiXsgkvBcojDwcDOclBSIcy8mwzDlEolVyXm7IsUx3EYGhpCa/D7MXlimthMzjFMSZakQAlJSiI0kchwhmoIsYXuwo+wmODlr7gNgDu+8hnMqRJukiF9QWWiBr5FoVhkdXkRTINiqUK5VMI2C3S77YHXd45EbSwmaRoPhDC5Z/X09DT9ft7ZeJ6Hadj4QQ/TNHPuORLDBM9xEUIjkRhK0GyuMTI2SRyHKKWoVGokSYJlwfy5WWq1GknUx3IrGI5BlEUYwse2XeKoxdT0NBOFGnff8RWmtu7lykuu48rLLqXZW+Tk3Bm++vWv8dWvfIFOp8P1117L3r17cZ0ye/Zdxl998N3Mn51j295xJiZGeM+7/4ZtO3bynJ/5GbJMMTY2QckroxE0W6s06iNkqSAIfTQBYEAo2LF9B7e+8qUsLy5x6NAhfvjDH52/BgeeM2BgGR6OXaLfi9CiiBIxWuWdu9IaJAOf9TyQOgx9HKdGqVQiHXi0bIRopJnEtWwMO08JKjguscrj3fK8dYs0jdFGho2J4ViozOfksaOYoo/WCte0WV9bIiPl8ssuZ2JqJ8cXu6RJl7KZ4bfW2DJdJ3BSUlMTNtd4+P5DBGGX1eUFFs7NIYRmYmycLFZ4Dc1EtYEtM0TSR/oBlCxWEpM4KZA1Iw5MVOj6CU+55gpm52dZWlpAqwppErJ1epqWv0IYR6RJApnLVH0HsrPM/bc/zEr7cbZObqVYrqPMPPrO8Ep0UonuR1xz7fXMLi8ye3aV4aFRSHssLC5R8DwymZClKWhF3O0TC+gZ4BZLWJ6NTYcsTdmzu8KpEz/g5PIODF3mhp99KoeOXMqT33kvu654CVNb93D4+1/id978x1SGCow0JijYVbQW9Ho9Fhbm+fo3vs0Tj95HpM4ghIGWBik2i61FKpUZVhZS/DjGdIZwXZvR8Qkuf8YziZOEgpVy8vAhECZfuuufcYwKTi3m4HXbuOv22+ksx1SMYcxVn9p0mXn/OM2lNmHfxtZFOmsJpmNTqjVQ0kBpBydzWegGaK0ployfWC9/Koo2kHcggGnZtLshn/nM5/ni5w7x6U//DTKKUULhFmxMA3zfHxg45c8tFD2Ulih9Xka+AZFESYYiJJUS08y7q7ynyYeWfi/Hny3DAKWRaUpmGCjDIZUZRdNAaoVlWwPGxUY0U85ASdMkN7KXkpWVJZJBWvpGt5WpnASWxhZKpZiWT5YosjhFZZJm2GV4fDuJ0kRhj8iK6ChFKwjIziywvTxD0AsR3R5Jmhs5Bf2QOE6p7xmm5JVJo/4g/ixXem5s3TdMrnJusdxM7LEsiyAICII+1WodwxgsflJu4vfKNDGtXPnnFfPU8E6nTaFYJAzVgIpnMjk1wcLCAlmWYGhorrdxy2UKRQ/f95kYLxNFfbRRyKO0hMvY0Ba2TY/TixTFSpG/ePfbGZto8NWv38Edd9zB7V/5PBcf2E4YKM7Nnea2193Go4ceQJsJaJutL9+JzAxmpieYnp7knvvuZnhihHHH5tEfLtFsdRgZrdFck9xw4zM5c2aWi/bvZ3l5mbvuuosD+/fx3OfdRJJGPP74YQxhDc5luvlZJUmMYSuyTG4OlrNUYVg2pjDIZIKScnCeNTLNxTZZmiIGDYNSCiUVUhgYQm4uqoZVGCwAkKIwTIFp2MRJim0Y2JZDbXiM7loHDE1GThRMk4xydQJhFAh6Z1FhRnN9FtsRBP0S0hS0uyH+wilWl5dBBliWxchYA5lmrLfWMIyIROfmZmGQYBsCrTRmAirNu/5et02aynxAi2Z8bIhmp83Y8AgyDVlfO4dXdUEZRGGMsAWWbWPWqhw9foyyabB3coKxfRez1lrBwuTE3Bw7dl7BYjuiIA1279jDnt1Xc26pw403XEqaaf7qfX+BKSRocAsgo4ysmC+Ome+TJUMEyQqW4dA+e4pdu3bwlGtfxle/sM7cSpvrnvFU7vtqwD989hvc/vUjmG6Z3/qvr2F6rJwrU43cSyXn7sOf/9lvEGVQLgo+8ndf4evf+BI/fPh2Zs8G9HqnQNvU6vvohR0Sp8TCwiw9P6BUqlDaMsaWA/uZXzpB5/hpdl51OUsPHObB7wVcdu3TOX7sMLpt4gzXmZzexROH7iDuRLgyZZkIZVlkaUC9VsMPEmy7iOua0G0jBHjuT3mnLRBYtkmWpVhWmUzaPPdFv8KNz+mz3O/jVWokSYjreHS7bWrlElu3biWTNpmQ+FEMKCq2h2lpiCwSlVEcYIhSayylQOQDQRnLTf51uVjCKxZYX19Fa4UfppREgayQd8lpEtIPIpyCiw6iHO/yHKIgolzyyNKUfq9HuVoiS+TgORmZyrMAHQyKxSoy0XhlA9dNCVcjLG1jZB2qJcVIpcKcO4mOz3Dlc5/PseWQ1fU+2+oGJ5vn2L91F0naQ0iJTBLGx8dptto0V9fI4gzf9zfFJxuZlhvwSP6981mYa2srjI2Nsb7u5wwRyyBJ8kXHc4sIYWz6uFimQKuM0A+IkhinWAL05i5GCEG/28WyTGzbYnlxkdGxrQhpkUQBWuTcdi1NtkxsZeH4g4wXSiS+JmxDdaTCkYcP8X+9+TdYWjnNS37uZezcsY9+p09zdZZGw+XYkyvc9OxX0O9KlF6iYNUIwxDTLrK6ukSpmsM1TqFB2Et43a/fQLPZ4vSZWZ554/VEcUC15qK1j1eUlCtlTp06zqFHf8TlBy/mhmdcwzfuuJPjx09jCAfTygM3EBnoDN/v49q5Os1xXLTOc0GzTOO6HmEU4FgO4QAmcQpF0iRDKXKlqdCYjk2WSmzLJJUZBQPiJMIq5u6JjmsSdCOKToMgaREFPmOjDTprGssSZDJFY9NoDHPq2HGEPk53bZH1pXlE1qZUcFkr5arfOJVYBqg0yuGbQAysDhRSJWRSYQiHREuEZZFpI3ezTDRZmg/rO8stHrr3bm58/it44uEnwVFsmdnJsaOPE0cx41uHUHQYHRqmn9Rotts8eOhhxkarXHT55dz0nBn+7p1/wrF/eByE4NpnPINyuUhrtU0a26x2Wqyta7ppn8uuuJ57jzdxCyXe+4nv83u//GzcwihxOAsoSHIygNZQ80x84VItTrDUfpyFR03OLfTo9jV7Rw/y2b/9IDONEvcdf4SVMzH/+IWHmVt3uffeU6wvHuXU6UXOLJygUZ/m6dc+mz27LmHPLih78JrbbuaXb3sumf57XAWWATKCD3/y0/z9R77FI/d/AoSg014ia1jMHYuwy1sZHh7m4HOfR2e9gze0l27TYXn5HJ2lVd7wO2/ls//6YUb3XgS3lxidqNIJesggt4TotTv49HG9In7QxbAtxooplmmCCn9ivfypKNoMCorjOIRhyNBwgyeefIQw8HnKpVcSBXrAdzY3+ccbHbWUFlpKLCvHe81B16vNjVACNtWKGx4hKH0evx1g05ZlIYx8aGQYBkEQYA4wbMfJV2bTzOmDUsmBSCX/+YaCzzJzc6UoDHG9fMC1gRmfHxKyCZ1sJOPYtkm73SaOYyqVCgsLS/jdNsUtJdphSBgGGKYmjkOyTFEouuhBh1YuF1lZW8M08l1AEEQXWMtuOM7pzYCGNE03C/pGN7hBT9xw9TOMvBvZ/Js3dg1Zhm1YCCDLEkqlEvV6nbKqsHhugVqtlkMFCIaHhkmVzHchAypcGIZ044ROp4MWULIcmitrrJ4+wcSWBkNDBbZuHaNSztgycQAle8ikwv6L9nLk2MMYlobUZXKiSJJBrVJn9459pDJhbHyEKOyTpDEjY0Ps27+PZrOJUhkg2bN3B1EU0eq0MZTB8CUHOHHsCOfOneN5z3seW2eO8u1v30nBqtLurLF1Zhfr6+u5N0qaGz5tLFSQC5Ryc7Kco61UNrBROP+ZG4aBYebXdZZGg6FmitRdbNch9mNcr0zY9ZGJBMuhZLv0M58t43VWFwVRmIIAx813A93OOgW7QBT6+P0W1WJuy5AmCRoD2zRJkihXCWcCTUYU9jANB6VyG2DbyYfTZBopE0zbQWuFTHP9Q6VWIcsSkBbtzhpuqcj4+CQHL7+KT6x8k/GJIVwvo93tMdyoMT25DxHCyuI8iyLmyCOrXHrwINdccxUAi3PzrC4t0+ks4zgOq8urDI9JyuNjLKys0BjazcLKAo1GA3Q5z0hF5TFmWW4apcnodjpInSHdHgqT8T1P4dd+/8/40me+xZe+ezeFcpWVuTm+9rd/y94Dz+Uj73orDz70FeIgAmMZhGLfnpdx8sn/4MMfeSdC1CgXSpRqKzztypfx+te/hBt+5kois0xBgfLgtb/2C9x6663862dfwh/85pvxo+N0myn1ye34i8usxn2E2aRYdBkdHWd2dpXTR2dp1Ct8/lMfIskMds9swayODHx0UlQaEKmIgmmQSoWOQ8BEyHyhz5TGMn48qOXC46ejaANxkpAm0OkGaAFbJnegMkmnFeWJ4TKkF+QpMUpApVIjzQaJKUpsFmDXs1HoAeUvp+dZFwwQgyBA6Pymcl03T1xHDXwi8g4yjmMK3qAAD7yl4zimNAi9FYbGcSRJmiJ7vdzE38yfKwe87QvDBIIgwLZN4jikWqlgGhKloFgs0krzgVkmBzTBLKPZ7kKW4lom46NjrCyvUK27uAUHkSTYjqDeKBIEXcbGJkCk2HaBjQi1jWIMFwxCxXmvlMXFRSYnJ1lcXBwsSg6+7+O6HlmWILONBJ688BeLNo5jEaY5y8IrWPlnmEmWFhYYm5jAFJpOu0l9eIyiZ9PtttGGoOAWQYGWGUNDQ8j2MqnMaDbXyQg5d+QYJxceY/LFzybqdxmq1njLH/130tRnqCFYb2muf+pz+dQn/plGA5AGfqgwNGyZ3MK5pSXSVKHJuacCgUYM/h84Pm7+DJSARhkuuWQ/9933JI4NMkm5+NLL+M53vsvv/t5vc+TwLP/+xc9i2RLXKQ3grwwlU4TQg0UttwAuekWkyge7Uqa5kEZIpJIIDGzHG/i2552w5TrYBRclBQW7gApjymWPXDW0RgAAIABJREFUdu8UY2M2r3nNr/LYsfs5ceI4cSApOB6Zivm5W17Ik0fP0vI7ZNLHNhJGhqq0185hqBQMgRY2UimUTkiTANO2kJmJzBy0aYKQmNj0u73BefUQlkDJDKU1SZqbqKUy4YU338z2iV34SYHpbbuZn29yxx3f5aafeSF+d5UnH3uUer3Knh3TxGGH5187zbn5lOXZY3zri3eRZjGdTgfXdXFtZ+A5Y+D3I7pRhBVFVJwSXnWYKNP4vuaBex6kMjpNb+Uo5ZJLFMX5bsUs8La3v5cTR57g4x/9IO1OE4pj9JXHJdc9g5tveQE3bNnJL77xPfzde97Ec57/KjJ9iAfu+yb7Lr2cQz+4h+l9z8QqlZnaOUVUihjZVqHuFHAdRbk4wvp6xg8Oh3z9njv5h7/+Y6LuEyD28Na3/S4vvvllvPHVL+LWV9zMUMGg6cN1V1/L8dVT6FixeLSHsOvYNcnUjhq7d11FKk0euffbzOzYyd+958286lfeyNriuZwtErfQhmCiMUM3iPPQFASpSjFdaxCz+JNZ0j8VRXtjYGcYNrZt02p2yGSClgrLLlIqFTFEHkCQytx1rFqvoXTuxW2rDYaG3pzW5zdX3iHmSsDzna1Ms83OacM7Ogw1hmljGPHmwBPMgY2rjdTZZse60a1qralWq6ytrVBwHbJUbTrY2ZaF0tZGk4phghzYwm50saZpojKFbYIQebEPw5CODBA697BODItKNcfT9uzbmyd2p7llaqvVIor7FDyHOJZkmfqxgn3h53veWzzvBOM4l6nbtp0vXFrnjI9iESHy95pLSfUmK0cojRL5e0Ao3IJD1Ak3PbVLpdxPOEkiTK8ykHnnh+e6xLaN2nBFNAT9fo8Ti3PMrzSZPzuL26hz/NjjHDx4Kb3OIl4xQtDCNU2mxyZpDEsKrksmFetrHWZmRknSYHMY7FUskDk+L2VKsVjE83JKo5QS08oX+FLRxRCa7dMNFIJjx46xvLbKP/3TP/Irv/xqhGEzMjSJbRcIwiZpmm3SI6XcGFjmn6VGboqccqOoDCHyZoEBNJVlGttyczYSEAaD8GkZYhqwvrJEvery5S//C7NzJ7n965/g0CM/xECTJiHbdk6wsrJGv99HpgZ2oYBjC7pJkJ9f00BgEmcZmZQoLRGmgZYuppkP6rUWqMwiI6FcLiFVSpSEJHHMhhd4vVFn9+7d7Nq7h5e//OW8+MU38Zfvf5zFtVMcObnOvl2XcObMERbPnIE4JjI7LM0ewzAlj/7wEUzhM3v6hwwNFVFxRs1zwTToB518l9HNrY2l1oR9nyTsszR/losv30bZLtFrrxH4LWzLIQz7KAFPf87NXHX9s1iPBTc+52b++Z8+hBAWMojxF2dZWepx+SV1sqxBbfslWM4Ihx86hFGZw1Muh+67izvueJx3vOdDHDp1hov3P5VeqggWWyTDJYI4ZFUvcHL2FJ5XIk6b3PSKm1k4VaM3v8yf/clv8ba3/yXv+ov38DtvuAVfaJTw+db3vsp3vvYYv/LqGzFLFWS2QtJyWFI1zOxRnLom6Hc5euwo1YLF5/7lI1z51GtoNtukCQjTBvtxNFCu1sB0KVUrmM55x9KfdPxUFG3IO8B+30cIg0ajgV0QxGGK41QJoz5amTSGhllcWcL3fUwzzyS0LANDCTByZkdsD1gQWR4KvLHN2BDHZFlGGORc7DxNXZKl+ZASIUhTiW3JHMPgfJpNmipM8oLoOA6xVJuQQqFQ2Oxkc5l9nBcKlZIkGscBQ9kIDXGY4Fi5GMc0BKahCcIOrfYqWZawvLzIQtgGLRmq1VnspZRKHnv37uX0mTMUi0VM28YPw00e8uhog/n55iZufSEcc+G/jUUsFyh1qFQqmwvmhodKFAW4rgvkQiQA3+9jWRYFzyVN8oJo2y6dVjPHyVeW8Io2Wkm6rVW63S479h3Iee9+j6JXRWhFt9Pn8UcfpVKokUQBjx89RKIzJmeGEWoA3ySaZ9/4Qv7t85/ErgrSeJU4DRgeGybLFkgTH0s4pGmfM2eOMDTUYHFxAWFCpTJBq5tTG5M4xDQk7eYybqFAEOTvq98L2bNnB0vz87iOTRinDDUaOI7Lr732jfzqr/46M1v20eos0Q/WMbS1aYsQJAG2lbNqNAPxUah+7BrOZDKA2OzN3V/ux2ISp/lCbQoblCSNW2Sk3PaGVzF/9kluufXprKz0cNw673rf27jhumv48le+xtfvuIv7H3gA16sxMT6D1po4I/eXMRy6/TzpR8nco1wYecE2RAaZiec1CEMfLRLQBgrJ6NgYz7rpOezcuZN6vU69XkcIQRiGlAoeftfnf7z9C/zem/8LBlcxOXUT9eE6UXgOv7+GjNp4nsB2HOLIx1Qujq3Rssv6Sn5tSp0v0MFAlIQ2MAwLyzDoNdcpSJ+Z0UkWDz+EadrsvHQf0l9GGop//vTXOPCUK/jhoWPMz8/z0X/4IO8/cQrtTWAEIdCFIOXuL3+DbVOvhtoLuO4FB/jgBy7mT9/zh7z+Zddw6TXPIzz6ADc/93lcfcNzuWrPBBdN15l7VFI7sIN+6iOVpjE8g+du4w9/90/5gz94E+PlER4+Ms7FlzyDm2/eSnXKwyoZ/PHb/5F3vuU3eeYLX8Q3P/8pXvlLV/HKX9K87R2f4P3vfxv++iyZP0c/GyOa1WyfmWZ863Z+dM9DpFmfu7/1DWyvxC//ymsHNguSZrPJ6JBBz29RsTRRkt+rlXrtJ1bLn4qirbWm2+8RBCkyg25fkskQEMh0HbfooLMAmeR+GxiDlPQBfm2K8x11rkTMaWsb1qoXhhQ4joPK5Ka3SMFxB+5xAoRAiIGabVCwN36HbcvNoielJJUKy9Kbf78gZ1rIARyR8501jpNzgkVqEsuNnsYYMBX0ZnHdwDv7/T7FWhnXdTl16hR2fQpf+hSLudouDEPqQ8OEcTxggfiMTU7grPTp9fxcnSnycN4LO+uNTvB8koqi1+vhOA6VSoX19fXzjJdBkVLqfMHPsgxhmghx/jEb+H8/8Cm4JlpmOae74GEbJpValU47L5bJYIAq9+9n586d1IaH2L5nF7d4JkfnH2VueZGDOyYxLUUUBVy0fy8Lyz9CWJp+7OMUXNpLfYqDKVGh4GIYFo5jY5oiZ1nIHC6zLZder0exaKARxHGCUgLLcil6kEYx1WqZdruLlHkhffLJo2QStm/dT6fTIUsFhmmTDfxKtFYYIi/CGjlQ3RoX+NHozcdpw8AQ+U7NcWxs26Hb8cFyMU2bJApAZkxPT7BzxwyPPfYoQitmz7YRZoFLL7+YR350nHu+ey/33/8wZ2aXSZVCYFNwiwMNgksajzM/N4dl2qSZxDSN3B/EtMkwc4WkDgmCNsIw2LFtN+Nbpnjms66l0WhQ9CoUi0Vcz6XZbOL3cxZSv9MdzDIsHv/hEvv2byP1NVGhSRSvE4VLuHaQK3NTG9NwkIkmTg1U5iFMg1D7ZDEDKNFFKYjSPIdUphJDwKGH76ff7XHgwNMYHq/w6U99jnK9wAtf+HM0Rrez2urz4AM/4D+++EXWTp/EVDGXPPU5HPrel8A2IIPZs0eZPeMzdN1BQlNjnZvjh3f+CyZ9Dj3wBQxVxPYyHnvi8wTrPS7ZPcp//PvfUK2NUq42kFpiF2zQFfprr+eB73+Z7sp2es0TrPQjjnzqIarVCq949fMpFwMuu/pKvvvVz3PF9Yv86ZvfzgtuuZ4//uNbec1rbmbbxBRCpqRuBylhftlCaZOxsTHOrWTs3bubdrfHXXd/l4v27aJScCmMDTE0XMNzBMVSgdrIEL7vY1g/5Zi2uODidwsWSissXcA0wHGqKOGQhJo46yMzyNLcvl8rE2E6aNnPsS9tglRYVg6PJFmuVEQLiuUyWZJsJq5vYNxJkuAVC/T7XYrFMlKy2cErpUBLZJrmNzcbae4WjpWhBtzdDbpYEmcUvDKOpcjIhS65s15IySlj2VDwTLLYIg5SSiMCEUt0luI6Jn3T4PFDDzF18Hq8cp2JHWO0fE1rdZkoKrFlcoZWq0O71cewLBqNIlmsGR0a4fHkzEDW3r/AMOq8ydWFGPeFhWZj8dpghMBGsMPA4F+AaViDDlGAKTAEZGmCXfDQSjA6PAIiI80i2s0mmZL4vo8wXYQw6beWsae2sLy+TCGDklcmiELe99fv5b/+1m1sKe9lT+1Sjp99hN27n8KH3vs5fv+//R7v+B9fZctUY7ArKNHrDOM4EIQxSZzDOdMzI7Q7c4yOFomzmFhZOIBhmmQIHE9hWQW0D2HsM71lC91mj9FqiZtuvZW3v+ejWEunsWz4v9/6Fr575/e45+4f4Dg2QdjNobJ0kISkN5BzhVLnB4650kBuPkapweqsFSqC0PcploYJgj5J2mPPRaNMT42jSVhdOYaUcOrsAs94+s9z84tu4Z3v+O98+1v3k6VxrrjN8nOXC5YcKtU6fpiQZoKFxdZgAQ3JYonGpmCVuf5pzyBVAU6hwJ6L9jA1NUm1WqXTauJYgihOMUREP+iTpBGVcg3DNGm2WgxXhykWSkTxGRYXjvK+97wLIz1NUQ0RdpYwU4WSA0OyNEWTUig0CKIMTUoSRrmFbpaLhlIhcqwfsAVk2sYpjuMVXebOzXLk8FGwOtz76BJpbYjJks1bfv+dfPJj7+A5z/4Z1k7di2nYSAySYJnq6F781QfJcHnw8L2Mfe2zPOP5zyLpRJR3j/CZT36Siw5cx/btExw7cZgonqVglJBejR3bZ5iozzAzPUypvoIfdikOj3Bw70uIeo+xd8Ji25gAXWWiVkCNrdBrnyHrXsfHPv5Rdu8YY+/OcbY0unzwva/lF249xukzEVPTNXo6wEXjmgUGNo8szgVIu8DO6UlW1kJ6a2tI1+HLX7uDFz//Go4deQzXEsydOEytVsLXudI6Tv/3vEf+Dxz5UEfJFAwTyyrSCzrYQtNrzpJokzgJKdgCpU0M22LL1BR6EDNmmxYKgWXZSGEh0chMUxI53U9niiSIMW0DU+TT/A1/EG2wGSSbu8vlLnheIS/qG5avrjDRA86ulGqAX+ahvkprTNPC9WxMSyANhZQax3UIgoSiZ6B0hEw8wsjALIREsU/dnCbLWsSxj+sUMeOQ4ydWmHyqQZceTjiJFbUYn9mGKQyOHTtGvV6nWq2yuLjIjl3b8byY5to642MjzM8t4TjWJhR0IZa9cVxoW7CBq+ehEOW80A468wvZLplKkEqgpA3CwC16WJ6L70c5bBD5eAUHQxu4Xg2E4tzcYcrVGmPjU3Q6PYLuBKePHeG///ZvMjG5nXa7Qyvp8Z17vsu1113Bk8eexK2MsN7scm71LN/+/u30YwO7Z9MPIkYmZjhy/Bit+TWiUHLpJdtYXV1lZHyUYtmmUhumVHYJOucY9upkPYlQMb3MoGAYdPyEKy/bx+LZ46iKw5lAc+e7P8ZTL7+Ew0eOgl3mbW95K57nIYyMIAwBjZLGgO2jQcjNXdX/2/1BweAa1GqgzpUSt2CQCUkQzHPwiv1MTU3S66ywvDTH2noLKWF9NaBUH+H6p9/EBz7wAVYWTiPEedbR+fOVcnp2lYOXb2NipMrE9CSj0yOcW1zmzOlFxmsz3PSC5zE+vZVev8ns8aP0mkukQcDhw4fZc+CSnK0SdXALDmudFmmakkYRfj/EHOy0+v2AubOL7Ny3lXe8712sLDQplAVe0QDDQipFnLqoMHcrNHVMHLQYoEAYhoU2NEJ4oCXFkoPv9yiXGkjbo2jWSAOfMOwTh10+/837eNGzL+VcaPL2P/86H33v+9g6fZyZyTIiW2N8aIj1dhPDLfHkD3/AjiuuorMG9Zqgd+JHHN35FP7kttfy56/9K/qnDRrjJZ44+igXXzbC2TOnsE2LIFzi0iv24xstFvuLiJZib22cIDXxFwvc9Ns3cv/99xHJhMBvEvXaPP7wQxSLBVzH4c57vsz88kmk6uN3Y8YaHt2ez/aZEb7/3a/yql96Kd97cJanXzlDlsXESlIsOmTKw1PrzC5GWNQ4eNVBXK9Kcd8VPPjE/UzWxgm7TaamprBsyYgr8Eo11jsJywvr/2m1/Mmym/+Dh1Ya01DYRkqWxqRJhmWWKBYrjIyUGZuosWXLOLVyA8vKGR2WnYsg0jRBMghWNUy0IdAYgy2ztbmFl1JiDSLHLuw0XddFqtxDIsekzz9+Q0wD/BhVbqNLF4KB2MbapINtwDEbUIRSDDrxGMNwkJnCMCVREmKauROfyjIsxwUC/LUEy3ORDshAURIm3X6I7/uMjIzQbrcRQlAqlej1ciXj+vp6jmkOXhPANMUFA9WffKRpurnzuJBhkr8PidYSDL05xDUMi1RmpCpDKkmlUsErukg56NiFIvbbkPmMDhUplTUXX7SVoLfC7t3buefBH3H3/Q8wuWs3GsHd991HwbJxTYskyrF2Rcyjjz3EvosuZnGxzdm5WdqdHnGS4YcZWpist1qYtk0YhjSGh1haWWZ5qU2rGXJufpkwULRbAYGfEvkBrgm2FhAqXLdG7q1e4NATxwjCFFdLtm3bNohXy0UYhnDPX6Na/9ic4CcduWgmo+A4WKYgjnykDLn6mqcws3WEvr/OyuIq/V5MryNproUIYVIpDvGlL36Ssycezs+fAVJuwHr5zg9gYekcC4uLVGpVMqAxMcGu/Qd4yhVXM7PnAMJqsN4TXHzJU9m/dx8WGpXENMpV1tdb9HoJ2iyQZBq3UKRQ9PBcD1OYmAg8x8UybCrlGqfPLPDIw4dYXl6kXCsSpT6m5ZKkMegEZIapTRzDxnNMSp6NlqBSgVI2tltEiFx1OzE+TZCCKUoEicTOMqTfZNeBPTzvWZfzhDI5MneWj73vbYxZIQWzR6Wg6PtNZmamyCQomWKKPIMUbRF0IqROOfnIdyGTzN73PWzTIbQtth+8mufc8itcfcMtPOcFv8Wtr/ozCpUJIim4+OCLMJydzC05zM7VOHVGMbplD0eOHyHSAWvrbRy3RL8XMj+3RKnU4NSZBdLEwC0PoewKvVRRHR/h1Jk2v/CqW/jFX/5NbrhqJ2/4o7cSCclSmPC3n3oIbViUxy8iS5cwMslDD9xLv9fh+3fdS310GsOuc8UVz6DZ7COlJopy/UQc/JQPIk0Djj32IO12H9MqYzgeUZzgOiZx0gXDRGQaG4dESRwD/NBHAFLmF3eSZMSRT5rZGEKjlM6xIQOyRGGbuaXrRvdiGIIsy2+IjRvS8zza/QAl9SZ1Lo7iTQaJvkAdl3OeNxSGNlEUIweLQJpKhMkgkzFnkJjCQqUGmcqwDQiCgDjpYuoMHaW41SFkZjF3+G72bP89EB5aS7phgFErkGYhmYwYGa3T67fo9tq0uoqCXcIw5f9D3XtGyXWWabvXu3Plqs5K3ZJaOdqWZUtyzjgbe2yDMQxhAI8Zf/ARBhjPgDEMwQzDEM1gGw/GGQccsY0zTrItWTm0Wmq1OufKtfN7fuzqFnMOzHfW+cWptbS6V69Sd9Wuqmc/+3nu+75obmxj3rw55AuTBGGkVJk21QB/ttBMz7nz+TzNzc0zBT8isPwJWTyUKFpEh5EoCCVCs1mGhl0Zje4fOuRaGli8ZCGZhgyjE5PkpwoElSJHRoZoamyjbLsouRb6+kdoGy3SsWgVhw/tpG1hB07oMDDYiyqrNGV0Bg4P87nPfJE9O75CIDSWrTyGF198Kfr7QnJkoIBhKBjdfcye00m5cpA1649ncukQtaqLqR09gWYQxJyAjUuOZ/dYgm0HDxHgkc5Z1EpVpNQpVmsUevoJZaQMUVUdVdHqWmw5MwY5eju6gJzmRkZXYdF7ynaKCCE455wzSaVS9PUfZtuWfZSKVWrVEq4rZ8aCihJQLoyxY/gQuqrj+Sq+H9DY1EJrazP79+0hDCWGbuC6Y2x751naWps44YTTKbk6CJ15813SuRjxmEHVsbjhU9eDX+Gsk9eRsEx8p0oyYRHUCrh+RGkaHhpGkWHkmmxOEXguXhBixS0MPcFP/uXrBG4VNwhItLcya3YH48lWYrHDDA30oKEipI0T+oR6nHRuFiuOXU9bawc73n6dUqGLxkwjGlAo1JjVNpe+gX5ICIpOgTAMGHMdXBVeu+sAn/v4Saw7sZ3CZA+jQ5NkkhnkxDDxdA7T1PE8n0DquBODQIZQ+miqghJfwPo1Om1r38fYoSPMS7TQs8/mmYdVWjJX8fgjfyBEMLdzNb3dm9i95SCp2CaS8YBcJqS391ZKBZOXnt2CI6uM9A+ycMGyOtu1zEmnn8qPf3gLupVj1drjGTgywkDfLppnNXDrrbfROX8VAwO9XHjBhezeupl0KsMvfv5rzrvwCjx/gg2nfYTR/p3YoheER2/PJE2NggP79tKaauHdN95m2dK5lO0xcpkYvYd6iCnGX6yXfzVFu1opU6tUcfwawtCw7Vo9s0PDtm0C26YxncNKpnCcGlNTU0Bku5UyRCjqzOw1DBSCIKwrKQShMj3OCLFteyb/WlXViB3JUbNJNM8NIpNIIhEtLqWP7weE9YWhpiv/LedD1pUkfzqKiEYr1MkyPnGTelaFiZTREkdVTcKwgOe6qJpFGOrAGE0NCRRP4Md8HBGSNnSkEqAoUK1WSCQStLQ0M5mfYnSkwMqVHZRKJXK5HMVSHsuyCPxodDOdxvXnivafZn5Pj1OCIIgMJXW9OhzVeEsRPSchJSKUOLUKUjooCI4/diUN2RSGZTEyMkJvfx+gMDw4TktzC1NaHivdwFTNJh5Pct+jj5NrbeVw9y5ee3czKzoXYu/fQ9JMYJc82uc0ogQBZ5x2JvmpEq2tIU6dNBMGLhJw3JBKrYpumqiaxsRoiXd3bccuRa5A3wckdGRTLLAS9MnDXHnWpTzxi5sphD6vPvcSzz37Il//1i0s7Gin+9DhOm1mWnMtUcRRxY2sK8Aj/fd0KFQ0455+zaeLezaXor29nWwuwZ49eyKVzVihngMjQQhCQlAEqmpQrkSGkjD0UTULI5ako6OjbiCLuJmu62IaGo7r89of/8jYSI1TzroCTTdxKLHn8GEaUjmseAeKFmPRsk40K9KJm5ZGcXKU5rZZJBNpDN1AEyqKUHF8l0q5BsKP9iJOjZdfeh27ViNKV4Z8qcpcI0GuLY2ZUBgYPBw9VxGA1Djt7AtZd9J5SL2DA/v7UNiBYoCmSybH8ijEGR8pElMUavkJPvSlG+h1ihi+x49/sYXGxjmEMo9T0nDGfQzTpFL1aZvVwMGewzQ3NTM8MERoOMQUC6+xjcrUZswgjjs+wk9/08W6s9fxu5/1AVlWr1mIp2ucd/75vPZON7mmBhYtTtM2v5HGWStoTLQThpPY5EGFn9/2c8bzB0CVxBMGQ8MDOFUPK5ZCV5Oo8QYsq4GBoTwj4yWS6QwHew6y7rhjONJ7hM4F8+np30MyYWLIJJ/+22sIwhpTns+7r9zD+jPm897b3wM1hZMvYAmf2Y0Z8hMF2hctYfbSNkaGDhBWxmjMZsiPTaMK/p+3v4qiHUrBae+7kKbmueSnKhCGpDJJuge62Xd4jMs2rmNgYABLUdjy3lZ0oRAzLSQhnlTRfNADgdCjwhz4MlooSonvR4V12vloGFYUhFTP4YjGJ5HdWgRBlDVBNJdTVRUZ+vi+F+VKyGjhFPoK1ao9Qyfx/Cjtr1arIU0LRUYLlwABMsRzwVVA4kfUGjQmJ4q4NRcFgasUWbJ4JdteeRAlkMzvWMC8pmUc6Hk+moHmR1BVDSkjuWGxWCQMQzKZLMl4kqmpPGYyg2lpdcxWlB0tRJRM96ez0enC8qfLxzAMmZqaikK3PBdTi7I1mM4NJ/rq+5G1VniS5uZGli5fgVBCKqUq/QN9DI2nKJaqIF1+ed/vGBg8yOzWlXz5izcwPDqBkh+nYV6KYmES08hy4okbOdLbxUO/eoCPXPshjgznqToKgYB0qoGHf/coZ511Dvc/9BRts5cS7T48FBFBExShUMhXaWpsYWJyK6Y5zBUXXM6ixQv5+R2/4rwLzmfJwiUc2r2NB37zKKccdwZ7yhp2KPFR+N7PvsPCBcsQMmCwbxCBRswyqNnFuoZeIZTT1KFp9tBR2EUQeEjJDLU+DGHuvBYamzLMnjWXV199lfPedxrfveXrdC5Yh2W0UnNHjiqchFJXNjn/7bVRVZWYYTI2Nsbg4CCmZdHU1BQ5SqcmUYVGSzaO9Kb4j+9/HkXTaJ69lideeIyJvgIXnPx+nnj3Dzz54AMceO8ljvSNEIYuV1x2IfsPdfHrO+6iavusWrGExpZGVq9aRyxpkM00MFmY5OZ/vhECj0TCwq1GC8TR0VHefvttLrvmWiqlTuZ3nsrAQB+2KNPeMo9lGzdiC4OHHtrMwtblNC04meHXd1EtDaDSQktzjqlSmVp5nMAPGbZ9ZpvwtR+8zPdv+RBOcYof33YP//pP/4ukHqdSc7Asjb4jA3UJcI7GpjZ27upnaPQQj+7Mc/mJxxGrlpGlvdz5kxv5z/vu59VnnqV37xC26CHc/DZLF8UZ63+U0cH5LF9zNgMD+5kY2UE+3kVQmSI922LZcZtoX9nGr+59nJv+5e85cmCUlpZG3GCC//jZf3H/PXcTlD1cOUEu3cKeXXtJJmoUpqrs3H6I+W1LGB3sZsESEyW06JzbQqkyG6EbLFy4hh37N/Pgs//Et7+0mDt+8g/Y1jaUqRwjkzqr125k5863OHLwHdrmz6HJiFEu2pj/wwjur6JoSympeioD42VimkUYlhnsPsh7297BaOlkYHQUT0piQqVUrNSxWuFMprUIps0T6p90vNGHSVVFZLio52lAWF8iRfIszwvRdQ2tbsDRdW0GMuBbBrpWD3+qf6CmZ7uqKvC9EF+vgxGUo5ivoyaeo4gsI6YTuAaaXmcoenXjiYhoJsIwQWqE+FQmoaNjKcO11xgYGqJzcSd+KCmVijNL04gEiDHbAAAgAElEQVRYY2NXa1iWxcDAAKYZJQ+aph51mYR1y7n/32btcLTwTB//KGTLiHKk64VD1wN8TxJKSRh6KCo0NTWwatUKNE1jbGIUL5SMjI6jJS1KNY3Tz7qA08+7GDWWoWanWDArjZ5oo7k5DoTUCgVSlsqSxW1UxqeY0zKPnf29vPTy65x63vkIQlz/ZQqlKvsPHGbjxlPYu38bq9dvQCghpqnguQEEEqEIyuUyXV3dBJ6PE/g88sijqAJiVpJ7bruLZDyLKqJMjVuevg+Px7A0HRBsf+89XvzDq8hQUAtq6GoS13aOHqfpKwsh6u8ZgSTE0PWZQhvNmkNAwTDhhOPXIxTJM394js4lqznnwgv4/fOvcsLxJ/HeO9vQlQRSeChK3Z4t/xQEHH1QXafGpFOrX/mBbqjkC5PR+CXUUFDoObQfRTmArml4dshY91s88fjrSDOOVLp57JEneOfN19j/3iv873/4OPv37Gb+wg4ef+JJRkYGEIrCm28OIRSdHTt2sXjxUtafeBy27YK0QdWoVGrRWE/6fOumb/DaG2/jOB4Ll61m265eMvPnE0wVaF60gGLBYe/hg5yx4ST2dxewks1oKYumlkW4Uz7DE3lCf4hPfe7rjAQhFUXylZvf5Ac3fZn5x7v07faY13IiI2OjZDqzyEoUftbUkEZI2LN3D6edcirI6Lg//ftXaV2wismu53A9DeXQQTZ2+px+yfk88cNfEdoeqmYzMDoEMgfSwqKZ4Z48ca2BamkCRTGpTbk0rWzn4Tse5ec9XXhyHIU0AgvPKTEyOMLWrW+BEhLYFeIJC9PUGe7bx99/4Truu+8Bcg1pNLMJIfOYumCy6qDKkI9c9Tnu/u0P6O0ZY+mC2fzyRx/AFaP85pc3UzV8claKCb9A46LlmIFFpTKKlUthKA4ONSD/Z+vlX0XRRggCEWd4pMjQvjc5ZnEHjz/0AGFMZ1HTCrr6Jhnv6+fs0zaiWDFUTSMQAaEMccOQWP2yPgxFnYwNpilm7OcEoNeL6XShmumSPS/6wGhRQpvv+4QSYqZR78KP4sOmYbOuG2mkHdvDcdyIlqPIGVehWl/vujUXK2FRq3oESojre1TtGrG4QrVWxqlVo2CiwMXMNZKatYjS4D5qBZg3fwXd2xzmLeykt7ufquuwYFE7uu5Hi1gt0pyrQqnPX8tMTk7OGCRyuSRSHk1EDPyIDv6n6pAwpN71RZffjuPi2CG2jKJls7kUC+Z30tScQ9MUBgf6CMOQI0eOEIYwODhETaosWrKcTWefRSK+gOXLV6Gbgre39nBw+3Zu/Oy1JJuWYedHkKFHwoozWe7irDWLmSgMsnPrm3z+a/+OlWpGSbaSTljctOwkfvGTH+Awzv2PPAR1zqIMfQIvrKfARQFjAAcPHkTiUS0Xqdk+OtCSsqhqMdTmDGqpSqVaxlM1CAKqoUPD7CYa0wt58elf0zFvBUkzFpVe1aRctesa92ieXTfcoggVpMB1nLpZPtodzJ8/h7POOZu+/h4effRJFFUlIOCaD/0tY2Mmr73Rwz0PPszihXNRdJPQiYLuZ+zt/lHn6PR4JUpVHCebyyGEZGoyj25oqBpYhka15pFtSBNPmrTMamPLtsN854bLCYQKikfXuy+AM0GtNsVjjz3GyMgIDz/1CCLQorz3wEdTDaSEifF++np7eOEPj6FgksnoFAs2V197Lbt3HySeSmJ7cPIpp7PlvXf4/ne/yfWf/TqVSo3GVBt3/eZR1ixfxtUf/gSf++T1bDz708SzWXzZhB9KkhnB5OR+pB8wIWxySB648wA/+c77mb8iiVIMMeIml1/awX33/ZFrPngKSxYuob+/mwIlQuHT0d7KSy+/RjqToVgwee/1p7n4qo9y1zeeAs1DlsbY2WPw0LeORXxnNzFd4noqj91+CwsWX0Z/Vx9NLXPZvWMnaBNosorvOwgnziWXXcU/3nAbptCQUkOhzMRkDaTClrf/SGFqAIiUIE8/ey/JRIaLLruaf/rydzlu+RosNSRuCZLxZvp6BzjzzL+hMGWzY9dDLF3SzMrFq1DMJG7lCP9880eYnHJ48q6vUXJM7PAIze3N9A/3EBZsto6onHrKevZ07f2L5fKvomgrAkQYEDd0cokEB3ftoFEYvPvOTpYtP4kDhSqtDU0kMjlKNTvi8NVVHY7jkIxrqEpUjFRVRda7lhl7cXBUQTHNeoxC6I9a21OpFK7n4QQyiqeZAftGHbSq66iqUs8HiazBihoFBwVBgGlYkRpFN3DdabkdhF40D1eUetc//Rjr3a2qqxEbz4ihmWnS6RilqZCGhlkomqRcnWB2WyOhptM/MIhlWaRSqegDr2mUaxWEcGlqaqJStUkmkxSLRWq1Gp4XzDxmgZyJa4Vp01CkXolOTAG27ZNKWbS3tzNrVivxRBSEdbjncERl0XU8N6BQqJJOZ7Glwd333s9kweb4DSfxzJN/xIrFcB2HW750DSoOqdZ12PleQreElCElr4yl6LTmJIWSRBUmNREHI025rFKoeSyfu4wrPvgx7r/z3xkZHaWxcRalUikaUogoVMe1o7GXqkSqAtNQsBCYMYNkzGLBok5WNDTyyhtvUZ6cwk8moOaiaw5SwOTQJG/2HeRDH/gYghBNMyhWK4QyrL9GR3cWYmYvECKJDFmeX0MAGzasZ8mSJbz22mvs23uQe++7kzvu/BUvvPAuX/nKjQwXh1i+/FhuvPGrKMJAFxJXiJlCPcOO5GjcwPQVoaIKdF2lWCyCAM/1MaSC7Vf412/9bz728Wv5zb2PoSkJBrr+gzG7gsSAwOdjf/cJtrz+e470bGXv3t1IAXo8hq6B5yuEjk8Q+kjpUylTDzMCXReUChWQEUYtkW1i0dJlxBMZHLfGRRecjQxq/Oimv6dl3gpGe4e57c4fs+PQEA/edzcbzzydcnmYjNmAoacxDMmR/a+QacxQETBUUfjJL3fyjS98luUdkuEDI+SyFmohh2HWmLuilU///dd46IH/JJFMkc2YFApTZNMJhDLCksWLeXfLNrq2bue4tRfjSgfNVzCycQ7s3ceeBcvAaKbm7kKIEhW3j5aOJg51vYNhaAwNHsRzB/G9PLpiIIN+knEN/DwOSQTl+tUpxOMN7N8XoW9jpoUTSHKZNKPj/Xz2c4/w7lvbaWrOoisO1UqJgcE8zc3t1Jwqu/duo1opMHdBO2tXN7F92zZee2srx5x4HA//+qtsHArY/vo91MpDTPRVmdO2gkl9iloxz+b3drB0+Rq2bf7jn62XfxVFGykpTYzS1z9OzK0yOTjCzl07+djV52JlDQaKAQe7esivXEHMSkaX7kJBSLDUeuerRrv9CFqgoaga5bJNJmPi+i6eF1nYwzAaZ+i6Vv+qz6TfRcs4ie/5GJo+s7C0bRtVRpeztm2TTiUAUBQfGYakUlHOhpTTy7/oRZZxDdd3UBSBZ3voagoFgV+n71SrVcKUjoJPKptj+ap1bH76bR5+5D7O2bAOz4FU2mKsL4+VidPWOptytUb3wUF0HRIxC8dxyGazdTeoIB6P9NapVGqGgRjN7+txSvWiED13wfIVK1gwvzPSVg8eplyqUi6X6O/3EHVKeXRiklSKNrqiY6hJZKgRV5JccdlFvPFeDzff9D2ee/b3XHHR2fz27juw4o3Y1XFKw1tARtkrMoR1xxzHvve2Ui6PMjxyhI6FC3CtBL1Dk7z++uvkx0e4+Yuf5n2XfpA3X3iCd4YGWby4lfzUIKefdgxNjTk+8akP49oO3d2H6D4wRNf+HoaHh5kojJOc3YD0A3zFZ//ePTTNasVo70BzTbr27sInz+dv+BDnXXwZhsiRjOtYmkVzUwPlwSoyABlOG40ipcq0aEQSYFkWEli/4URS6ThdXfvYsn0Lg/0D2LbHq29s5Qc/vI0DB7q57NIL0VULFZBKMsp1tyMtfzyeoFgszlCEpj8Huqbj+h6mbvGJT34UIQSHDh3C933eeustdu19gtbmuagyy/atO7n9579meGSColPGkBGtxg0ln7zqVHwRsnTpWibHBmnv6GD5cRtJxOIk0wlqlSqpWBwZerQ15ajZJd55fRtb33sDRUJTc5LNb7/DgWGfk869jEQmC/mAAzt2sXx2jjO//VVyDcu49lOXsfn1bZxw9kZ+cvOXOfGi6/G0KA5WUxPkx/P8+y138LkvXI0IoVJS0JQd3HbrDVx33ZUsaY6TzrYwWRki3lrm1LVL+MV/Pccvbv02iZiBRhXLshgfG6C1McnEcB9nn3EeL7y4g5defBI9Mws3P4xenOSWb9zEmk0PcPMDP+Zr7z+VZGuOSm0+Z593CW+9PsaaU9eQeWw142P7QYwT6mVCZ4LG5hiCLMQTxLwATfqUgpANGzbx0ovPYKhJbLeIKiwmBw4T+pJ0wuD6v7uJpqY0PYe3ETMSnHzyubiux5vvvExjJgW1RkrDPmq6iyUrVU7ftI7OJWfz6vZHePW5m+ic9wRTk5JKsZdaZTtNs+ZSmVDxNTXibP6F219H0QYSusnKZSsZKR1Bm+VxzjEaiWwDA7u7aTLiLFo2G8Iipu5SKoyjqzEkChXXIWspKBqk0pmoQHkVPA+SMQND0cGAquOg6xpmLKKy+2FA4EWXqZqmUaljyTzvqC3e8zzcMOqINCR2OK2fDepuw3oAkO3UF50h8aSBpqqMTuZxXcjlkqi+h6EmISyhKlo0GQ1qhKGN6meJaSrV2iSxdA5TbWBg5+/pXjiXkXFoS3vEE23YXgXFgkQqhWWM4/shtZLPgvZ2cF3GxwroMQu7VMVUdCqlCpqho6kWvvQRWoDrRWaI2bPbWNDZRmtzC/ligZ7e3UwV8gShg6HHSaYzuI4k9FV8/6jCRI/ruK5PEAo8J5JUPvvQbj73pes4fOQ1RGjw8D2/BAl2ZTQ6bppB4EMy0cTsuR1MTE4iBFgxHVvOIdncgFdRSSoe55+4kpHBBp5/9CmObJ2LoSmsP2EVn/rE6Vx55dVkMgsJxCDvvP0eF1z4aXQ1TmPjPKyYQdX1UDWTRakOdnfvZKy9SNigUp0KsFRJrejSaDYyZudZv+kcLrnoaoSuU6iG5LKN5MseoRdGmddh3fkqQxQZoKkhTiCJtbXz91/8JoEsMz61g6cfe5Sxw6PcePPX+dd//THXf/FLPPb0Hk4+6yIO95Y56cRLIQxR1ASBn8dUJAEuIoBSsUgimcZ2qgS+j1BABNEuQgiVwFd45cV3aGrKMT4xiBCCdDLHbbe+CqpC+6JV7N7Vxf5DAyB8VEXFJ0AEkcLFI0CRBvv27abBzLC8czHVYhlHMVEmbPL5PLQpWJpAKCbJmEIqpUX4LxRGJ6Cslfjazf/GaWecSvfuHUyMjZNpmcfYaIVDQ30sSbSSNNr51W3f5PbbXRSRQRa76Fi0ge7dXWSynSRSKr997A1ee3sfne3H89KLr/Dutlt538Wnk2ucxcHxIdq0XhIZDbecQlNKXP/RC/jQR27knru/iRVL4FQclNClaZZPV1eZxauymAzQs/c1MvNWUcyPoYVVJt8+yOvPvsXKVceSmL+OZGmQ2c2ziaXzLFg3n3HXw2YxBAeBEVRiBIBj5zE1hVDW8P0a2cY2iuOjNLc1IjFpbGxmaKyML6OGLN0whztvvw1D7WNyVEV4GVAjXuyuXTtoa5pHvlxByZmEgY89LokbFkuXLWL/3ueZZaYY8T3ufv4Z3rd8LZqcRS4rCdQaatMCvMnNHN71/4M87VK1yKqFy3j9oefpO7Kb005axtbt+2lvW83pG05jMj9BqGgUKza6YaKp0yFNIOvLRc9zIqZjGMkAI7ldJA+bXggCM7QRUc+6hqiLUoReN9dEMkNHAdOIivr0TDsMmXFTOk5U0KeBroYhqdoOUoKmqWiaQqlURtej+WUsblLJl0mmDHw3snqnkwquV6U6Ns7sWa3UnBLvvvYIl1x7HYlYG739w8RVFz1lUS4WMU2dbCqN7/uMF8oc7O2lKZdBt+rRrXX+YcWuIVSFqWoREKxYuZg5c1sZGxujVCoxPj5ej6b1qNVcMqkc1WoVGaqU8jUcO4ikdGokCRMo1Cp5IshCNCbJZrP88zc+SqlcIZdeyFThEDKcUc2xdGknk5OTpFNZspkWPD9AT8WJdbbz0988wJx561mydhm9e3bwyguPI0q7IvFcaPEqGmCjm3Ddp3dx3ad/iiBAEQYdi3NccfkVeK7CE08+y9RUEdMUODWTwf5hzjzzCs669Epu/cXtGL4k25rlvX1P47ge3/3ml/jgBz4ajVmkR0vrLJyazXh+gkQ8Xn+/RPQUqUgEBpXARdVifOLvvsiRkSRNDc1otHLthy7hrFOP5dHfPciHLjyLzvZOvv3t7zA3Z4CqRzNxTcULIkOUE0aduyoUpBTYtlc3W8G0GV5wNHisu7uLffs8FNWv714k3/7Wd2loamT5quO4+KLLmTt3Ef393ZHsVRgEMkSoPoQpQik4/sQN7N/+Fs+98DIfuPoDlOwaRaeCH/pUCyVkMsbu/V20NubYd6CXMIhGJEL4lIcOcPsPv8Wbz69h6aIFNKRTTA0PYmgKG848k3Ix4JhjV/La231owiKgxNuvPwbvPEs2m0UzAroPDdDtK4CKngTPDtDjDbz03FaySYXzLzmHoaER9h84hCpUOuY0EoZw2fs38slP7OTD11xI3NIwzTHsskagTvDCM/fRPH8pw70H+OjN3+UHn9kcrdyVPv7tX77FO9uf5MRTTqJ78x9xpcPLT77Mxo0b6Dtgo2t5TDVANyBUAgwjx5uvvYliGTRkTJySgqLq/M2VH8Cyotc6Hksyu60dMxZSq0leemUbG084lpXL29m3r5uNGzbR1JDj5VeeJ5WIMzY6hhU3qdaiIq/HTLSYxf4dB/jav/wQVSS48Zbvc80/fJRL/+56Hrn9JsbzcbRJj3TLfhoXnctkaSeU/3y5/Kso2pE0LaRWLXP26WfS3Hwhd9/9cwIH+ibypMcmGBjoZ80xSzFjcaSM5tBIiQymo1ejGbauHgXVquKoemM6nnV6Sy9lOANDsCwr+j+qhiojY04YSmKxGLqmULPdujLkKPggGhtEM21FUSgWbSxLYBgayWSSqUJUrG07yj/RdL2uyhAzbkrpR+l6MgixSxUamhujCFdZY7DnIJWqx8L2ZrRqgAfoamTDx1BpaGhgvFQmnoozWSiwbOVyiuUSQkQSRNu2yeSyKIognU6zYEEHA4OHicVNstk5FItFypUaCiqOHUSEmqqPCMEPopPhtB1eqoJQBsTi0VVKuVRB0wx8D3bt2o1QDRRRwzAUYrEY6XSKpqYGpJTMmzcbzwuYmByiWI7MTrrqU/N8Sk6NUrXAvn17EZUJUAQKkMnFyWYa6p2/SixmUZyy6e8bw5Mu3QeG6e56GNOIkck2kIhDuVJEUVzCEJ5/+TFuvPku3vfQ1Ww6YRO+4uO5NV594wlOO+listkkhVKZ9jlz8bxIjy6EiE5aBAhUNEONMmdkQKaxgbntK0FN4nqCHe8epq2lmepkGelYNKUbyMySzJqb5cYv3oCihISBE01VlBBFMaNmQo2s7VJEUN8g8GG68ZARck9RlPpcPVpqhzJgWittGAauW2F4qMLw0CAH9u4hEsL4hDJakhpaAqnWaGxcQNET7Ng9iBrGkJRxSyViuoaDTxB4VMvghdHJ1w1DbCdC8fmejyIkpqpwcM92PLvMccsXoQQO48ODtLU3sXLVGg5297F//x6QEl/adQmji277lIdqSBRaZy+gdeFceg50Ux4fQhMaXq2MCEImaiFPP/YSiqlz4qbT2L1zOxOFcdpam/nox65lbGSUoaE+FnTMIVRqIDLoukBFZcXKtQz3DdKYW0p756kM9bxIEE8SDPSSNn3+5uqr+O4rbxFLZznUfZAFq89ChAJNVVBFSMzIMFYosGTFWnbv2UUikST0bVKpNNVqlXSqgeHhURKJBI7joqg6tVqea675JKOj43ihhxRQqVZpm9XKI799kAUL50Wuaxm5YVURkso0MDZe4EBXDz/++V3MmtdOrqmVb331q3zlC5/kP3/2z+x7Yxf7Dm7Hs4eZGhnBt+dQKo79xXr5V1G0g1BSqpQZGxlgwex57N62nd6BMp2LllLCZM/BXpAev3/mD7heBeoJdAiBooLvBSgo6HENGYZ4XoBmqChS4tazkBVdJfB8bNuvZ24LtDrtRUqJ5/ooVnQ4oojTKHZVWMaMPM7zQAiXMPSJxWJ1QEI08LSsqHuHaDmqEM6AbwGUujlC140Zy3upUqUZDy8MiOGiUV9+Cfj9g3dxwinn8fZr99LZmMLSNUo1B4SC77uUylO0NmcZm8jT0tbMrj17CUNYuHDuDGFnfHycEzesp7GxkaHhI2g6jI4Og9TQdYv6HhK7FuA6HoqMEYQKZn3JG0ifqlOlUilRq5ZpbWpG0zQWL2onHo8kfKGchaqbjA1PoiAoliYIgoC+voG68QSEVKh5TkRDUYlyuf0QR4WSM0FldB+hP04ck5CQ0kSB/MQkmiHwPIlhKbh2iK6nkH5dtyEU/NBjZHQARYFUWkOgUq64hGGCM05ZCDLkF7ffz95dWzg8nuPUTZei6GC7NrGYycTEGLpu4gduPUrUjVaOanQ1tfbYpSxaOIehUUmhYiL1Zsb6XicWS/Ds7+8mZukc7LoHwhJXXfoNBroP8MLzD3Dnzx9g/+H3GCtJpkZLVGsuoQghjKSGQWgDGigqCpKQGoqQMwtIVVUjqEF9KTo9nvK8o9ZmRSgMDvQilHCmO1d0nVgyR6GskG5bzNLOlZx+5rl864ZrQKR5d+t2OufPYrxaQ1MNrFgaVdewzBRVt8pkuQyKSswU1GoeTqDw6KOP4IeCw91d7Nu7kzPOOZcAl3POvYSeg/vR1Tiq1JAKSOFHcAyh42tNHD50gI45MXYftjn/kmuZmyszcrgLLTfF6GQeJYjhBjVOOvYctr13iPMuuornnn6QqZpAV6vELYV33jzA+g0rWLK0iYnqEG1NbfQNDLP51cc5/8rP8NJDT3H1Rz7HD29+C8Meww3yjE/5XHB+juv7xmhZVGbqQBu963dzxuKVxE0fQ2nBcfoBuOCSa/jZL26lQY2SG4UIGZuaQqCx+c3NWIZBIpVEUX327e/h09d9lksuvhIpA3r7jvCBa67mnvvuorEhS7VajjT2VizS7oc6e/f28vkv/wtnnHIh55y5kdaO+bQ0xMmlUnz4w5/kll/eztZd95MQDWhKBRMTXdtHevZxFPtf+LP18q+iaCuKiqYINEUhm84xMV4kk27CdkMe+d1vWb/hNNYddwxrNm1i2/YtlEolZHxauhZ1KWEY/Z4oR0SdSVybdi7qhoFUNUxdretifWQQUq1W62dTpx6gpNft70pEmdBUFMWrP04wjOiQRWOVaJkXhpEV2HVdqNNqZChQ1PrlsFqXJPoeQtMQisDz67Z6LST0JLoSEnigCI1QCent3sKyY65DszJ4gYNddFAMk1qtglAVvDBSc7Q2NzAwOMaSRfMYHByMxjqOR4jEtX2y2SzDw8MUCgUUNcoNN404k5N5UkmdWtXBsuL4nkQROkJRcBwP04zgAV7gMWtWK5nUYjoXdFCYylOqlKlUSoTSY3xsAl3XCQMXpxblkGuaQVhXXgSBhyAgDCWBFBCEhF4IqopbK6DICFvmVAvIwI6OqWYS+DYSQTxhUK24qJqC55dmXocwCOpadAVQqJR9wEc3LJyah6Ya+GGZ2//rO/zHj37Kycd/A11P4FEiHktRKpWgno8emWTkjJFIMzQWdnawavVyBgf6GDicJ964gGrV551XnsQeH0TRChSCgOF9CiohX/iyy4mrjmftqjmEus32bX2EqOQamuhcspqO+fN57OFHMY04jluONOB1qIRhari2F6HywgBNMzAMEyihqgJdN+skJFl3+epRARcKBAER8EOC8JAiRNHioOsUqw6VUAU/xLSSHBkeJNuYxDJNYok4sq6MOvbYY1mwqIOnH38Ut1LGcSI4sQxDfnPvPRw40MuunduQgc09v/0tjc0NLF+2mp5DXVHGjapR8zwIQRXgS4EaVKiJkIqAKz/wD/R1PcfsrEVj3KHmecxtzaI5CsMjNXbu3El750p+9tP/YM3S5xgdOMzsDov8VJVj18/mpn+6jfsfuYV0toDARcGkUqlQyY/y7rsHOG7TenylVpd8pHjrtREuvLSd9mUX0tf7LAKdvbt3sWnTuVSrNm2zFoKqUT3SxQnrNvIT56cUZIF5bQ0UayUMw2R4KHIk6oaK5zmUpibR9QT33nsfPYcPoCmwfv16/vCHP9Da2owiBGE9V8PzNVzPY+fug6xZs45NG87guk99nHRjK02NKXZueZM5LW08+uCveeSeX7ErcFi55v3s2PUrNC1BsTBFczZD8S/Uy/9j0RZCWMCrgFm//0NSyq8LIRYA9wONwBbgw1JKVwhhAncB64AJ4Gop5eH/8W8gCDyPVDrG/Q/fx1lnnkv/eB4Pn5NPO5Xzzr6AWFwnpktMRUFXDUwjkqnpOmi6gu+FOI6HDHzipoKUdfxXXe6nhiGB70fdXhgiBMStGJqmEwYBMctC03WK1epMyFStVkNgoghBEIboOvX8kkgLHbktxZ/ABSL9czwex3arKHWThmmaEa1cEaiKQKBG5BDHQ6IQhi5aNc9Y7SBqzEJxivhUWX/C6bzxxusY6lYKeRtTGpi6QSCh6rqUKzWSqQg6W6mUSKUSdfJMDTkJCxfOY8+ePXUepiSVTjA5OYkMqySSOSplB1UxCfxIF+x5HiKMslL80KO1rZl0OsXwSD+lwgRvvnGEWs2uj4QiQoymaPiOQxgKfI96LECkmZ8eRYV+QCgCAlHP6fBAEFAYHaM8ewIfMKxGyrU+kCEi8JEozFu4GrdaIXCHMMwEV15+Kb9/+VGG+sZZsXoWw8adNIkAACAASURBVEPj6Eoz+XwBxy9HfETbQVFU/KCKosI55yxg65bfka+V+OgHvsfjT3+VUs2mff4CROiRzaVQdQtFMajZeXzXY2Bkgv7BIQYGD0Wju1oSM9vGjq1v4k4MoSsCPwDLUNBViWHEePv53Wz+ww7coIJEsmLlUuLxGDt3HmLbls1s2/o2y1aso/vgXs4993LWnXgia9dt4vDhLr7yuU9jGglcr4KiqniuQiyeI9ukMTU+RjxpMGteO7pm8cnP3sitP/oxhwZ7oJAH4ddRahoilJTyg5ixLD37d9KZzKEENU666CLeefVZZs1Zgq8Z9B8+iC5M1h6/gXQqzS9/8XOS8TiVqanoRIZRNxMZXHnNRzCNJOVKjYnCMAP94yhekdFSnouzVzM5Osm8Bau5/467UFHQ0xazl5zOynWreeCpQ6xcHOcHt9/KH5+9iO985QoWZBIEqqRsl2hQdBpmmVQrJXbvepkVi1dQzvdx5cUf5cln/hM1BF1PcMftT7Ovax/pBoNGS2PJ0mYO9Qzw6nN30jp7E6+8+RRozSCPQKXE3b/+JXM3fYurPnk+//aPb9A2aw1HDmxl2TEpxssSs2iSSOZYsuwk5s6bTeCWyaSSVJ0q46NTbNh4Jnt37yGTSlGyp8jlsowfmeDB+5/kIx/5KDLwOOt9p7F96zskEwkmJsZIpRMUywFtrfPYu2cXc2Yv4N77nubee+/l+k98AiudRFcqVKYG6GhvQEiHY9cewzmXfJBnHr+Hl7ffwf/+8Gnc89D1+IAz9ZdL5v+blD8HOFNKuRY4BnifEGID8D3gh1LKRcAU8In6/T8BTNV//sP6/f7HmyAK9xGqghq3+MFPf8zxxx3PcWuP4/hj1vLYg/fzuwfuJxlPUCkXMQ3tT5L6IinZNMB32l3muhFBJBaLzVBZpourWV+weZ5HtRotKqN0N3fm564b5dm6rku1WqvrtsH3A1zXr5svjmprp12YQQBCipm5+p/mkfh+NCePnJfg1GwkAW7oIEWI7doYMZP6VAE9laG1Yy5hTRC3EghVoer7TBTzePVL/MCXWIaYCbzyfZdqtUo2l0DXdUqlIqpaX3zV3DrzUCP0ZZRkV08iDANw/RAPHy9w8X0X17YZGx3Gd2xCz6NardazMKITpO9FpJSa4+AFDgEVgPrxt2cylIVW1x0DBOLoG0/UqFYnMK0MupGGUMNKtLJm3XmsO/Vyvv69n/HBv7seZJp5c5bQ2tTK0hXHIiQE6CA01q5di+/7pFNxgkAgFFkPfYqe046tu3jlhc08eP9T3PzNr5DONHHi+vXMam0jk0lTrZYZHRnmcM8BDh06TF9fH6oqsKw4hpYGH1y7RmFqEj+oIXEJiZByjispVyWT+Ro136UW+CiaSYhg1+79vLtlG52L5mNZOps2nkAyrnPaKRs57sS1ZHKNjAwPR9BKIrCClEfzYIaGhpg3dz4NzS3YNZfBvn669u7l41ecxx1PPQOFKXSzCUWzsJQYCJ9AuMjQx7MLhNVJpvq72fziE1iyyty2NIbq0t21g2WLFnLySSdiqAqDfT3s3bWdYn4cSRh5CaQH0gdstmx+i54D+zmwfwflqRLl6hiKYbF6+Qquuuoabr3tPu775S20rTgLq3k1K9aeR3PLKvq7TO5+/EW+/NWHuOKcj+CUda68+kscnioj3RxZq4WJgo2JTiKlkcnoVMqjpBIJXnnlt1x6xTnMntdI66wmPv7xK/jkJ/+Z4oRNqVQiP1UjdCPZ7fxlK3jrzS00zF5NMjDQFY13t2ymVg5ZtnIhVqIDuzZOtrGDkfESjq2A1UBNKnSuWEKhUkbT4wgRgnQQUtLc3IymRfHNyWQMISSr1x7P8lUrsd0y77/8Il5++RVcJ8SulTB1C4U4zc3NxJMqK1Yey2133slnbriOJ5/4LaF0UJwygWPj1mzGp6rkq9G+6KUnHuShp97E9it88dsfQdohmtaBrh/+i/Xy/9hpy6g6Tu8x9fo/CZwJXFP/+a+Bm4BbgUvr3wM8BPxUCCHk/5BnKUOJV6mhKYKVK5fzN1dexfhYiSNHepjf0sDl3/0G1VqZweEBTFWhUi1gmFlAQYYSP4wu5YSQ+EEEQw1CB8ebnlMJNBF15kYdDjBNHTfNYCbFTygKjm1jqFrdyixRTROEF3WVmoLjhKhqnVITRHCEaN7oY1l6nccn8WwPLRlRZAzDwvGqJGImxWKReDyODMCpVdAF4HugQH5yglxjltHJMQwMfv/UH7jwosv59Tfux4xpBKpAqBqZbBrXs0Hz8D0Vy4SJsSLZBkE8bpFtbGBoeLj+vAwCLyCUgmItkvTpqhmNQwyLcrkWFfdygUBTIqqIVFACgT1WRhBSLU6hGTqyrqyplqtoQiFEww8j5Uy1VgERogmJECqhjLpsP5AzagxFUSBU66xEiRIG9Ozbz8Xv/wxzO5bS2DGPvqEiU3mPbDbD/gNDvPzCq8QzJXqPbOatzT5N805Fkc9RLgWoisX4xCBhaGPqDTR0mKjkGOifjLp8bHZs3c3ixRqf+tilmLFFrFyzntffeIXW5ibCsELo+4T1AChdA8fxqExOEAaSZDyDXY4ee2lyCDd/AEkpWvohUJVoHg4hGFUymRiWobF06Up834+gzKPjrFmzkJ6e7WQyjShKmlf++CZ7tu+mOFVBiKA+/rDrGSYBlhXDdnyESGBZDZQLeTy3imUZ/M0NP+LF+74AagxP5LC0AJUCDYkk8USa0oRNW1uSIwOTMLGdcs8Ue3v20tiY5UDvAImUQbFUZnRsB8cefxKWXSOZ0JiaGkHgRzkzAsL6fP0H3/02mVSSz3zuHznQ28uaVSsY7Z9gJBhmfCTP8SefQ1GB4a4yras30DdZxi3XaMzGySpNhDmfdMtZdPUXeereH7Hh/I/zsQ9dy9c+/3HiyRwIFc+diHLg/RqGAklL47f3vUgyk+C4TSsZL7xOZ+di/uu29/jHr7wPzZxCVwSGIti/+3kWrr6AdcecxiPffwYRhvgD7/JP//Itfv2dr3LCyefyx6fvZ1bbqYyXVFYcfyyje6bQPIWrr7qMd97eRktDDtfuI5tpxNSaae9cwGsvv8Gstiy+OkX3wX089fRr/K8bPs+HPvi3vP32i+RyJppQIRQIXRBgc/hIiX/7/o+47Zd3cOaZZ5DMGHQunU1tbBTLbETxHQwtBUoaJ1TpGe3jvAtP4QMXn0oYOpTmeWQ6r8M++CJO2Pv/vWgDCCFUohHIIuBnwEEgL6Wc9t/2A3Pq388B+gCklL4QokA0Qhn/v/3OTwGfAsjmMgyXimCZHNixi+6DPbQ1NVIq5onpGtt3bKFacclmsxiaDkFQ7+LCqLMVkXPMcX1Mw0Co9byQsJ7nIMIZ+EFERtdn8GOxRBzHsfHdaEEpgxCEiqooMzbpKB8iKsi6Xqe61JUg02FM0/SaIAAZBgjAqVZwPQhlGdUUVGpVTCEol6ukExalSg1LGMRVC6fqYAQKaTNFvwSBy+6X/5NljZ/Fy84mZpYJymUUWxIKFamo+PgIRaCGgoRlMjFeoP34BYxNjBOEgv6BQeJGEtf168l/gkAVuF5QR4D5eDIk8D3Q9ChtMNQIJXhBgAxCHKeGquo4rsRQdNxKBQMfLwSpKgSBiRN6EclF6jh4gPffI2FFpD2WElRNwdQthKqyatVG5s7t4OFH7uGM8y6gY9YayvE4vj9Kw9w0f3z6Trq3v4klPZwaoNZ46L7vRSdhr4qqwZHenvrfMUnGZ7NrzxZ0HYRm4LvQd6SMXetizuxmhoa7mNV2DvuT+xgamfy/mHvzKLmq82732WesuaqrZ82zhEAgQGIGY4fBYDwxGoNtPIGNp8RDEjuf48QxiRNsxwnETj7jgRljjPGEbYzFLBACCUloQEO31Gr1PNV06ox7f3/s6sa5K77JXeveu3zW0loqtbrOqapT7373+/7e54dpRcgoJJtz8f0GBiZRKBDCQRJTrVT0wJYhCRszlNOS884+l4ZXYd68eYRhQHtHkenKFH6LQDgwMMCxgRFmZqpUe5u8+uprlMsFurs6yGaz+D70lkz86jDldpdavUkUah68TIzWrlPRVsqTJAldXV00GqNUZ6r0dHdxwVKfL93yNQ7sf5Jf/uYBbv3qPzJ8NKGzvR3iiJtuvIEVqxex58BrPLHpWaanRxCOS669h7KXkM5m2LV3EIyEE05L4WNRr9dpNputJKj1/UQgrIRiWwdTU0NsevoZVq5aQ//ADAt6SmRtl2eOvMbKTov9k2C4PeSMDKEr6U6liP1J4mSSyDCp+UWUMDjr0i/S9+qj3HT9G0nn0jyzuZ+v/8vXeOju25k/v5tstsbY4QpOZ5GerhmkCnjqsefo7lnIXXf/HYZVIDTyjA14WE6dOLRojhyhWfkJb7/oJhJlgxnhSI/+H97DCfd8ib/8+pt49pc/pHNZgYnXFOeddSI9byxz/YcX8O1vP8/jv7ifYjqhkqQZHQ+58OIL2bplC7miQz2c4djwETra5/HcE1sZOjLEa69uI98WoaIAwypgZiwOD45w0403MzY+zI03vpsNJ23k/HM28tLLz1KbSiimM0z4TbJtJWzXoVE5CsB1113Llk0vsri8mg99+la++/W/YPOOb3DexjOZOXAC8Op/GY//RyYISqlEKbUeWACcBqz5n/zef/Oc/1sptUEptcGyDDoKJYwI9m7bwWj/YXY8/wLpGDb9/FcM9h1m89NPtdCmDpZrYdmvX/psCcJ1078H/m/pX9Xr/otavaEd32fNC37fbms2u46juAW81/rtWW229iM0iSL+EyVPKUEc62zdsbULjxCv0/H0Nag5uWCmJZ0zDIMw0hOLsUzIpjMopXBcgQIajWle3bmLRhAzMV4FZZLEApUovcLjtMowKT2KDiQqIZ1OIQzw/XCuwdpsNufwtFJAGCTIRDsBJRLiSGIoC9V6Lw3DwLCtuQUO9HugJCRCYFgmhpFF4ZBIDdBSrWD9+tSlhRaymQjVcgEy01h2CtNI8+LWFxgY6MeyDZ564teUkmnWdKU5cXkneTtgz56XqNZHse2IhSsL+NU6bzz/bB64/y5t+iXhpJNOoqe7h66ObqamxjENQRRCsVjEMDXIaWp6lN7ubkqFMs89s5mT12+ARJGEMbbt4nsBptB8dEMIhBECCV1dZRYvmcff/8Pf8sUvfh7bUnT19NJW7qLR9Dh6bJAXt77Mrx59mvHRKnt395Fy2ii39dJW6sEys8zrXcCC+cuo1SIGB8fwGglKCBJlMj3TIAxm0QKSRCYoJI1GBc+rcqhvH51dRdIZiw998DruufsO1p92GnZo8aef+jR/84WvUcwv4azzj+e9N7yHc849iy1btvCNr/8b99/7MINHRzCEw8Rkhe3bdjA5Osbg4X4cy0agyKbyLOxd9PoCC0gUUsnWIg/ZbDtIk+mpOiMjI9h2xND4KFO1JplMjhCDvXsncfJlksQjChrEQYiMHKQyUCKFkQimJsdx82kK2Q7K3T3Epsmp65dy9lnnccK6N3DkyCSDR6rkOlM0hUeoQJgWHaUik2NHWXfcaezfe5Tbb7sXUCTKBBSOYRJ4o+QKNoaZB5XCUgbE0+yq1lm8GkzaiU2P8cmYZi3hN49u4ciBaex0mlqjSuBF2KahS4mGxcTYGHVvEklCFJpcdcU1PPqLR+nve41CMUO1UsdrhliOy2v7X+Pr//R11q49gQfuvZOF83swiKhOjbNi2VI6ym3EQhErSWdnJ0EQ0NZW5JprrmDbi1vwmg3mze/kzh98necGhujMKj7351+G+P8lEwSl1IwQ4gngTKAkhLBa2fYC4Fjrvx0DFgKDQggLKKIbkn/wkLEEP8EMfJqTU3QuWoiqeUwcHqVouhx4aQerVq8lY9lYwiKMdDb8n7gNRssH0TR12SKSCMdGGIk2T4iDueA+G8illC0+iSCdyWoPvkyWRqPRqoPrN851LZJEEoYacG/bzKlS5kwVLIsg0B30VMoinRJIhXbyUIJYxCAVSjsOYwhFFGuXHaEiTMtAWTZKKHJFl6kJH4XBtle2c/bbruT5n34PI5/GTmKUFSGBZlWihCRPCsOxWbaim71795LPZ8nlcsRRhWagBf5JIrDsmNgwMYRDDMRBgBKmtshSirRtoQTEKkKqmHzGYbxR0cUMGaKkJJPN6vH7VIE3X/dxrnnrFdxx57/w4i8fIqaCRYpZhKpjp4jQPOhWO5hUuh2pYu36bhts27qZU05eRxRFfP+WD9DZ3U6xvIAd21+ksxCyvNelMh1y09svo3vJana+eoS/+dwnWXfCOnp653Pm2edx69e+wZ7XXmnhdHXZSsuvBEkiSWI4fGSQrq4u9u07SC63nndecxU/efD75PNlivkFpNNpGo1xOruzfP4Ln2b58pU8+eSTvLR1B//8zX+iUfdYsHAFjz/xW0rtnXR1l1tIgzJLV6TBzhMrn1Khl7GxMcbHGzhOibGRCqPDM5RKJaamq8TtJguXXUZb124mx45oxQha6SRm7cxMg+7eEgNHhvC9UZYu6aCtI8+2XdtoVFye27aD+QtPZcVah0q1yrNP7mDPjocI/WkMx8LzTIy4QigFkxMVTExMpfndBqBUgGPZ/PjhH7Bs6UraO5dQnRlHELa8LhM8v0lb7wlksu1c8JabeebJn9JW7mDv/j2UimWynYtY1rucHz05xN98/j/o7QaVNMhl9aIukwb1eoKdMulo7yYMfUK/QWnBQgYObyZfMpFugX/40qcZPHaQt7/jBt559Tv54Ieup73cRSQnaDQbOElMRz7Nay89RxxM89TTjzAV1mh3BFm7SGJWSNnw4O1/z9KTruDQK9/FM20MFfDTu0f5zMfSRF05VOLx7LN7WNkbsXXTMc468TN88q/+hN2vPEPeVkgrxnEtDvf3c+zYARYt7WB4ZJD3vucm3vSGd3DHHXcwf9Eipqcn6excyKsjOzHtOg899DOuvPJy3JTN2jWrqNerkHgMHO0jk8vS0dGlY0wsiRVc8pa3cs9dd/HDH/6YkzecjDczydRUH4vKec4/8QQGK1U+fsMFfO7Dw7Py/P/nQVsI0QlErYCdBi5ENxefAK5EK0jeB/y09Ss/az1+vvXzTf939WyARhIyWbJ4efwoGy9/KxaK+e1d7Nz5CudcdQmLnAJHjoySth2QquUIk3k925UhhgnNZoCMHXKpFIGsvu5zKMA09QDP7xPVXseUmv8pmLfUagQBuG7SMsn1cRy7RQ5M5n7fMLRDd5RA2rVapFWd0Sp00BCGRRAoXEfgui6OYxJHIfFMnTDR026haJJEGmaVzTnUGwlx00aqKksWr2QzDkkYgUyQfoSTcUictJZ4SQs/DEkkhGFMZ2cnBw4dJAzQaNHWRx1HEUYcYwgDx3YxLAfRcrAXCu3TKSVuykbFipmZGeIkbhERdfBNWk9qWRbve89HOGFtDz+4u01rj2MtV5w9o2admJimIm6VnSR6oUqlUgTNOoqIfDYFysZc2EmxvYPFKxdz9MhO0imLwYEZ/vWbnyYImtgZhyef28TS44/n8cefZuHCBQgzRaVSadEK4xa5UOB5TVIpF9A6/UqlQqlURgjJ8889ySWXXoCdynDGGWdSmZmkp6eLY0M2kjr33v8A+VyJX//614wM+aw9bhm5rE9HRzudXdN0ds8DJG1taaanKlQqDUwrTRiGDAweIYk1idH3fWIpMVobWkXC9PQUHT1dZApFJkZVq3bM7+1O9P0TR1rLWq/XWbCwg/2vHWTLCy+x/8AkbV0LqNQl5Y5enEwnM9MNxof7QAbgeyBdUo6FVqoqFCFJy78RYaKkPkdQq7J/3x6WLlmNTBpMTdZb3wewnRTFYhEvyrP0uDU8/ovvMTQ1g5vvZGKyyTkLFxObkupMgN/wMcIAw1QQKyBAoIeBEimZmZrGSdmEYYRtthGHJg45gqRK3Ztk8eJ5/PSRH2CnYt7/ns9y34O3EXohhVwe16qjopggrLFmzVK+8+1/YN68eSjLoBE1EJFBLmfz2s7Hec9NX+PQ9l9giFGk5bPzyWc4dvVyTrt0HX3DQ2SiJltf2kTOSRBOxJF9AwjDZP78Tl47/BoLFi3m4MEDZFIdNP0GYRjz0Rs/x+bNL5JJtaNEg3JXhmNDQ6xeeTKf/MSfcvPNN9PT04NMIqrVGWQcMj7RZNmSJfQfHWBwcICJqToZx+INf3IBm599ljiOWbpkKf1HjtLpOJSLBWoiJm7U6FaSI0rS27mU4eHt/2W8/J9k2r3Ana26tgE8qJT6hRBiD/CAEOIrwHbgu63//13gbiHEQWAKeNd/dwLTizhh0uCClau4+LM3kjOhksCG+QvZduzHlHvKbBsZ49Z/+go5J4VpulQ9r1VuMDBNAyHkXNY7y5QO4wjLcjGUTRhEYIJtuXOoVZnox4apB2JmTW4Nw29J93Q2r1Go1lyAFi1DYe3mrssmGDq4NRs+xtz0pdZvR7HEMg3iWBJFAb6fEAZo9UcS4aQzhPgE9SqFdAG/adHWZjIZNZBxnvZcO5defT3P/vIusCLsUGnliWMSxpI4jmiEQC3gsre8lYnJMQxxkJQLrUQb0RreCP0A04C0kyedzc65tkdBEyUkSdRksjbZWtA0u7ijo8zoyIh2OY91vT5qVrnhirfy9mvfxaE925BCF0ISmWAIUw/vmLbOtqOIXE7bsHV0dJBKpZicGqa9lCVtm0wMHcQ2JSsWl2kGFYaP7iaXkQwcnubWr/0l85Yfz8f/7C8YOHwM1zB5be8hsvk2Ricq3HPv/fi+r3sYAu6667ts2bKFf/u3/02zqa9/djDl0KGDLFm2iP7+w7z4wuNcdMF5bNv2PPVGhcNHswwenWDl6vmMjk5rjky6l8WLJEniMjVVxXY8Jsd9/GCITFabFKTTWRqVGkFg4DfrTI2PkMmmCUKf/sN1XDdFHMfM1CY0R13Bgw/eTxyHKCVwUg5RELZUIy17YKF125bpcvjQUYaGBnQTUzgcv/4MRiYaBKJIEmYpdM7jkuPP47eP3sXE0H4ibxjTkvhhjGlqhZBSrWE0aWCIuDVlCWCQRBEHD+5DCR/TkCgpEIZNys0zvG8v81avYtMzffQsvJAju/Zw1VXvJZ0pcf5F59MIE771zU0MHx6jlPdxXIEtClipkAQDIzGwTD205Dg2Y1MTLF24iETliCoVbOoktoLmCB1ZeP7x5zg2/mN6F/Tw1du+y7/f/k12bX2Snq4ioQoJxgdYML+Hv/vSJ6lGCZddeDPPP3kXtYaHYITTTzmJvvPezuZddyCm4fGffYeb/+Jq1l9YxtzSw/MDe/nIBz7Hj+77a05f38WmZx/DkLrnpZCsPu44nvjd7yjlCixftpogNHh13w7+/POfZcWyTiy3yuH+Yb7ylW9y373387FP3sjCJYvwGzMYKJI4QsYR2WKRIGgyNdVg4cIerrvkMl7e8iK/+Okj2LZLNptmYnIMN5fHshVR6NH0QpYtXsYdP/0tH3rrxVzyub/ke5++5r+Ml/9tTVsptVMpdbJS6kSl1AlKqS+3/r1PKXWaUmqFUuoqpTSdXCnltx6vaP287787R2wKgt4Ce6IJTl8yj8ceuJe/fs/lfPjaq/iTi8/ilz99gI9cdDHFTJ7aVJU40dmvVNrKS0nRKl+ELYmex6zT+Kz8T1+bAIzWjSxaHA0TgUkYJoShrt2aLZPf2Ux+1twXdB0VNAhp9otmmq+DlUxTEMdJ649q1dL1UMssxnU2Q4/iYI7rjdCYzCRRhE1JLpPGtHQG9uRvf8K6E9dTb0ZYjk2iJIlS5Ap5TNul1vS54urrWbxkDYaZZu++g6gEogh6erpIp12U0r6VyIhEBjS8CiQBjeoUtZlRGvVpKtNjNLwqUkaYrUk7s2Ve7LomhqmbiQJQcURzYpC1K5YReg1ETMuGSx9JEs19HkmSIJSeKpVxRNyytwp8zXApFXIUMmmGRifIlwoYZoq2jjKZrOC3jz3Nu9/7Efr7j1HItyGESXdHO21tbQRBoKdWBYDk1FNP5Bvf+Bq7d+9i5colnH3O6eTz2Tl0AAgc1wSl6O/vZ8fOl6jVp1i7di3Llq3CtCCJBVOTNWwrg0ws3UiWqVbgnkKqJkEQMDU+hYxiTASGaYJUFPIlQCIMXRdTMiKRIUkSkMT6HrRsm/7dOzh2+JAeS/c1eEwI3ZOgJWEVwqBUKOoejOnQ9GL8QDA2UmFyuk4mXyKdKeDmCnhRzMkbz6F7wQpMM61LLYZBkphz9/gsBdIQpuavWykQKaSykVioxES2AGgoDQOLswsJCel74Xtc88kbOe3N76B34RpypSJBpLDshPHRKggHw1BEsUfd8/GCBopIiwakwjAlcRjguDkqjSZtXQvwwgrFYpmuzi7q05K03YnvjdDdlWZ4qJ+//8otvOtd19PV28vRoRlidNlLOR6Wrbjj9h/xiY/dzIq1bySTTWM4WZ783YNsOPVsVFNh5cFS2/nBDx7jzRccx8Kli0lbFv37p4gbCScsPBN/8iDZbJqZmWmy2Sz5fL5V8nTZt+co3Z3LePgnjxDHMZVqjT17D/Ctb9/B5MQML770O3rnLyX0PdIpC9+ropKYfD5PteHRd3iAN7zhLN562du4554H2H+gTxu2CEUU+lgC0ilJ1asxVavQqMckscUd376TcVNy8nGL/mC8/KOYiEznchydHGfV6iWUCwUcEx777RPsH5nmA1dcyr/f8k9s2fYS5159BZl0mjBW+LHeVtqWQSIjXFtzoy3DxDEBtEzPSDtgmhhCzFH5ZptrOstMAEkqZTPrWJIkCY7rEobRnAv7rOekZVnEkaTZ9MlmNUM7CIJW3TshihRd3UWqlQaWLWhGEtcQBLF2W0nbs2oU7V8ZBU0M4WDYMaaloVUiFkSeIvAEhmiw8+WfYNgGidXG5PQUaRfqDZhfqtufPQAAIABJREFUWsOpZ6yj2ZzkRz98jFPPOJO+/lEanqRcbsP3PWqNKmHL0VtIqSOCjCGB0eFp/QEIHWRM0ySRCSgDKU1MS+C6aeozFZYtX8mevQcxLQcVh9gmSDWDDCM6Fyxg/PBulBGAlC3wkaUXCqH5LFLFuI5gfOww+XyRfCGLSPTuZnJiEkOFFDvTvLL7Ncrz5nNscIZ1J66lWEqhkhAk1BpV4ijBG5tAJRMt3IAxZ9Q8ODjIqRtOolwuMzAwwCuvvILruriJi+dps4oDr/WzfPki2trKyMQi7ZY5uP8o5XKZbCZPvZrgNSQyqRIGkjCsk816utwRgEmOJAhIpW2SWNCoz2AIE9+bJGzqHKhR8xCGbnjHkS4XGaat/R8Nm4VLO5mZqTI9Pa1ZFTLBtKBQLOoEQepkwxS6qd1UIbFMWLp0MUOTNbrmL2XekmVYqQypQgeOKSivWkQmleOhA/uxRBUlI727wiWWObAyZLNtOgnJpgEDr64bxyqqE0UV4uYIEGEQk0pl8Bp72LP1OfK5LGsv+Szz5y8icbOkzAxKNSmVMhw6MEa+1IHpVrXU1mgnoE4US2qNCMtyEDJFpEycVBuTlRobz72Og7sLjA09TdExMJw8hu3gGhZVf4pczmRicC9f+uJnmalOc9lbrqCzs8x9DzxAbjLBNeAzn7iGCy9+C3t3vUq2tITO7v08tulX3HjzJRCaJH4aSZNHv3M7X7r9bbzhdMFv7qizZO0Kdh/wueojV3Dbv3+UtlQJhcfpZ5zF4OAQp6xfz9KFi3n+pe08+cRm2oopIOGDN/4Z69aexDXvvpjO9i5KhQ7CcAxLxggM2kt56p7P4OAwZ5//RpYtWc7dd9/Ls09vpZTP4Vg2YRTgujamJQlCn5xdouoWGBydoqujl7vuvItLLr+GW/7X13jnhz/0B+PlH0XQdkwTuxqxOt3Fl17dx1/91RcpBiEXdPcwNTDB5276EEE9fB2wJNAmCK06oExMmlFCvmDoxqMjUImJOVtfjhWGpX3+HEcrLmbLGzogx3PMZNc158oss8MOwBxAKQgSXVZxBKaps/BZ+eCc0a8SRFFMa2qbMILYAKP1fFJKbEuPuIdhiGFa0OJHCGESNLV6Qfsg6gxs3759XHXN9Tx0z78RJLBy9fHM61nB2JjH6OggJ208l2yuSGL5LFq0hLHhPdi2zUyljpK6FGMIQRj6egcQa3caNbtVbo1QI7SpllI64/B9n/buLiqVGk4+r5uXic6e23tWk8tlyLV1IgjAsvWLRZLISKshpDnXK3BcQ09LqhAVg9syrmhvb8ckJogjTtmwgmLncianp9i1ez/bXz6A1xp6komtlQ6J0GPDSrYawvpcoD+jxx9/XBvVIjTyoIVaTRKFYUK1OkOj7hOHroZsGQmWVadarVMXIYZh4jV8LCuFZeQAA8OUhIGHKQrEMsH39eejF3OFIWZt7AyKpTJLFq+kq6uLJFHUahX6Dx9gcnICKSVHjw0Sx7IFh0oo5tIIx8S0QKqEerUGGLqHQ0wiAuLEouHVSEhj2BapTBrTSeGkUyRBEyFMMtkiSEEiIJPOkkl14qQLSCuHMh0MJ4NSNm7KIYwTEgIatSpJ3GxxUQxMw0TKCMsUPPTj+zDSaY6JhK/98//Cw2LzY9s4YdUaUikHr5owPVVHCVMTI6M6YRKQKjvYGFjSxFCCWMUgBWFUw3Et6k1FW+dJHNzzK2YqEeVSjno0iiU6sCyfYjmNmgmp+h7ltm5+8csfc9VV7+ert/4LX/jEB0gELFrh8NhvNvGrTaNc+qYSi05pY3TTXlw/p/G06SZGM08c9zNfClYtEFR2DxBepsjJWA9gxXUcx6JR1/fzsWPDrFq2mJ07d3LLl29jcGAGzITj166hu2s+11z7DtoKK8hmDKpyGNdJ4eCSBB6+18ALYhYtXszCxUt45Gc/J58vYiiJQGoVmUhatn66lDfQf4x6bHDRpZdx4w2f4Ad33UngVfn5L77LJ774mT8YL/8ognYqlWL7kX5emqry1YfvYmh0lMXtHTTwGRuu80hOYF1+AROpiDjnYguF8iJMJVBSIk2JNoUxEBhEoS6NREGIUyggTW1ekEQxjg1BmFCrRbgu2KaNZaVIFSyqE3XytiKTt/A9XQ9NZIJluiRxgpNJEfsNTEcQJxKpLBQeMrEImgGZrMB1TSYnZ8jn8lRrDRzTIJtJM16pYzm6fmwKQSwTUq5FHEdks4CfxTahkLMRZghSsXZ5L/1HR7AsF7+ym662T/KOKz/FyPAkRw73cWTiKB2lIsqIcOIDHNs9gJ0t4tp6sfCqDebP76FerZIkEIY+QpgIwBQOkYrnArcQoCyBmSgcE1QsUUFE1krpn+MS1wOEiHAdlyBIGB87yhkXX8bVH7mMlUueIh58DcdJackjEssSWEikYZHEkEhJJmNhW4JKpcq8RQvIpx0cK6JcbmfLKy/zykMHOfn0Ovl8kbb2JkcPj1Eq5qlWa6w+bhmHDh0iDPU0qmUapNIG69efRjZns23bKzz37PMIIWg0QuRctWa2D26QxAbjYx5QxzIdstkslWqdsVEP07BIpCbcSRkTxk2EMmg0quhhWoNY6qnPWd7N6+U2FydTZOPZb8ayU8SxJLEdHAMW96xi41kXse2l59izeyf5XNQqpenpW9/XbkzNwNeLiwQhYsKWu5EMBZgGfhhi2hD5rRpqJEm8iFQ6zaQ3QSaf4rKr388vH/w2YVTFi7IgD5Kpn0YsE1S+gXByyFibEDtuDkSKju6FSL/CxPAIidRs7kajxjWfupWDF17Jogy8MPgKV114DuNHFvDy7pc5acObmWomTPTtYOFxxxE0aqTMdpxsGlMqhDKQpiBMYkxpYcQQRRIpAiqkCILFrN34Ni5/xzpefuYZfrfpd5jJNIUul5lKgOkHBD4Ucw1Wr17Ilhd+xcM//j5LFy3j/PPP51ebngDzCP/41ZsZaCQsyTooq4NNW/6FZae8jb7tj6DcBmYA//LDUS5+Qw8wTke7Yv3Fp7DuhCwONn58gCSWrFl5Gn5gsWXr4yRNwaoT17Nu/Yk8cP9v+cynP8Ctt3yBhd0d1PxJgjhFo1FFEGBmCoxXapyy/iSy2TwvvfwKzz/1FIWMixcPE4WSJEoRJRFd7fPwmnUmqj5rVp3Mrbd8n3+49c957NGf8cTjv6CnexGdC8r07TzCAtf8g/Hyf6TT/v/6MIRgZrqGMF22bN3GsdERntz5PM9v3cbIzCR9A4MkiSTVVSQyW36PChIlka0tstECNymhYUpaPz0LlFLkc5mWhluRRDHFQp6Ojk5sB5QUVKZrZPMG8xd0Mz3lk0ibKATTMDEMRTpjksvY5LIWtiHI5lyCsEEcCUwrplAU+J6i6SWk0g5xoiiXy0RRQhxLLNMBwyadypHO5khlMygBnh+AcnDsNLl8hro3ShhGmLZLpd4gSRRRGGAIobO1SpVG6JMq5SkUcxhGSLM6RWWsD1vUscyIam1yTh8+PjZJELYQq0rg2Cld4pER/J6oR9dTtZY6jkFgU8x0YJtpfD9FGOpgb5u6lm+YArIZ7rrnQW74wDc47e2fwHU6WjsYa45NIowEP2hg2wYpV8skm16AZWrZY9D0qXs+e/bvZ3i4xvr169hw6vGYAjLpAnbKolLRgbKzs8w555yJ65pIpReBd7/7GlauWspvf/u05qgkuuk4OyTynw89BGUaJoawiJNQW3kRI8TswJZW0ejBKe1WBHJOaTT3TL/3WGBipXJ09cwjiGJqXhPPD0kUJEpRbzQZHR3Fsiy6u7sxbe1v2WjU8X0N5ZpVL8VR0pohcGj6IaZht15TRKU6Q9a18OsVVCiJmxGFdJ6UZeNVmlQqNU44YR3d3b3EtoR0BoICGDZZU2AYPlHsUW4rUszncF2XVCqF47g4jtOqq2ubIctySIaOMC8fccCfwssoXt6xj0vOXsLyBd2U8oLKZBORlkzNHCWJoNHw8Op1/JbV3Sx0TSuyEtKuiZuy8KOQQrGDo4NTfOWvb+H0jRv57u3/RiwDJsbrdJfS+KFJoZRnYqTOQP9RpF9j2fL5HBno4/t3/YB3XnEN77ru3Tz12D385KePkIiIjBXy/FPfp94EpSzNGDJCnn7yWaIAzO4yj/ziAZYv2shP7t5FQoJhJnjNBN/32b17F81mTKmji6eeepbbv3UXH77pPRw71o8pBFFcQxi66Z1O6/fv6OA4V199NctWrGTTk88SBE0EEVHYoD4TIRObQjGFIVz6+g4zMjzFHf/7fj7/+b/i5k+9j+dfeIp1x6+lq70dz5tChAEdHWXEH5Zp/3Fk2jJJ2Ld7H6OjAyyZt4AwalDq6CXl5mnWYsyMhUASVKZQYYNao0pPby+mbZDEkrjVdJQImkFIR6mIMBIiFZOQIAxFKCPMtCJbaCOVRNRqNWpegB9FpF2LtHAYGwtJuRM4rpbvkYTYloVr6+111GggogTL0BrndNpGyhQNv0ZipFmzfi0z1RkkCq8RUIsSjGwJ003T2ZYhDnwSGZPNZXDSKWpN8COLMLGwMMnn8/RLCz8SJJWIM886k/N75nPv/fcBKR79+W289Yqb2LtrL6VykfG+PiJvilKhCxWBk87jNWukbId8toCUVcIgwfcDLFuzUeqeDoCzTdpZs1+FgUgcEhISAVIYnPmms2k0PZ56aiv5goPEQyqwXYckjskHkt3PvsiqU86kp7tMdfWJvLrzWWzLIfAjtD0FlMsFPK9Jra6BXbaVJuWkELZFR08Xm37za04/dR3HLQ+wCTnWf4SUYfDa3oMct/Y4zj33dAxh02g0GRrSPpkf+9gHeeaZp3nwwQeJYwnSYHhoXHOpDWNuPfpPk5noXYVsbVdJlDbhTTQpEGRr4EoHmUI+C0ri+wFJIlteo7NyRtmS6emyVrmtSLmUpzF9DKkEzYZH1bbxgzqJDGlUpkA1UUms2TeGQRy2FhFshCHnAnfoa+s71zFoeh6JNEhnBNXxIVavPgnIsGPrdpYsX4OXn8R2JY1ane3PPc4jI3WWL1jBpz/8EJddvZK15fU0C0NI0YNwqrimRa0+gyl0aUU32WXLL1KXtpQ0iaSiY+U87v71Pq5+8zouPft8fvjgZm5eF/OhK4/n0CBMHkyQRg1FTNDUPPowmCCMHSwjR9Bi76TSBSxhEEdau58tOtSb01xw0U0c2LuG2799HzOTY2RSNv9827/y6p7d/Os3boeqT64gcB2LBElYq5FKg+MYfOtfv4oErv/UZ3jo/nv5ze8aXPzWLsDmy//4Hb76Z++jf+CXxCri6G9uY+ubT+eS91zPL75zF2d+7iz+4vMfQ7gppkd83nPtB7jnge+DHWO5WT7757fw9W98gdGRQ6xZfjIVs0omk4BhEzcTHFcwNNikLbuE6699O/fefzeOY1HuzBOGPpgJwnZoRja1Rsj8eRv49Kffx+H+Q/zoRz/kxg/fgBKC+fPn0dtbZHriGDIJMVGE3iQdXb28svu/noaEP5KgXa9VMAXcd8/9tOXTCNMjViEp4RBIG8NWWLagu7ONwaExlqxaQbPZRMUSU0EYKpA6k3Rdl+mKhhrGoSQKGwipy61RCEEwiRAmjbrUsHpshLKQkY9pGGBYND2IfE+7r1smjVqM54VkMiZBICmU0sQyJBZpYuUTk6dW99ix5wDTlSorVizj4MAIhmFw3HHHMTQ0gvBqLFiwgImRY0zXfTrTefJtnQjDBaGbdju278Q0UpTaOjlp/SkcGx5hcqaJnSoS+RMgYPeOF3GthMbUIH40g60ihGyiZIxQtla1YFCtT+N5AaVSgTiSmJag6QVIGc3VmH//EErzwE0zabn/SIRoMDk2gGUnTE2PY9uCKFREcYJSJjWmOdC3lRWrOzk2nlCb6SdRCU2/iW07rQCpWlZsYYvKqBtylmPT13+E7Tu2seGE4yjm89QrKTKZDM2GR8pNs2hhmQ9+6F38x7fv5MCBPpSCpUsX8uEb38sPvn8Xk5MzuK5FGGh9tjYJCOewAvA6gGn2mO1jaHchA9dNtd4XPT0ZxwmZTB43ZVOrTSMTNaeYef2Qc88NAiUgWywQq5hqo45t23h+DVe5BF4dGfvYhuabOKksUZgQJ5JGvamvrWWkEbXY70miTTqSROh6PBBHAYYJIyOHWbxoLaHncXDvLtKuTdOvUqk1mB4f5pxzL0RY0zz26FN8+Ka1FMqXEPBLkiQkkWksEZN2HEzhzJlbz9IYEXKOvmaZDsZMlW/echvLz/sWGzMWY34NIR0cy2OqArtfrYBXI86CleS1Jj0TYQoXZIxUehw+jkMkCsco4nk+sTmMklmGRhT50lL6fJNFSzro6x/k4x//BFe9/To++fE/5dnnNrF9+04y3VlqtQYp26enex61eoVcBnoWLOSe277OslWL6CxVEF4DhODFnXtZffJb6O//OQ4WA8d2smPLs8xfdTGdS9ZiZQW7d7/AqmXLqDcmOXToEFHcABny68ef5/QNZ/Dnn/sA83sW0qiNEDUNjswcJV/KU6lVmZiucu5Z57F4wWIeuO8+euf3as/XRg1lxARJzJFjYxQK87jwHRdyyYWXsvn5p/je976FwKCjPJ8oauIHYziGIJVyqdU1XdSLIpoq4qmnn/iD8fKPImgXCkWS0Kc2M8rfffGbPPTI/Ww4+RQK5SzTlZigOUIqkyaQIb0Lp4l8XS5IFbJ4dY+0a2Eh6ejooKOjTGdHmXw+h2kJujvaCcImSsW6IWDac9s2IQQNb5qgkdDZlsN2MpqWFhoUyzmOHtWqAkM4tLeV2bn7IBiChx/5KYbjMD6pmJqOWbSkSDNQRLWQRLrs23+MINRqlhe37yafyeN7TYZGp0inHBzHoZnMEAQByYRPraFwTYdDB/chUgYYNvsO9nHuG97I0PAYCxZD/74JHJVh4MDLvOu9N/Lrn/2cYjoh52SwaVDzQzxMQpGQyuT16zf164yjJpWZhq7BCnuuiScMXXtUJBr2ZCaYhk2QRAgEjz3+O5p+zPGrV3HeeVfyvg++m+6OLPPndWA5Dk1mCCKXjDsPv+Ix+NG3s3LBGgxMjgwc4bprr2XLli1zLvAGms+SSmUod/UyOXyMk48/iSTyGBwbIZERIyNDLDt+DV4zYGh4mq/87TeZnplm4cIe3vb2y3juuee4/bbvoJRW/AR+NFdb1g1hk1lnIk1+NH4PN6DmgvNsYG80GrpsFktWrjyeU884jQfuvgvP8zEtMVdmmS0kab07uK49RzxEgYnJzMQkliGpVyYQMsL3JM2wDko3nyxbNz4VLlEQkstnNGYAhd/0cV0bpQRJHJN2M0hlYNmSMPKJ4hiU4NiRwxw9OMiq40+io7Mbv7qfMKzzzM+fIJYz9L36ItaSEq/96qv8+LG3sHixy8GDywiMPqzKItwFNYzI0lAvKYEYwzFJaAVsZncnBiXLYNf23Vz5tk8z/vitrF27gcRqkk5GaXeWsnnzCxS65mHnPUxR0gREV9CsR7i2QMaxToL8OpZjEyoPS+QxY0W9OY2IeuksdeL5CV4QYAEZx+KlLU+w7/BRFIqvfPmvkDLmb//2H/E9yLX7mE6CqkuGjh3BTUGznueU0+bx1W/cyeoNF3P5eW/lii/fgfNwOyHDmHHArx/9EV/7/rW8etZSLn/HX2KohBs++nHu/PZd7NlzlG/efhvPb3sBy+7gXdd8lp6ONkRYIcbHdCJcy2ZiosoV116J7drce+f9bLNcujoLmChkYtDwEkzT4FOf/BsWLVrEJz/xWX784L389tFHECJHT3cnMg4QqoplxLiGjSEUvh+Ry3TSqPukpGJqZIbNT/3XTuzwRxK0oySiq7ed4aFJ7r3/fl7c+gKXX345Y2NDtLeVUO1Z6o1p5ncvJAoPEsUxhiUwZKKTg0QSCpiqVkhQeIFPNucgI8XQ8BhBs4mSTZQUv6cM0TpsO+WSsh327K4hlKQZBpiWRb3eZNmSxby07VXKXYvYseM1hKONDipNQd5J04iaONkcA0cmyRdyxInGn3b39DAxPUUUhvQuWEDda7RkgTZxoqhOTjM1XdOO6c0qgdfANB2UKVixZDkYJn2Hj7D1xW10dfWQRBFnnfUmtrywGTAZONjHCevWMjawA8NwUcrDzTrgWCjfJ/YDho+NYzu6Qer72u7MEC3XHEsHn5JbYLpexTTBNDIkUYPYCMikMyyc1877b3gXp522gQ2nbESaiomZGlIq+gaOYKcN8sUMAwM1KjNHmJwy6V7kcnjwCdrb2jl99clsevJZcq5Jrq2bemUCwwALB5Qe3Remwb6Dh3jn2y4im3aoTAzRaDYpZAtMTh5h4aIeDvcPc911V1Mut/P9O39ArdYkl0vhNfzfy6hns2nRMp0wkNLQEjtLsua4VezetY8VyxexZNlipqYqTE1Ncbh/EMPQ05m+73Pg4C5K8xbp50ulkH5DB2mpF7qEEJQNRBpZ0DqEYeCaBjLj4jWqqDgiUT4JSo+NtzTGYdAgluDYshXwFc1mgGvrOQApjZYEVTc3pdIqqHQqhzIt/LiJChMsC0YGDzMzOcHQ0YN4Xh0ZHcXMdXNo71MsrKxmy54nOfW4Rbz/wlsw7T/B7urCSfcQND0S2cA0EjAd3Ry0FH4UYpgmMomJ44hERYxUBXSuobJ9OzOJy/FrXAyVEBlF5i+Q2JUII5VmcmycdDyKaWrcAa1yTxRFZLM2QRID2g5NJg0MIbGcpMXBV7T1HI+VPkZsjNPZXWCwb5Lu9i48r86X/voWeud18qk/ey8vvXSQZ57ZrD0jHYeEkEYIlYkB5nWs5OGHvkfXiwN85ZG7SaeX83NZwbBzKKNBZddPOOtUieOcwp/+1KRzxQXUZyJeO3KEN5xxCo89+iyPPno3b3vLx3n6mfso25DJGMQqTTrbw6GBw2w86xSGBod59pkXKORTOK4iX8yw/+AxFAbXv/uDXHrpZTz0k0d5+Md/AaJGV3cvzWZALqcHz2IpkKpJFEfUpg1UqBfKRFYQmCjDIp/PM3R48A/GS/HfTJj//3L09JTVuW84nYd+9GsefuhHbN78DOX2Am3lAq9s38XKlcvJFzL4QZ2R0VHK5Q6Wr1jFe6+7kXpNB0PLNigWC2SzWTo6OnDTeoIx5dr6JC3YFICJ3hK6rkusIAkDZOQDEgzN3rZsl989+TTFUpHJyQr5XImZygztHR1MTkyAYVFqa2Nmepy0k25ptLWLiJQ6E5MoojDUmu8gQBhGy+UFSqUSQRDQ9DwKhQKmaVKt1fSNXizheR4nrltHPpNl965XmZwe5exzLuHIkUE2btyIoeCVnY/jNxuklY1rgTBNppu+njisTKGUoDLjY5kOthFjmoIwkcRxoo1klYakfugD13LGmSfz7vdeSMo+kTicodFoMjkzjmmazFtQYmjsMEGYozot2b6lQqUSsGvPIdasPQ6QbNx4Jok9yOJVq+guQ5sZEwqDjDAx7DxKNZCJJJspAAY98xYzNTVBPpeBxKOnu4N81mXXnt1UGwGeH/Pu664hiBMe/uFDKEWLkufPlXZ+n9Y4K5cUImm5GOlgrM0njJbJc4xtm8Rx0hqKel2vv3jxYo4e6ifJzOeaa6/hsV//humJYyRhBWaHhpSue2t9OEipEMIAYdI9fzFCCOJmgAx8PK+G4ZoI4tZ5bRTaFUgqA5nEWJaesLUtVycSUg/gSEzABNPGUB4bz7mMLU//FsstIoRmuxvCxTAsoqgGIgEVgkizccPF3LvpJ6RMjzY7TcaIscSlKKekeR9qAJkYSOUSSQGYFDKSKJnBm9iFQl+DkIKPfuab/MfXb6W45hRu+tTN/N1H3sSjOyZ560klUC5Pbxvn4ov+lraODH5zPyoWYOnvluXk9XWaFsJ0iROFk0pjmTZWyiRGkXd6MKVBxp5ix/aHwT9EOZ8jl0sxNDRCW1sbpiXxvLoekmtaXHfDpbSXu/nXf74LKWJKZRsvyNGesTk6Mcy8BcuZHJkgDEwWLFvP0b5nwImwwnbczHIa3nY61n0Mp3GY5fN6+PjHP86NN55PpV7hH//5bm75wt9QDfbR29FOEsZEiWDDhg3MVCbYtu0ViqUyzWaDKIqIY8mZZ5zLO97xDl555RUeeOBeANpKbeRyBZRStJWzrFi6BCkU+WIBy7KJIp9cPkNluopMwPd99u7dT7VaJQg1F18mASOj4y8rpTb8X+PlH0XQ7upuV1dc/RZ2vLKPN1/0TvYfeJXjT1iF7cD0RAMlYxzHorOrxPDoCG1tRVauXsX7rvsoM9MNUlkLUxgtOL9mAs82iGYPnY+1nMJVy7Kq5RwuDLBaj5PWRFoqbREngjiKKBULekIs1o27crnM9LQeTLEdQRRIjNY23DRNkha6VWf0un5q2vr6Mpm0ZpVEkTZU9RM8z8Oy0CYGUjfvlFJknDT5dAqv3iBSsGzlamaqdfoP9jFv/iomJ/tYs2YlKTvF1PhhFCF+YuI4Ln4zbJn3evo6Lc1YOPesUzl943quvvoyOnuWI5MKv3rs52x5sY+HH6gyMVFnbMrHJIsyIhRTrF69mrdcdglvv66XiUmP4ZFxCoUS85aXGBqcwWvEjPQXmBoNeGnbcwz1TzHQ90NiGWDYDjKaJpvTI9NBIDEth3nzlhAnIRMT4yzo7aKro8S+ffuwHYv3f/jDvLhlG08+9SQYUMgXqdVqrbq7tmRLWrX52fH82SNfSFOrNueQBLaVRkpJw6sBmgQZBk0UzGnsQZc8Tjr9LHZs7SOdy/Dua67nu9/9MoZyWka7UoPyMfXfWwTJKy+/ijBK2Lp9B7btIpsxlZkZgqCBMCCao0ja2rEoSRAiat2LLfMMFSPQcsNUyiGdayORGkEQeMNs3j3GWesW4jgdWEDcuqeiMCCdsmj6NU7deCbT0wF9ByusPfUidjx/K9h9eM2FbN1V4dIzvojo2ozgVCXGAAAZpklEQVSRWNhuDkhj2BkMZZJxYur1EWaGX0aYrQUqkSxYcwP1ao3G1IssOulsXt50H1d+5Uc89vfvxP8/7Z13lB3VmeB/t8JL9UK/7tdqdatbtFoBgUCIIBAS2ZJBNjhiDMaY8WKzXvDAHI/xsdc+44R9bNZD8noYGNsTCGtsZgEbdgwimCCCUM5ZQi11fjlWvPtHVUsyhwm2gZas9zunTlfdqu6+9b1XX9373S84GhHVQ2jXEIq1E23fgmKC7bYicBEhPzVEPJ7EUzSQCqrmL3xKwrhSEIu1oikRwprL4L4V3Pz5xcw9sZtXV/wbd/2ve7A8i0ntEdra0jSqgGpRMxuUilUaNcEpp85l0QV9/G7ZGnbtGsasu3ghi8/+xc/I1Xfw+MO/BWsfST2H40KdEFKEOGvpzaxds4u2aJhT5x7Pk7/5Op+75iauv+l7XHLhHFJpD4HK3JPPQNdg6/YtzDlhHtmxHKO5YS5afCGLF3+Ml19eyT333sGMGX2oCmxcv4ZKuUgkLLBtNzBH+q6pAHGjBaEqJBMtlKslPFFgcscUStUanu0vROtKsLDdlmDD+r1vq7SPCPOIb/N0Oe20uWzbto358xdQrOwnEjXwPI9EPI5l1Wg0ajiOX1XFtu2gwMG4ndFfVNE0gar4I+/xqukhTScWi2E7HrlcDkVAW1vaL3wQjNIiUQMhBPv3D/jT7mABRQ+FKBRKKALUIBgkn8sB/kvAMuWhxS1X4rh++adDkXr+PXqOhwDq1bpfScaFerWGlGoQgehQqVYC/9kwAKZZJx6LUigVcIE1a14PjKsKlfIwZqPOurVr6Zg8hbGhIcR4LXFVEglJOia388FLLqSvbwYXnHcaPT3dHD97OkooTnZ/gc3b9nPrt3/Os8+vJpu3UcXpGPEk8VQY1zKo1R0UamzZupqtW/fRM/NzzF8wn3knX8jry1dz+zfuZsvW5VgO9O/YA4qHkbiY9p4pfk9UBcUpgapiNixcz0MCyWSShunbknVdx7QtNm7ZyoXnncvUab3cfdf/ptGw/Nwsnk2pVPI9Qjy/irnjWgdT6R6e6TEe93OjA/RMmcqsWbNYv349rvRItxo4rsXIiJ/WXddVLNtCKH4mRl/gRWZMb2XPjh28sGI5pyy+gnVP/wZdD2PbdSJhBcv2vwOu69I3fRr5fJ7R0Sye46LrCiIWpWGZNCzfS0cLOUEwl4NQPKIxlVrZQdXDuFLxg5s8D00VTOqYjO1Kuqb0IIRgy6atoOgMDgwHIwyJZVVxXBtV8ZN4Oa6OEAqD+3YzaeosYC9bVq9C1WCwkKY9brLo5DamTTmRYrRCobIDoSh4rovVaICrEELBNE04bMFWEwr9B9Yz75RzWDcYY+eqtfz9L19jz+ZtOOiExBAVx6Cv92x2730Tq1AhqU/Bdmt4DsSjyWDRW/h5woWK6yhITUPVQn5REtHAUxVQFLqmnso3v3U9s2eczCUXX8S3f/Bj8vkxfviDbzI8NogehnS8g5Gx6sFygGvWrKNWs1i48AR0vZN1a1aBA//4s+v43t2P8viDPyfS1kapXEFIi9ZkH9nSVgb27iTVFccc2ENlzOP8i6/mo9d+kd8++yi9mQ7y7iBXfeozvPLKa2zbshXDMHj0yUdRlRj33H0/uq5w5ZWXUCqVCashVr66FxWIRnTaW2IoeBBRiUYnUamWMAyDSqNOo+75NScthbCWQldDJLVJIMqMZIfQNI1So4JhREl2tQN731ZfHhEj7Xg8KS/78PmccupcfnDrPVx77bX0HBchEgljm359RU2XRGM6+w8cIGZEmXX8bG64/svksmVicX/hxLE9f2osfKWNVCiX/YdH1yCViBOJ+AmMTNNfuY9Gw5SrJuWKCSjEYhFqtRrgRyzCIXcxoQZFEn4Pf8o8HnwB4EkPVRkfVY0rlaD0+Vt/W2h4UqAqJlKCHori2s7B3MqTO9v44W3f5bS5J5FK6Tj1EBWzTsOuo4c1EDqeYtESbUVFUqmZaIqgVs1j2VUcu0gyZaDFWhgZcviHnz7D9m1Zdm7WaGuZDkLH8hIUSnkUJU65sptYwqFujuGYu8EboHNqD9X6HkojVdCqgbVAAAaaruNKl3QixpxZZzDv458gnJrN3/6P+cRcDQsHW2j+FN7z044KITCiETwE1UqFG268kZGRER755aOAg1Dxq8I4/uLx782YxLhP+aHMeOFwGNM0WXj2fIrFIpVKDWSIoaEhMpkMqVSCSj3P/v0DtKQi1Op+PpgzF55FrdZg/Zr14ElAp+c4jXotzdjYAP/4yKvUPZMbrlrs18V0FFzPRAJnL1qAEJJXl7+OlNDddRxtmXZG8iUikQjDA29Sq5aJRgw86aCqUWp1f1FSKApSDdPS0UO1XKAtESaTSrNr3xANy6+QhGvhmUW6+07kg5dfzd/d9l3AQJHl4OXsIhQV6emgqIQ8i3TPDHL7s9iZE3h1xS+Y35tBBPV/d/TnOX7Wt4l2b0GxbHA1hIxgNySTW8MMDG3Hrm0F6ZubdKky56xPctmHP82/PvUrtu49wLRJ3ewcFNx7+3/j6o9NwzBTlPUQychfkuyFem4PmUl9lMv9VGoVWtvbqVQqGPHWwLsniaIomKbmuz0aOlLqqF4YRVhMMcr0dh5A12tk8y4vvvAyiVSS9kwrV199NTHD4J8fuJ+N69bTqFXItGXw3Dr5ehVpwpKLz2eof4zhoSzD1SHu+MmD7Fq3k3t+/E10o5vjTzuPUrVGsQH1epmW2hiDo+uYc95fcsLsXh659xt85cYbWbtvJwsXXcCOLRv50KUfxbZV2jsn8/DD97Nh7evYDZNKOcvAYD/1muP7tgOKBvF4hETCQIoGtt3AbAgSiRjSkZSKVcIRBbPh0Wh4RNMgGxASCq0tSYqVMq2tLVSqdUbGatg2R+5IW0ooVcpouqRcLlOrmlTL/pTKsT1i4Qim06BcqmKZJvF4HF31AxBcV1Kv+dNk34bpBPUNBa707UPhkEYqESMU0shli0jPIxo1gtEK+PmgTD+ZS2DjHK8JOY4QIniw34qviH0PhkNK+VBI+/jvOAf/jt82ruADNy8vCIk3nSDxksczzzzGonPOZGBoF/1vFtiwoYRl12hra/X90L06kYgvg2x0r18J23PRtQjhUAIjkSaZOI3tO/r56X2/YMPmQYYHBEa4gyndp5LN1ygXLTylBKg4tV2gVamVNyOdHLCfM89dzKmnz+S5Z2uosohtJ6mWhoNERBaOXQKpUa+bFKtZXnthPQf2PYZ0dRzh5xBG+km4UMcXXTyq1TqJVJKrPvUpli1bxo5t24PkXBEsy8KxzeBz8IspeJ4T2KE1P1G/478QI5EY9XqVM06fi2mbVIolOjp7WLlqHZMykxgZGWI0O8T5Fywi09ZCLjdG3FBRNJV6zaZe879PlVIZhM3+N21mzurBcrrYuWkVn/3CdURaWmjkxvAwAI9INESjYbF7905kYG/L57Mouk4q7edPDsfSmI7ANGt+rnWrAlIlFG8lPbmHrr5Z5Af3URweotCoIE2bejkL6ChCxWyU0UI6F114MaOjOZRoO16thIfrV5XBL7FHUL3IUjQsq4ZHlc6U4JEHNnLGNxbSqIPQNWZ1JcDUkWYEabsIEUY6HoQklrTAtUBqgEskrFBvOJxy1jx6ZvVyWejDbL7li/RLiOUSVMs5tMYpuFGBocBHrj2P559egRb2yI+sIJKYiu5KKmOjuLZN0bKJhaPUGy4oHl2d07Eth7pVI5bIUC1L0vF2hnN5Xn3xaRA5FMVDuBqa5rJlbB//8ysbae/M8ImPX8l5Z53Lxq2bWbnydbKFqr/GoMLoSIGZJ8zm3CXHkWmfzOY16wlFwsxbeCmbN2+hUKuwb/Vy4nMXY+55kWy6je6eeXxg4cn8bsM2km3Tue2eH4EHrz3/Iks/cBk7dvfzL//yT9QKORaeew4f/chf0N7aiapDw6zSv28XQ0OjmKbJ08t+w9joIKV8fjxnBenWCHHDoFqpYyTixKJxBipDuB54DYVoOIKiKIyVapimS2MkixBhLlhyBsv+38q31ZdHxEhbD8Xk5Z9czKxZ3dx26885Ze4ZXLj4dBy3TqFYIxqOYMQjnHjiLEZHR6k1qpx00jxu+MKXGRwYJRoNB3mu/RX9SCREJBqitbWVbDaLWa+TMKJooQiKcijdaj5f9KMpFQXHPTSqHles49s4bw3U+FM4ZD4JlHcQYSeAq666nC/f8iU2blpFS9ogFPZoaU1Tr7mBC5iJqgoS0XbqZo6urj4aToG21skUsl2sWbmbf/j7l9j3Zp5CAVQtQvuUNgr1HIV8CM/xvyjl7C6E2IMUK0FWULwSk1o7GcqNcuVnr2HpJVfy4zvvZdUrL6IqKomWGkuXvp/sWImnn1qG0IIc0PiRjkJt4aqv/5QpPVO5+/r5aFIGpX41hJCEQr65CuCKK67g6WeWUcjniUSjNGr1gwE/hwolewc/C1VVD30mAr/WpAKGEebkuXN43/sWMrmzm7/5+neoVuuoagzHcVEVF9M0Oa63C9eq+YuZNrS2tTM4mkPTQiSNGINDB8hnx1BVv16jpkZwXAfwMFoyTJ4xm10rN9HWqtFzXDfr1q8Jshb6vueO46GHopx06kJA8YtFux6KalCp1enpnkpbRxct6QyqkaLmONjFAda+9izb172GKiSup9LdO4P9b24G1yMcVonG27jgko/z0ksv4VSKlPMH8KS/huLb2kVQ1VoHqTCpI8PIYI3e09/P97/9V1x2yalEGEWqcWZM+yb73nyTZFcR23XQZAol1CCqeQzt2YhQRkHYCM9Dj0QwzQ7w8ixY+kle+7eHCEc6sRo7ueaGb/GTO/+asGjgKBAlg1A/zXHH2yz68AJ+9+sXmHvi8ewdHqCSy3P+RReyfv0G2tLdpFtbWP7yCjJtk8hXbVQ9jitjSCmolUeYNa2Dgf7t5Pb9AiMcJ1es4NeI8AOgIpE4QqhMam+joyPDiXNmUywWKRbzPP/8c4cFVwmkUFiw6DxOmruAQr7Kow/dictUOk46meHNL9A753gcK4ajpegIR9mw5lc88/ImQOWic08AKQlpBiEtjIdLV1cno2PDJGIpBkeyQb6bGorw/58RS/qLp6EEqWQ7l3/8arq7u7GsGvWaR7VUZ2R4jFdWvEyxmGOksJHC2NDB515KSGWSPPDAY3zmumvJH+g/gkfaHliWn0R8cuckNm7cyNJLz8VxBdMzHdQqVRCSoaEhhkdHMAzjYPJ4IEj/6Y+0I5GIX7XFbTA4OEg0GiXd1grSRVM1pFSwLIt83q//5zien0/3v6CH/1RlPR5BB+NfLH/xQVFBUWHG9G7uuONvmTlzJv39/UyePJloTCcWC+NIk5ihYsQjeBLC4SgpowMppxKPT2bNGxVeerqfv7vn+xQKDUwrhaanaO/qpVKzGRwsI0WUpKFQK41SzO5CYQghtuJ6w6AoRGIqI/lhHn/6Mfr6TuKiRUsZHeoHIqiKSms6Q0/Pcfzy4bt97xPHT9rvehI1FOWKK66hq7eXWrWGKUOYeKjCxRMK0vMDbKZMmcL8+fPZtGUzhXwehKBRqx/mAXJYNaLD2saV+Xi7ogo8z6Gzs5Ph4SHWrFnDhvsfIp8vEQrpxOIGpVLZz90hPXqnTkXaDfL5LOFYAs91adT9PN+KotDW2s7Y6Ciu52dERLqoOAhNw6yMEREmMxcupjGwmuHhUd8OrsogKMYGFCzTdwVsSbcRjhjULRsj2UbKcmib1IWtqBQaFiEddu89wLxZnVz2kU9w+/o3UJAYLa1Mnz6T/bs3EQ0ZWE6NQnYETRE4Vp10Jk0x59cXHFfYQvFfEHgmyAjRSBIh6nT3JPjnB5dxwTnTiaYaOGYrt9/5BS6//EtY9RBRoxXLrqELDccuIVQP6fnTIgHYlgvhMBqdvPbMs7SkZ1AobCIRm8LaDfsx9BjCtahQJqykibb0kklYjA2NMPzmTiqd3ZiVLPu3bMBachGNRp21a1dwzjnnYJs5kqlJGC0p9u4bpmvqKeSLVaLRDrbs3Mvxfb049UlkRwqEwila0gZz5pyMkTRYtGgJuWyRjetW8/qKl3hj1Sqk5xIzDJa8fymjY8NkR3OMjY1Qb1i89vKLaKFW+vcPc8sPHuGl51+gf7iKTpS9G9ahoiISp3DfU09iqPdx1w+/wOOPPYwiwyQTGVpaE9QbJVTFY3RkAE2EMKtVMpk4pmsRCmeoVHzvFhuPwewITn0vCI91a58LorI0jOgMFl90Lpn2Vj73+auRUmB5koEDOxga7KdazlGpVFi+cjfbdpTID4z8u3rkiFDanvTrDzpug/POOZuHHnyUes2i2ijhCaiUSkyalKG9vQPTtgKXK422TIbBgVHC4ejBh6da9X2iFUVBoNOoW1TKNd/FL6JhNnwzhe/yJhDKeMEC+z/u5DvAeARdcNeoGpx77kK+9/1voWpVTLNOqZRndGyAlnQKXYsc9IJxXZU9e4fIjlZYtWKAA/vKrFr9JvWajWenaUm3o+pRkskFhBWbql3DFZCtZjHtGo3GCI3CAeIZh3gS5va56HqaN5YPoeGPan90153MO/19LFywFKj7xlDFBZHDAvr3xfjpfQ/5GRNdNShDpvj5MSx4efkbGKUWzj7vAoSmIRwLqehIz2P+mWcy56QTePD+B3jyySeRIigei19vcjzP+O/Lyufw4BiASz94KU/8+jfousr27TtBwOc/9xlCepRyYTm5fBlDgB4J4TRscB3GRkb9ACpVY1//flBCWLbAtiVj+QKK4pFKRykVTaTr13tREKiOgxOJsvWN1UQmVelMt3HggB9iPF70QVVV0KMkW1rZtGkTmbYOps8+GT1q4HgarhIiX3UJx8I4lmCwfx/TjpvKG2+8xuY3XkJxJaGWNE+89CyZTDu3/PckT/32cbDDoFTQFJVSOYeuSJLpDOVCkXHzmvQEQlWRXg1NE4yNDdPZleHV5c+hJ86kM5XEdqvoosJHP9TH7Xf+jFtv+yLS0XBxwY0wNtrvm0eEP6VHKHiodEzto1YOEYtKyqO7UTBwFFj/6u8QUqGsZDHopWJJvnzTFXz31pv43i3fYc+eYapCoVqxSHVNpZArcuDAAEuWLKFRM4lGPBItkq3bd9CoVXHVFjKTQwzu3Muicy5gw4pVnL34a6TiOq8//ySF/A6ee+EV8Dyee3UluqrSEjGIGilmZrqDgiVR9h/Ik80VSRgx+qYfT+/0PjZv3k0i3c7slsk88fijfPU73+HTH7sGXRfcdOuDfOlLH2OGlubaj1xIqmM6F196Hm2ZtXS0ezhuDSkrxOMhGtUGsXAMx26g4GE6HigCr1bAUCWW468FhKIRiCaQqkfDqvjrYJ7EdXfy+uoDSCl58OEf4TgQb0lTGBs5LJ9ZiGuuv5k9/dvpmTaN/t1b31aPHBHmESHEKFDlLRXbj0EyNGXQlEFTBtCUAcBxUsr2tzYeEUobQAix8u3sN8cSTRk0ZQBNGUBTBv8RR0Rq1iZNmjRp8l+jqbSbNGnS5CjiSFLa9010B44AmjJoygCaMoCmDP5djhibdpMmTZo0+c85kkbaTZo0adLkP2HClbYQ4hIhxDYhxE4hxFcnuj/vFkKInwshRoQQGw9raxVCLBNC7Ah+poN2IYS4O5DJeiHEaRPX83cOIUSPEOJ5IcRmIcQmIcTNQfsxIwchREQIsUIIsS6QwbeD9mlCiNeDe31YCBEK2sPB8c7gfO9E9v+dRAihCiHWCCGeCI6PORn8MUyo0hZCqMBPgKXAicBVQogTJ7JP7yL/BFzylravAs9KKWcCzwbH4MtjZrBdD9zzHvXx3cYB/lpKeSKwALgx+LyPJTmYwEVSylOAecAlQogFwA+BO6SUM4A8cF1w/XVAPmi/I7juz4WbgS2HHR+LMvjDOTzHxnu9AWcDTx12/DXgaxPZp3f5fnuBjYcdbwM6g/1OYFuwfy9w1dtd9+e0AY8DS45VOQAxYDVwFn4giRa0H3wugKeAs4N9LbhOTHTf34F778Z/QV8EPIEfKnxMyeCP3SbaPDIF6D/seH/QdqzQIaUcDPaHgI5g/89eLsEU91TgdY4xOQRmgbXACLAM2AUUpJROcMnh93lQBsH5ItD23vb4XeFO4CscSo3ZxrEngz+KiVbaTQKkP4w4Jlx5hBBx4F+Bv5JSlg4/dyzIQUrpSinn4Y82zwRmT3CX3lOEEJcCI1LKVRPdl6ORiVbaB4Cew467g7ZjhWEhRCdA8HM8tdefrVyEEDq+wn5QSvl/g+ZjTg4AUsoC8Dy+KaBFCDGewO3w+zwog+B8Csi+x119p1kEfEgIsRf4Bb6J5C6OLRn80Uy00n4DmBmsGoeAK4FfT3Cf3kt+DVwb7F+Lb+Mdb/9M4D2xACgeZj44ahF+btWfAVuklLcfduqYkYMQol0I0RLsR/Ft+lvwlfflwWVvlcG4bC4HngtmI0ctUsqvSSm7pZS9+M/8c1LKqzmGZPAnMdFGdeADwHZ8u97XJ7o/7+J9/h9gELDx7XXX4dvlngV2AM8ArcG1At+rZhewAThjovv/DsngHHzTx3pgbbB94FiSAzAXWBPIYCPwN0F7H7AC2An8CggH7ZHgeGdwvm+i7+EdlscFwBPHsgz+0K0ZEdmkSZMmRxETbR5p0qRJkyZ/AE2l3aRJkyZHEU2l3aRJkyZHEU2l3aRJkyZHEU2l3aRJkyZHEU2l3aRJkyZHEU2l3aRJkyZHEU2l3aRJkyZHEf8fDb2D/4yCVOQAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "for i in range(10):\n", + " print (d[2][i])\n", + " plot(d[2][i])\n", + " input()" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(256, 256, 3)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/rajath/anaconda3/envs/onesod/lib/python3.6/site-packages/ipykernel_launcher.py:1: DeprecationWarning: `imread` is deprecated!\n", + "`imread` is deprecated in SciPy 1.0.0, and will be removed in 1.2.0.\n", + "Use ``imageio.imread`` instead.\n", + " \"\"\"Entry point for launching an IPython kernel.\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQYAAAD8CAYAAACVSwr3AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAfh0lEQVR4nO3de5BU1bn38e+ze24oDJcwIhnAwSOJJSgcGI0kRo1Rj5cYExMiMSpBLEKi5Jx4e9WTP1JJhUpiYspLjuJRfNGypIgkSgwnL0qSsk40KFhyEYOA3IZ7EHG4DPTlef+Y3k0PPZeemd69VtPPp6prenb3dD/T0/Prtddeey1RVYwxJlvgugBjjH8sGIwxOSwYjDE5LBiMMTksGIwxOSwYjDE5IgsGEblCRNaKyHoRuTeq5zHGFJ5EMY5BRGLA+8BlQBPwFvBNVV1T8CczxhRcVC2G84D1qvqBqh4F5gHXRvRcxpgCq4joceuBrVnfNwGf6ejOgwcP1oaGhohKMcYALF++/J+qWpfPfaMKhi6JyHRgOsCIESNYtmyZq1KMKQsisjnf+0a1K7ENGJ71/bD0tgxVfUJVG1W1sa4urxAzxhRJVMHwFjBKREaKSBUwGVgY0XMZYwoskl0JVU2IyO3A/wNiwBxVfTeK5zLGFF5kfQyqughYFNXjG2OiYyMfjTE5LBiMMTksGIwxOSwYjDE5LBiMMTksGIwxOSwYjDE5LBiMMTksGIwxOSwYjDE5LBiMMTksGIwxOSwYjDE5LBiMMTksGIwxOSwYjDE5LBjK0DnnnENdXR133XWX61KMpyJZcKa7Ghsb1WaJjt6pp57Krl27Mt+LCKlUymFFpphEZLmqNuZzX2fTx5viCoKA8ENARFBVfPhQMH6yXYkTXH19fSYURISGhgZSqRS1tbWuSzMes2A4AQ0YMAARQUTYsWMHI0eORFVJpVJs3LgRgDPPPNNxlcZnFgwnmFgsxv79+wGorq4mlUqxYcOGnPtNnz692KWZEmLBcAKpra3NdCaec845tLS0dHjfadOmISLFKs2UGAuGEjdp0iSqqqoQEZqbmwmCgFWrVrFixYouf9Y6H01H7KhEiaqpqeHIkSNttokIyWTSUUXmRGIthhJy6623UlVVRRAEmVAQEaqrq3nwwQe7PSZBRFi3bl0UpZoSZy0GT+zatYv6+npSqVSHTXwRIQgC6urq2gxU6ilVzWl1GAPWYnDuggsuIAgCTj31VJLJZJtQqKqqYsiQIcyaNYt9+/aRSqVIJBIFCYWQBYNpj7UYHOnXrx8HDhxos61v376ceeaZvPXWW0WpIQgC5s6dy4QJE4ryfKZ0WIvBgSAIMqEgItTX1/PXv/6V5ubmooUCtI55+O1vf1u05zOlw4KhSKZMmUJFRUXmPAURYejQoaRSKZqamrjooouKXtOoUaP48MMPi/68xn8WDBEKhyWLCM888wxBEPDAAw9khidv377daX233HIL8XjcaQ3GTxYMEamvrwdaw+GTn/wkqsrRo0e9mgNh0qRJNsjJtMs6HyOyY8cOBgwYwL59+1yX0qERI0a4LsF4qlctBhHZJCKrROQdEVmW3jZIRF4RkXXprwMLU2ppUVUWLVrkuoy8zJgxw3UJxjOF2JX4gqqOy5oZ5l5giaqOApakvy87lZWVfOELX3BdRl7mzp3rugTjmSj6GK4FwnfaXOArETyH96688kqOHDnCli1bXJfSJRvkZI7X22BQYLGILBeR8AT/Iaq6I319JzCkvR8UkekiskxElu3Zs6eXZfjnpZdeAuC0005zXEnnwsOnP/jBD1yXYjzS22C4QFXHA1cCt4nIhdk3amuXd7vd3qr6hKo2qmpjXV1dL8vwUzjfwdChQx1X0rGwRpuM12TrVTCo6rb0193A74HzgF0iMhQg/XV3b4ssVeH0aYU8t6HQYrEYIsKhQ4dcl2I80uNgEJGTRaRfeB24HFgNLASmpO82BXipt0WWqjVr1mSa6meccYbrctrVp08fALZu3eq4EuOT3rQYhgD/KyIrgDeBP6rqn4CfAZeJyDrg0vT3ZWv48OEAfPDBB44raV9tbS2qyt69e12XYjzS4wFOqvoBMLad7XuBL/amqBPJ5s2bM9O3V1VVcfToUdcltXH11Vcze/ZsGwFp2rAh0UWQSqWorKwkHo9TVVXlupw2Hn/88czuzrhx41yXYzxhwVAkb7/9NoCXJy3169cPgPXr1zuuxPjCgqFIxowZQ01Njesy2hWOtTh8+LDjSowvLBiK6IEHHgDg17/+teNK2rr44osBm07eHGOrXRdZVVVVZu5Gn4QdpPPmzeP66693XY6JQHdWu7YWQ5EdPXqUZDJJEPj10j/00EMATJ482XElxgd+vTvLRHgUYMCAAa5LyZg5c6YtWWcyLBgcOP300wHYv39/pt/BB+GsU8ZYMDiwfv16KisrAbjnnnu8WQ3qnnvucV2C8YQFgyNHjx7NNN1Hjx7tuJpWM2fOBEp3RqeKigqCIOjwEovFOr29q0tlZSV3332361+zKCwYHFq4cCHQOujppz/9qeNqWtXU1PDyyy+7LqPbfvKTn2RW8uroEi7/19NLIpHgwQcfdP2rFoUFg0Nf+tKXuOGGGwD44Q9/6LiaVmvXrmXbtm08+uijrkvplkcffZSamppe/eN3drnuuutc/4pFZcHg2HPPPUcsFnNdRkY4c/Qdd9zhuJLuSSaTkR5V8aUfqFgsGDxw6623An69+eLxOPPmzXNdRt7ChX2iEoa3b+NPolIev6XnHn/8cYIg4Oyzz3ZdCnDszX///fc7riR/UY/BCM8j8WGkcDFYMHhiypQpHDlyhK98xf2k2qeccgpAScxwnS3KcAgnLA4PM5/oLBg8MWfOHKB1dulHHnnEaS1f/vKXgdb99lIRj8cjrXf//v0ADBs2LLLn8IkFg0fCVbC///3vEwQBTz/9tJM6Zs+enZlQpqKiNFYxDCe1jUoYOj71A0XJgsEzqVQqcy7FtGnTnNXxm9/8BhEhmUxmWjM+q6ioiPzoTjmdS2LB4KFUKgW0tiCqq6ud1HDrrbdmOiFvu+02JzV0RziAKUoWDMa5b3/72wBOJ48NWywtLS3OashXMY4WWDAY555++mlqa2ud1jB79uxMqyGcBt9XxQiG8GhNObBg8FjYE+5yRqUwELZv3+6shnyEE+BE6dJLL4308X1iweA5VWX+/PnOhk1v2rSJWCwW+f57b1VXV0f+Gp177rmRPr5PLBhKgIhk1qZwIfyk9Hnat6iHREP5DG4CC4aScMkllwCQSCScjCv405/+RE1NDQsWLCj6c+crHo9HPsGuBYPxyquvvsp5550HtA60CReiLaaFCxd6PRIynIQlShdeeGGkj+8TC4YSsXTpUiZMmAC4OXx42WWXoarMmjWr6M+dDxGJLBhWr14NwKhRoyJ5fB/ZuhIlqLKykmQyWfQOwXAf3of3zPGGDBnCgQMHOHjwYMEfu0+fPgwYMIAdO3YU/LGLydaVOMHF43FUtej9DWEwjB8/vqjPm49w2rYotLS0lNyMVr1lwVDCkslkUQce9e/fH4CVK1cW7Tnzdfjw4UiC8tlnnwXga1/7WsEf22cWDCUqDISmpiYef/zxojznL3/5SwAvxzQcPnw4klOiS2kWq0KyYChRW7ZsyXS2FWt+xvDcCVXlj3/8Y1GeMx/XX389qVQq8+leSB9++GHBH7MUdBkMIjJHRHaLyOqsbYNE5BURWZf+OjC9XUTkYRFZLyIrRcS/ndECueuuu+jTp4/T1ZtWrFiBiNDS0lL0eQIGDRpU1OfrzAsvvACQOWpTSBs3biz4Y5aErqbNBi4ExgOrs7b9Arg3ff1e4Ofp61cB/wMIcD6wNJ+puSdMmKClJggCBTKXqD311FM6cOBAjcViKiIqIm2ev5wvIqLjxo2L5HUP/84nAmCZ5jldfpe9Nar6mog0HLf5WuDi9PW5wF+B/5Pe/ky6iL+LyAARGaqqpX2cpxPhpCpROvnkkzl06FC7twVBQH19PYcPH0ZVCYIgcyizurqalpaWNucQhMvdJxKJnJmP4/E4lZWVpFIpgiDIfAXa3F9EOHr0aOb7yspKEokEIkIikaC6upojR45QVVVFMpkkFotl7p/9/GFnYfbU7+HXVCpFLBbLPG8ymaSiogIR4eDBgwwcOJBDhw5RXV3NTTfdFNkaoFH/bX3V027cIVn/7DuBIenr9cDWrPs1pbedsMFQX19PU1NTJI/d0NBAU1NTZsRhEAScdNJJDBw4kJqaGmbNmsXXv/71SJ7bwPLly8s2GHrd+ZhuHXT71ROR6SKyTESWhTPwlhoRYfTo0YhIwXqvZ8yYkflk3Lx5c+bTdMyYMSSTSZqbm9myZQvvv/++hULEvvGNbwB4tSBQsfQ0GHaJyFCA9Nfd6e3bgOwD68PS23Ko6hOq2qiqjXV1dT0sw53jdyFee+21Xj9mRUUFs2fPzrQQRITa2lo2bdrEqlWrev34pnvClmA5TdAS6mkwLASmpK9PAV7K2n5z+ujE+cD+E7l/AY5Nvfbxxx/3+DE+9alPZfajofUTatasWaRSKfbv359ZNs4UV/j38H32qkh01TsJPE9rH0Gc1j6DacAngCXAOuBVYFD6vgL8BtgArAIa8+kBLcWjEqeddpoCGgSBDh48WCsqKvL+2RdeeEGrqqra9KzX1tZGWK3pifDIzx133OG6lIKgG0clIlsduDuXUgyG119/PfNP/cgjj3TrkFZ2IARBoK+//nqElZqeCv9G77//vutSCqI7wWAjH3to4sSJmev5TuAxe/bsNof8rrnmGpLJZJvHMn644YYbgNa/Uzmdbh0qjWWGPFVRUUEikcicQ9CZhoYGtmzZgqoyePBgSvVITLl48803gfI8IgF2rkSv9OvXD2g9b6Gj+QbnzJlDEARs3rwZVSUWi1kolIBw7oVwqb5yY8HQC+G8BMlkst2BMFOmTGHatGmZ2/r27Rv5vISmMMJl78844wzHlbhhwdAL4WpRHc2F+Mwzz2TGO6gqzc3NRazO9NSPf/xjoLV/YcWKFY6rccOCoRduvPHGNrsQ2eP1hw8fjogwd+5cF6WZXmhubi7bodAhC4ZeGjp0aOZ6GALPP/8827a1Dvhcs2aNk7pMz4WT7ZbTWpXHs2DopTAAAPbu3QvAfffdl9l9+NWvfuWqNNNDYf9CObcaLBgKIBzHEAbDzp07M7clEomynR6sVJXTwjIdsWAogPB8iXg8zuzZszly5AgAw4YNQ1X51re+5bI80022K2HBUDDhQJjvfve7QOubauvW1qkpUqkUc+bMcVab6Z4lS5YAFgymgML90osvvhg4Fhj333+/q5JMN4W7gi7n83TNgqEAGhoa2oxliMVi/PnPfwaOHbUI+x+M/8JBaLfccovjStyxYOiFP/zhD8RiMTZv3txmGfbsdRe++tWvAh0PgjL+KrdFZrJZMPTCddddlwmBVCrFpZdeCtBmcdWHH34YaN3FCBdHNX4r58OUIQuGHtqyZUumFRC+kRYvXpyZATnbmDFjABg7dmxxizQ9Erb+qqurXZfijAVDD40YMQJVzavnOpyv0cel3UzH3njjDdclOGPB0EvdbXb+7ne/i6gSUyjhqNXs4e7lxiZqKZKwZbFv3z7HlZjOhPMviAiXXXaZ42rcsRZDASxfvjyv+6lqhytKGT/E43EAvvjFLzquxC0Lhl4Il1j7zGc+0+7tItLmCAUcGz5t/FVTU8Mrr7ziugynLBh6IR6PU11dTTKZJAiCzEVE2swV+Pvf/z7TUXnnnXc6rNh0ZObMmYgINTU1mbMry5n4cMy2sbFRly1b5rqMHquoqOhwAFMsFuMTn/gEu3fvzizSavwT9gH58P8QFRFZrqqN+dzXWgwFkEgkMhPDZq/aPGzYMBYtWsQ///lPAE477TRnNZqOhbt75XzS1PEsGArk4MGDbb5XVa6++mq2b99OKpVCRPjLX/7iqDrTnrFjxxIEQaaV8NBDDzmuyB+2K1Eg4adNQ0MDmzZtavd2G+Dkj1GjRrF+/Xqg9W/z2GOP8Z3vfMdxVdHqzq6EjWMooOrq6kzHVRAEbYJAVQmCgEsuuYRXX33VVYllZ/Xq1YwbNy7nbxEaMGCAjS1phwVDAXz+859HRGhpaWHkyJGZsfbZb8DFixczadIklixZkmld2Juydz796U+zYcOGTMfv8a95qH///kycOJHa2loqKio4//zzmTlzZrHLLSkWDAWwdOlS+vfvD8C5557Lpk2bcnYbLr/8cvbv3w+Q2a/96KOPMiFRUVGRGVxjjlm9ejUTJ07k4MGDXR4xCG8XEU455RTuvPNO7r777mKUecKxYCiAeDzOk08+CcD8+fPbdGi1J5VKcdZZZ/GPf/wjc79EIoGIUFlZyRVXXMHChQuLUnuxiQg333xzl+ttvPHGG1x55ZWZMO3osU4++WRmzZpFMpkkHo9z+umnl/U8CoVinY+9NG7cOFasWNEmCMJgyOe13bJlC2vXruW6667jwIEDUZbabR01zYstCAKGDRvGvHnzMoeFly5dyrRp0xxXVlqs87GI1q5dm3P8uzv/UCNGjGDEiBE0Nzfzve99jyeffJJEIuHFP6RrQRB0OHAsnOPCRMNaDL3U3oi5cCSkD6+tb8phhKGvbORjkbzxxhslMVrOx6Xc8z0j1bjRZTCIyBwR2S0iq7O2/UhEtonIO+nLVVm33Sci60VkrYj8W1SF++DFF19sdxYnnwYy3XTTTcTjcV544QXXpQCt546ICDNmzHBdiulEPi2G/wtc0c72X6vquPRlEYCInAVMBkanf+a/RCTWzs+eEGpqatrMDg3w1FNPedVMfvbZZwmCgBtvvNF1KQD06dMHVc1Md2f81GUwqOprwId5Pt61wDxVPaKqG4H1wHm9qM9r69atywmBRx99FPDrhJyf/exnmWXzXAsnxLUxG37rTR/D7SKyMr2rMTC9rR7YmnWfpvS2HCIyXUSWiciyPXv29KIMd7Zu3ZrTYgiPu/u0MGo4yMeHlZXGjBnjVWia9vU0GB4D/gUYB+wAur3Wu6o+oaqNqtpYV1fXwzLcWrp0KarKoEGDMts2b94MwODBg12V1aHt27e7LiEzvsOn3S2Tq0fBoKq7VDWpqingvzm2u7ANGJ5112HpbSekcNKVqVOnAvC5z30u0/F4++23O6vLZ9mTrRp/9SgYRCR7Xu2vAuERi4XAZBGpFpGRwCjgzd6V6K/wU+/nP/85q1evzqxDUF1dzX333eeytBzhP+LNN9/stI5wUhRrMfgtn8OVzwNvAJ8WkSYRmQb8QkRWichK4AvADwBU9V1gPrAG+BNwm6qWxaKNY8eOzZxa3dLS4rqcHOEclAsWLHBah4+vjcnV5ZBoVf1mO5uf6uT+PwV+2puiSlG4C7FixQrHlbRv/PjxvPnmm85nqQ5n1rZdCb/ZyMcCCD+NR48e7e0Y/rPPPhtwv+p2GAzGb/ZX6oWdO3cyduxYmpubc+Z89M0HH3wAuP+kDlss1sfgNwuGXhgyZAg7d+50XUZefPmkrq2tBdwHlOmc7UqUCdd9C6Hdu3cD1mLwnQVDmfBlJGb2Cl3GXxYMZcKXgUXV1dVOn9/kx4KhTITT2rtuwvvS12E6Z8FQJo5fdduVcLyH65aL6Zwf7xYTOV+CITz923XLxXTOj3eLiZwv4ywsEEqDBUOZCE8Dd92Etz6G0mDBUCaam5sB95/YPs2HaTpmwVAmfJkpum/fvoD7lovpnAVDmQj/EV3/Q4aT27huuZjOWTCUCV9GHPq2DJ9pnwVDmWhpafFiLUrrYygNFgxlIlxo1/WuRDhxrus6TOcsGMpEOCTa9Sd2OL2+65aL6ZwFQ5kIjwa4HgE5cOBARMR5HaZz9tcpE2Gnn+sWw4EDB1BV53WYzlkwlImamhrA/b69L/NCmM5ZMJQJXz6hw8loXQeU6ZwFQ5nwZYDToUOHAOt89J0FQ5kIA8H1P+Qpp5ySsxCw8Y+d6lYmfJkMdu/evc7DyXTNWgxlok+fPq5LAI4dNjV+s2AoE770MVjnY2mwYCgzrpvxthJVabBgKBPh2ZWuP6ktEEqDBUOZ8OUw4dChQwH3AWU6Z8FQJnw5N8GWqCsNfrxbTOTCmZNcC8+uNH6zYCgT4eFK10348OxK13WYznUZDCIyXET+IiJrRORdEfn39PZBIvKKiKxLfx2Y3i4i8rCIrBeRlSIyPupfwnTNlz4GO4mqNOTTYkgAd6rqWcD5wG0ichZwL7BEVUcBS9LfA1wJjEpfpgOPFbxq021hILgOBlvUtjR0GQyqukNV305fbwbeA+qBa4G56bvNBb6Svn4t8Iy2+jswQESGFrxy0y3hP6TrJnxTUxOq6jygTOe61ccgIg3AvwJLgSGquiN9005gSPp6PbA168ea0tuMQ74EQ79+/Zw+v8lP3sEgIn2BBcB/qOrH2bdpa/x36yNARKaLyDIRWbZnz57u/KjpAV/Wc7BdidKQVzCISCWtofCcqv4uvXlXuIuQ/ro7vX0bMDzrx4elt7Whqk+oaqOqNtbV1fW0fpOno0ePOm8tgD+HTU3n8jkqIcBTwHuq+mDWTQuBKenrU4CXsrbfnD46cT6wP2uXwzgSi8Wctxbg2Bqaxm/5zMfwOeAmYJWIvJPedj/wM2C+iEwDNgPfSN+2CLgKWA8cAqYWtGLTI76cXTlw4ECnz2/y02UwqOr/Ah29m77Yzv0VuK2XdZkCC+d8dN1qOHjwoNPnN/mxkY9lIpwHwbXa2lob+VgCbGq3MlFR4cef+tChQ85bLaZr1mIoE74Egx2VKA0WDGUiHo+7LgGA/v37A+47QU3nLBjKRDiDk2u+BJTpnAVDmfBlJSpfTuYynbNgKBO+HJUI2a6E3ywYyoQvLYYgCBARazF4zoKhTFRVVbkuAYDt27ejqtZi8Jwfx7BM5MLDla7+IR955BHee+89FixYAPjTGWraZ8FQJjZs2FDwx5w6dSobN25k3759pFIpmpqa2L9/f6e7CZWVlUydOpXZs2cXvB5TOBYMZWLXrl2ISK/mQ5g4cSLvvPMOR44cyauPQESoqqpiwoQJ/O1vf+vx85ris2AoEwcOHEBVGTlyZLd+7pprrmHx4sXE4/F2wyD7rM1YLEbfvn357Gc/y8svv1yQuo0bFgxlIjwqMW/evE7vN2PGDObMmUMikcgJAhEhCAIaGhp48cUXGTNmTGT1GrcsGMpE+E9+/D/z5MmTWbRoUaZF0Z6TTjqJYcOGsXbt2sjrNH6wYCgzQ4YMIRaL8fHHH9PS0pIz8ElEqKmp4dRTT+Xpp5/moosuclSpccmCoUzMnz+fqVOnsnfv3sw4gr59+/LRRx+5Ls14yAY4lYlJkyZx4MABEokEyWSSRCJhoWA6ZMFgjMlhwWCMyWHBYIzJYcFgjMlhwWCMyWHBYIzJYcFgjMlhwWCMyWHBYIzJYcFgjMlhwWCMyWHBYIzJYcFgjMlhwWCMyWHBYIzJYcFgjMnRZTCIyHAR+YuIrBGRd0Xk39PbfyQi20TknfTlqqyfuU9E1ovIWhH5tyh/AWNM4eUztVsCuFNV3xaRfsByEXklfduvVfWX2XcWkbOAycBo4JPAqyLyKVX1a1VVY0yHumwxqOoOVX07fb0ZeA+o7+RHrgXmqeoRVd0IrAfOK0Sxxpji6FYfg4g0AP8KLE1vul1EVorIHBEZmN5WD2zN+rEm2gkSEZkuIstEZNmePXu6XbgxJjp5B4OI9AUWAP+hqh8DjwH/AowDdgC/6s4Tq+oTqtqoqo11dXXd+VFjTMTyCgYRqaQ1FJ5T1d8BqOouVU2qagr4b47tLmwDhmf9+LD0NmNMicjnqIQATwHvqeqDWduHZt3tq8Dq9PWFwGQRqRaRkcAo4M3ClWyMiVo+RyU+B9wErBKRd9Lb7ge+KSLjAAU2Ad8BUNV3RWQ+sIbWIxq32REJY0qL5LOceeRFiOwBDgL/dF1LHgZTGnVC6dRqdRZee7Wepqp5deh5EQwAIrJMVRtd19GVUqkTSqdWq7PwelurDYk2xuSwYDDG5PApGJ5wXUCeSqVOKJ1arc7C61Wt3vQxGGP84VOLwRjjCefBICJXpE/PXi8i97qu53gisklEVqVPLV+W3jZIRF4RkXXprwO7epwI6pojIrtFZHXWtnbrklYPp1/jlSIy3oNavTttv5MpBrx6XYsyFYKqOrsAMWADcDpQBawAznJZUzs1bgIGH7ftF8C96ev3Aj93UNeFwHhgdVd1AVcB/wMIcD6w1INafwTc1c59z0q/D6qBken3R6xIdQ4Fxqev9wPeT9fj1evaSZ0Fe01dtxjOA9ar6geqehSYR+tp2767Fpibvj4X+EqxC1DV14APj9vcUV3XAs9oq78DA44b0h6pDmrtiLPT9rXjKQa8el07qbMj3X5NXQdDXqdoO6bAYhFZLiLT09uGqOqO9PWdwBA3peXoqC5fX+cen7YfteOmGPD2dS3kVAjZXAdDKbhAVccDVwK3iciF2Tdqa1vNu0M7vtaVpVen7UepnSkGMnx6XQs9FUI218Hg/Snaqrot/XU38Htam2C7wiZj+utudxW20VFd3r3O6ulp++1NMYCHr2vUUyG4Doa3gFEiMlJEqmidK3Kh45oyROTk9DyXiMjJwOW0nl6+EJiSvtsU4CU3FeboqK6FwM3pXvTzgf1ZTWMnfDxtv6MpBvDsde2ozoK+psXoRe2ih/UqWntVNwD/6bqe42o7ndbe3BXAu2F9wCeAJcA64FVgkIPanqe1uRindZ9xWkd10dpr/pv0a7wKaPSg1mfTtaxMv3GHZt3/P9O1rgWuLGKdF9C6m7ASeCd9ucq317WTOgv2mtrIR2NMDte7EsYYD1kwGGNyWDAYY3JYMBhjclgwGGNyWDAYY3JYMBhjclgwGGNy/H8PoK97d6MTNAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "img = imread(\"/home/rajath/work/iisc/data/sketchy/256x256/sketch/tx_000100000000/airplane/n02691156_1142-1.png\")\n", + "plt.imshow(img)\n", + "print (img.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [], + "source": [ + "coco_sketchy_map = pickle.load(open(\"../data/coco_sketchy_map.pkl\", \"rb\"))" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [], + "source": [ + "query = {}\n", + "sketchy_db_path = \"../data/sketchy/256x256/sketch/tx_000100000000\"\n", + "for class_idx in coco_sketchy_map:\n", + " query[class_idx] = []\n", + " if len(coco_sketchy_map[class_idx][\"sketchy\"]) > 0:\n", + " for sketch_class in coco_sketchy_map[class_idx][\"sketchy\"]:\n", + " class_sketch_paths = glob.glob(os.path.join(sketchy_db_path, sketch_class, \"*\"))\n", + " for sketch_path in class_sketch_paths:\n", + " d = {\"boxes\": [0.0, 0.0, 256.0, 256.0], \"image_path\": sketch_path}\n", + " query[class_idx].append(d)" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 0\n", + "1 0\n", + "2 614\n", + "3 642\n", + "4 643\n", + "5 708\n", + "6 0\n", + "7 0\n", + "8 698\n", + "9 659\n", + "10 0\n", + "11 0\n", + "12 0\n", + "13 0\n", + "14 583\n", + "15 1050\n", + "16 692\n", + "17 692\n", + "18 738\n", + "19 669\n", + "20 728\n", + "21 661\n", + "22 722\n", + "23 608\n", + "24 673\n", + "25 0\n", + "26 546\n", + "27 0\n", + "28 0\n", + "29 0\n", + "30 0\n", + "31 0\n", + "32 0\n", + "33 0\n", + "34 0\n", + "35 0\n", + "36 0\n", + "37 0\n", + "38 0\n", + "39 549\n", + "40 603\n", + "41 0\n", + "42 697\n", + "43 0\n", + "44 624\n", + "45 535\n", + "46 0\n", + "47 635\n", + "48 551\n", + "49 0\n", + "50 0\n", + "51 0\n", + "52 0\n", + "53 634\n", + "54 606\n", + "55 0\n", + "56 0\n", + "57 669\n", + "58 652\n", + "59 0\n", + "60 0\n", + "61 563\n", + "62 0\n", + "63 0\n", + "64 0\n", + "65 0\n", + "66 0\n", + "67 0\n", + "68 0\n", + "69 0\n", + "70 0\n", + "71 0\n", + "72 0\n", + "73 0\n", + "74 0\n", + "75 571\n", + "76 0\n", + "77 558\n", + "78 571\n", + "79 0\n", + "80 0\n" + ] + } + ], + "source": [ + "for class_idx in query:\n", + " print (class_idx, len(query[class_idx]))" + ] + }, + { + "cell_type": "code", + "execution_count": 130, + "metadata": {}, + "outputs": [], + "source": [ + "# r = pickle.load(open(\"sketch_query.pkl\", \"rb\"))\n", + "r1 = pickle.load(open(\"roidb.pkl\", \"rb\"))\n", + "# r1 = pickle.load(open(\"ratio_list.pkl\", \"rb\"))\n", + "# r2 = pickle.load(open(\"ratio_index.pkl\", \"rb\"))" + ] + }, + { + "cell_type": "code", + "execution_count": 110, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 110, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "allowed_classes = [int(class_idx) for class_idx in query if len(query[class_idx]) > 0]\n", + "any([i for i in [2.0, 3.0, 4.0] if int(i) in allowed_classes])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 122, + "metadata": {}, + "outputs": [], + "source": [ + "criteria = False or any([True if int(i) in allowed_classes else False for i in [1,1,30]])" + ] + }, + { + "cell_type": "code", + "execution_count": 123, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 123, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "criteria" + ] + }, + { + "cell_type": "code", + "execution_count": 125, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "212996" + ] + }, + "execution_count": 125, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(r1)" + ] + }, + { + "cell_type": "code", + "execution_count": 131, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'width': 640,\n", + " 'height': 360,\n", + " 'boxes': array([[359, 146, 470, 358],\n", + " [339, 22, 492, 321],\n", + " [471, 172, 506, 219],\n", + " [486, 183, 515, 217]], dtype=uint16),\n", + " 'gt_classes': array([4, 1, 1, 2], dtype=int32),\n", + " 'gt_overlaps': <4x81 sparse matrix of type ''\n", + " \twith 4 stored elements in Compressed Sparse Row format>,\n", + " 'flipped': False,\n", + " 'seg_areas': array([12190.445 , 14107.271 , 708.26056, 626.9852 ], dtype=float32),\n", + " 'img_id': 391895,\n", + " 'image': '/home/rajath/work/iisc/data/coco/images/train2017/000000391895.jpg',\n", + " 'max_classes': array([4, 1, 1, 2]),\n", + " 'max_overlaps': array([1., 1., 1., 1.], dtype=float32),\n", + " 'need_crop': 0}" + ] + }, + "execution_count": 131, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "r1[0]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:onesod] *", + "language": "python", + "name": "conda-env-onesod-py" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.10" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/get_common_classes.py b/get_common_classes.py new file mode 100644 index 0000000..25ae4ee --- /dev/null +++ b/get_common_classes.py @@ -0,0 +1,70 @@ +import numpy +import json +import os +import pickle +from tqdm import tqdm +from pycocotools.coco import COCO + +dataDir = 'data/ms_coco_data' +dataType = 'train2014' + +annFile = '{}/annotations/instances_{}.json'.format(dataDir, dataType) + +coco = COCO(annFile) +cats = coco.loadCats(coco.getCatIds()) + +nms = [cat['name'] for cat in cats] +draw_classes = pickle.load(open('/scratche/home//imagenet/label2idx_draw.pkl', 'rb')) +draw_classes = list(draw_classes.keys()) +common_classes = set(draw_classes) - set(nms) +common_classes_v2 = list(set(draw_classes)- common_classes) + +class2label = {} +label2class = {} +for cl in common_classes_v2: + class2label[cl] = len(class2label) + label2class[len(label2class)] = cl + +print(class2label) +print(label2class) +pickle.dump(class2label, open('class2label_common_classes.pkl', 'wb')) +pickle.dump(label2class, open('label2class_common_classes.pkl', 'wb')) +print(len(common_classes_v2)) + +draw_data_paths = '/scratche/home//imagenet/processed_quick_draw_paths.pkl' +paths = pickle.load(open(draw_data_paths, 'rb')) + +train_paths = paths['train_x'] +valid_paths = paths['valid_x'] +test_paths = paths['test_x'] + +new_train_paths = [] +new_valid_paths = [] +new_test_paths = [] +for path in tqdm(train_paths): + for cl in common_classes_v2: + label = path.split('/')[-2] + if label == cl: + #if cl in path: + new_train_paths.append(path) + +for path in tqdm(valid_paths): + for cl in common_classes_v2: + label = path.split('/')[-2] + if label == cl: + #if cl in path: + new_valid_paths.append(path) +for path in tqdm(test_paths): + for cl in common_classes_v2: + label = path.split('/')[-2] + if label == cl: + #if cl in path: + new_test_paths.append(path) +print(len(new_test_paths)) + +print(len(new_train_paths)) +print(len(new_valid_paths)) + + +new_paths = {'train_x': new_train_paths, 'valid_x': new_valid_paths, 'test_x': new_test_paths} +pickle.dump(new_paths, open('processed_quick_draw_paths_common_classes.pkl', 'wb')) diff --git a/get_train_test_quick_draw.py b/get_train_test_quick_draw.py new file mode 100644 index 0000000..355564b --- /dev/null +++ b/get_train_test_quick_draw.py @@ -0,0 +1,30 @@ +import pickle +import os +from tqdm import tqdm +import random + +train_x = [] + +valid_x = [] +test_x = [] + +root = '/scratche/home//processed_quick_draw/' +for r, d, f in os.walk(root): + for dr in tqdm(d): + for r2,d2,f2 in os.walk(os.path.join(root, dr)): + for file in tqdm(f2): + if '.pkl' in file: + toss_1 = random.random() + if toss_1 > 0.8: + toss_2 = random.random() + if toss_2 > 0.5: + valid_x.append(os.path.join(os.path.join(root,dr), file)) + else: + test_x.append(os.path.join(os.path.join(root,dr), file)) + else: + train_x.append(os.path.join(os.path.join(root,dr), file)) + +print(len(train_x), len(test_x), len(valid_x)) +data = {'train_x': train_x, 'test_x': test_x, 'valid_x': valid_x} + print(positive_samples.size()) +pickle.dump(data, open('processed_quick_draw_paths.pkl', 'wb')) diff --git a/lib/datasets/VOCdevkit-matlab-wrapper/get_voc_opts.m b/lib/datasets/VOCdevkit-matlab-wrapper/get_voc_opts.m new file mode 100644 index 0000000..629597a --- /dev/null +++ b/lib/datasets/VOCdevkit-matlab-wrapper/get_voc_opts.m @@ -0,0 +1,14 @@ +function VOCopts = get_voc_opts(path) + +tmp = pwd; +cd(path); +try + addpath('VOCcode'); + VOCinit; +catch + rmpath('VOCcode'); + cd(tmp); + error(sprintf('VOCcode directory not found under %s', path)); +end +rmpath('VOCcode'); +cd(tmp); diff --git a/lib/datasets/VOCdevkit-matlab-wrapper/voc_eval.m b/lib/datasets/VOCdevkit-matlab-wrapper/voc_eval.m new file mode 100644 index 0000000..1911a0e --- /dev/null +++ b/lib/datasets/VOCdevkit-matlab-wrapper/voc_eval.m @@ -0,0 +1,56 @@ +function res = voc_eval(path, comp_id, test_set, output_dir) + +VOCopts = get_voc_opts(path); +VOCopts.testset = test_set; + +for i = 1:length(VOCopts.classes) + cls = VOCopts.classes{i}; + res(i) = voc_eval_cls(cls, VOCopts, comp_id, output_dir); +end + +fprintf('\n~~~~~~~~~~~~~~~~~~~~\n'); +fprintf('Results:\n'); +aps = [res(:).ap]'; +fprintf('%.1f\n', aps * 100); +fprintf('%.1f\n', mean(aps) * 100); +fprintf('~~~~~~~~~~~~~~~~~~~~\n'); + +function res = voc_eval_cls(cls, VOCopts, comp_id, output_dir) + +test_set = VOCopts.testset; +year = VOCopts.dataset(4:end); + +addpath(fullfile(VOCopts.datadir, 'VOCcode')); + +res_fn = sprintf(VOCopts.detrespath, comp_id, cls); + +recall = []; +prec = []; +ap = 0; +ap_auc = 0; + +do_eval = (str2num(year) <= 2007) | ~strcmp(test_set, 'test'); +if do_eval + % Bug in VOCevaldet requires that tic has been called first + tic; + [recall, prec, ap] = VOCevaldet(VOCopts, comp_id, cls, true); + ap_auc = xVOCap(recall, prec); + + % force plot limits + ylim([0 1]); + xlim([0 1]); + + print(gcf, '-djpeg', '-r0', ... + [output_dir '/' cls '_pr.jpg']); +end +fprintf('!!! %s : %.4f %.4f\n', cls, ap, ap_auc); + +res.recall = recall; +res.prec = prec; +res.ap = ap; +res.ap_auc = ap_auc; + +save([output_dir '/' cls '_pr.mat'], ... + 'res', 'recall', 'prec', 'ap', 'ap_auc'); + +rmpath(fullfile(VOCopts.datadir, 'VOCcode')); diff --git a/lib/datasets/VOCdevkit-matlab-wrapper/xVOCap.m b/lib/datasets/VOCdevkit-matlab-wrapper/xVOCap.m new file mode 100644 index 0000000..de6c628 --- /dev/null +++ b/lib/datasets/VOCdevkit-matlab-wrapper/xVOCap.m @@ -0,0 +1,10 @@ +function ap = xVOCap(rec,prec) +% From the PASCAL VOC 2011 devkit + +mrec=[0 ; rec ; 1]; +mpre=[0 ; prec ; 0]; +for i=numel(mpre)-1:-1:1 + mpre(i)=max(mpre(i),mpre(i+1)); +end +i=find(mrec(2:end)~=mrec(1:end-1))+1; +ap=sum((mrec(i)-mrec(i-1)).*mpre(i)); diff --git a/lib/datasets/__init__.py b/lib/datasets/__init__.py new file mode 100644 index 0000000..7ba6a65 --- /dev/null +++ b/lib/datasets/__init__.py @@ -0,0 +1,6 @@ +# -------------------------------------------------------- +# Fast R-CNN +# Copyright (c) 2015 Microsoft +# Licensed under The MIT License [see LICENSE for details] +# Written by Ross Girshick +# -------------------------------------------------------- diff --git a/lib/datasets/coco.py b/lib/datasets/coco.py new file mode 100644 index 0000000..d20f7f3 --- /dev/null +++ b/lib/datasets/coco.py @@ -0,0 +1,551 @@ +# -------------------------------------------------------- +# Fast/er R-CNN +# Licensed under The MIT License [see LICENSE for details] +# Written by Ross Girshick and Xinlei Chen +# -------------------------------------------------------- +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +from datasets.imdb import imdb +import datasets.ds_utils as ds_utils +from model.utils.config import cfg +import os.path as osp +import sys +import os +import numpy as np +import scipy.sparse +import scipy.io as sio +import pickle +import json +import uuid +import copy +# COCO API +from pycocotools.coco import COCO +from pycocotools.cocoeval import COCOeval +from pycocotools import mask as COCOmask + +class customCOCOeval(COCOeval): + + def summarize(self, class_index=None, verbose=1): + ''' + Compute and display summary metrics for evaluation results. + Note this functin can *only* be applied on the default parameter setting + ''' + def _summarize( ap=1, iouThr=None, areaRng='all', maxDets=100 ): + p = self.params + iStr = ' {:<18} {} @[ IoU={:<9} | area={:>6s} | maxDets={:>3d} ] = {:0.3f}' + titleStr = 'Average Precision' if ap == 1 else 'Average Recall' + typeStr = '(AP)' if ap==1 else '(AR)' + iouStr = '{:0.2f}:{:0.2f}'.format(p.iouThrs[0], p.iouThrs[-1]) \ + if iouThr is None else '{:0.2f}'.format(iouThr) + + aind = [i for i, aRng in enumerate(p.areaRngLbl) if aRng == areaRng] + mind = [i for i, mDet in enumerate(p.maxDets) if mDet == maxDets] + if ap == 1: + # dimension of precision: [TxRxKxAxM] + s = self.eval['precision'] + # IoU + if iouThr is not None: + t = np.where(iouThr == p.iouThrs)[0] + s = s[t] + if not class_index is None: + s = s[:,:,class_index,aind,mind] + else: + s = s[:,:,:,aind,mind] + else: + # dimension of recall: [TxKxAxM] + s = self.eval['recall'] + if iouThr is not None: + t = np.where(iouThr == p.iouThrs)[0] + s = s[t] + if not class_index is None: + s = s[:,class_index,aind,mind] + else: + s = s[:,:,aind,mind] + if len(s[s>-1])==0: + mean_s = -1 + else: + mean_s = np.mean(s[s>-1]) + if verbose > 0: + print(iStr.format(titleStr, typeStr, iouStr, areaRng, maxDets, mean_s)) + return mean_s + def _summarizeDets(): + stats = np.zeros((12,)) + stats[0] = _summarize(1) + stats[1] = _summarize(1, iouThr=.5, maxDets=self.params.maxDets[2]) + stats[2] = _summarize(1, iouThr=.75, maxDets=self.params.maxDets[2]) + stats[3] = _summarize(1, areaRng='small', maxDets=self.params.maxDets[2]) + stats[4] = _summarize(1, areaRng='medium', maxDets=self.params.maxDets[2]) + stats[5] = _summarize(1, areaRng='large', maxDets=self.params.maxDets[2]) + stats[6] = _summarize(0, maxDets=self.params.maxDets[0]) + stats[7] = _summarize(0, maxDets=self.params.maxDets[1]) + stats[8] = _summarize(0, maxDets=self.params.maxDets[2]) + stats[9] = _summarize(0, areaRng='small', maxDets=self.params.maxDets[2]) + stats[10] = _summarize(0, areaRng='medium', maxDets=self.params.maxDets[2]) + stats[11] = _summarize(0, areaRng='large', maxDets=self.params.maxDets[2]) + return stats + def _summarizeKps(): + stats = np.zeros((10,)) + stats[0] = _summarize(1, maxDets=20) + stats[1] = _summarize(1, maxDets=20, iouThr=.5) + stats[2] = _summarize(1, maxDets=20, iouThr=.75) + stats[3] = _summarize(1, maxDets=20, areaRng='medium') + stats[4] = _summarize(1, maxDets=20, areaRng='large') + stats[5] = _summarize(0, maxDets=20) + stats[6] = _summarize(0, maxDets=20, iouThr=.5) + stats[7] = _summarize(0, maxDets=20, iouThr=.75) + stats[8] = _summarize(0, maxDets=20, areaRng='medium') + stats[9] = _summarize(0, maxDets=20, areaRng='large') + return stats + if not self.eval: + raise Exception('Please run accumulate() first') + iouType = self.params.iouType + if iouType == 'segm' or iouType == 'bbox': + summarize = _summarizeDets + elif iouType == 'keypoints': + summarize = _summarizeKps + self.stats = summarize() + + def __str__(self, class_index=None): + self.summarize(class_index) + def get_mean_IOU(self): + mean_IOU = {} + micro_avg = [] + macro_avg = [] + for cl, IOU_list in self.meanIOU.items(): + if len(IOU_list) > 0: + IOU_list = list(set(IOU_list)) + mean_IOU[cl] = sum(IOU_list)/len(IOU_list) + micro_avg.extend(IOU_list) + macro_avg.append(sum(IOU_list)/len(IOU_list)) + return mean_IOU, sum(micro_avg)/len(micro_avg), sum(macro_avg)/len(macro_avg) + +class coco_sketch(imdb): + def __init__(self, image_set, year): + imdb.__init__(self, 'coco_' + year + '_' + image_set) + # COCO specific config options + self.config = {'use_salt': True, + 'cleanup': True} + # name, paths + self._year = year + self._image_set = image_set + self._data_path = osp.join(cfg.DATA_DIR, 'coco') + + classes = ['clock','fire hydrant','train','bench','toilet','truck','donut','skateboard','carrot','car', + 'baseball bat','scissors','couch','bear','spoon','elephant', 'toothbrush', 'sheep', 'bed', 'fork','apple', + 'pizza','microwave','bicycle','umbrella', 'cup', 'stop sign', 'dog','cell phone', 'book', 'keyboard','bus','oven', + 'chair','horse','cake','sandwich','cat','toaster','vase','sink','knife','wine glass','suitcase','broccoli','zebra','traffic light', + 'banana','cow','airplane','giraffe','laptop','mouse','hot dog','bird','backpack'] + + # load COCO API, classes, class <-> id mappings + self._COCO = COCO(self._get_ann_file()) + cats = self._COCO.loadCats(self._COCO.getCatIds()) + # class name + # self._classes = tuple(['__background__'] + [c['name'] for c in cats]) + self._classes = tuple(['__background__']+classes) + # class name to ind (0~80) 0= __background__ + self._class_to_ind = dict(list(zip(self.classes, list(range(self.num_classes))))) + # class name to cat_id (1~90) 1= person + self._class_to_coco_cat_id = dict(list(zip([c['name'] for c in cats], + self._COCO.getCatIds()))) + # Lookup table to map from COCO category ids to our internal class + # indices + # 1~90 : 1~80 + self.coco_cat_id_to_class_ind = dict([(self._class_to_coco_cat_id[cls], + self._class_to_ind[cls]) + for cls in self._classes[1:]]) + # 1~80 : 1~90 + self.coco_class_ind_to_cat_id = dict([(self._class_to_ind[cls], + self._class_to_coco_cat_id[cls]) + for cls in self._classes[1:]]) + + self._image_index = self._load_image_set_index() + + + + + # Default to roidb handler + self.set_proposal_method('gt') + self.competition_mode(False) + + # Some image sets are "views" (i.e. subsets) into others. + # For example, minival2014 is a random 5000 image subset of val2014. + # This mapping tells us where the view's images and proposals come from. + self._view_map = { + 'minival2014': 'val2014', # 5k val2014 subset + 'valminusminival2014': 'val2014', # val2014 \setminus minival2014 + 'test-dev2015': 'test2015', + 'valminuscapval2014': 'val2014', + 'capval2014': 'val2014', + 'captest2014': 'val2014' + } + coco_name = image_set + year # e.g., "val2014" + self._data_name = (self._view_map[coco_name] + if coco_name in self._view_map + else coco_name) + # Dataset splits that have ground-truth annotations (test splits + # do not have gt annotations) + self._gt_splits = ('train', 'val', 'minival') + + # set reference file + self._reference_dir = os.path.join(cfg.DATA_DIR, "coco_reference_image") + self._reference_file = os.path.join(self._reference_dir, "coco_{}_e2e_mask_rcnn_R_101_FPN_1x_caffe2.pkl".format(self._data_name)) + if not os.path.exists(self._reference_file): + print('No reference file.') + assert False + else: + with open(self._reference_file, "rb") as f: + self.reference_image = pickle.load(f) + + self.cat_data = {} + + for i in self._class_to_ind.values(): + # i = 1~80 + self.cat_data[i] = [] + + def _get_ann_file(self): + prefix = 'instances' if self._image_set.find('test') == -1 \ + else 'image_info' + return osp.join(self._data_path, 'annotations', + prefix + '_' + self._image_set + self._year + '.json') + + def _load_image_set_index(self): + """ + Load image ids. + """ + image_ids = self._COCO.getImgIds() + return image_ids + + def _get_widths(self): + anns = self._COCO.loadImgs(self._image_index) + widths = [ann['width'] for ann in anns] + return widths + + def image_path_at(self, i): + """ + Return the absolute path to image i in the image sequence. + """ + return self.image_path_from_index(self._image_index[i]) + + def image_id_at(self, i): + """ + Return the absolute path to image i in the image sequence. + """ + return self._image_index[i] + + def image_path_from_index(self, index): + """ + Construct an image path from the image's "index" identifier. + """ + # Example image path for index=119993: + # images/train2014/COCO_train2014_000000119993.jpg + if self._data_name=='train2014': + file_name = ('COCO_' + self._data_name + '_' + + str(index).zfill(12) + '.jpg') + else: + file_name = (str(index).zfill(12) + '.jpg') + + image_path = osp.join(self._data_path,self._data_name, file_name) + assert osp.exists(image_path), \ + 'Path does not exist: {}'.format(image_path) + return image_path + + def gt_roidb(self): + """ + Return the database of ground-truth regions of interest. + This function loads/saves from/to a cache file to speed up future calls. + """ + cache_file = osp.join(self.cache_path, self.name + '_gt_roidb_filtered_sketch_oneshot.pkl') + + # if osp.exists(cache_file): + # with open(cache_file, 'rb') as fid: + # [roidb, self.cat_data] = pickle.load(fid) + # print('{} gt roidb loaded from {}'.format(self.name, cache_file)) + # return roidb + + + gt_roidb2 = [] + + + ''' + image_index = copy.deepcopy(self._image_index) + self._image_index = [] + for index in image_index: + roi = self._load_coco_annotation(index) + if len(roi["boxes"]) > 0: + gt_roidb2.append(roi) + self._image_index.append(index) + ''' + gt_roidb2 = [self._load_coco_annotation(index) + for index in self._image_index] + with open(cache_file, 'wb') as fid: + pickle.dump([gt_roidb2,self.cat_data], fid, pickle.HIGHEST_PROTOCOL) + print('wrote gt roidb to {}'.format(cache_file)) + return gt_roidb2 + + def _load_coco_annotation(self, index): + """ + Loads COCO bounding-box instance annotations. Crowd instances are + handled by marking their overlaps (with all categories) to -1. This + overlap value means that crowd "instances" are excluded from training. + """ + im_ann = self._COCO.loadImgs(index)[0] + im_path = self.image_path_from_index(index) + width = im_ann['width'] + height = im_ann['height'] + + # Get the useful information + reference = self.reference_image[index] + save_seq = reference.keys() + + annIds = self._COCO.getAnnIds(imgIds=index, iscrowd=None) + objs = self._COCO.loadAnns(annIds) + # Sanitize bboxes -- some are invalid + valid_objs = [] + all_class_inds = [] + for key, value in self.coco_cat_id_to_class_ind.items(): + all_class_inds.append(key) + for i, obj in enumerate(objs): + x1 = np.max((0, obj['bbox'][0])) + y1 = np.max((0, obj['bbox'][1])) + x2 = np.min((width - 1, x1 + np.max((0, obj['bbox'][2] - 1)))) + y2 = np.min((height - 1, y1 + np.max((0, obj['bbox'][3] - 1)))) + if obj['area'] > 0 and x2 >= x1 and y2 >= y1: + obj['clean_bbox'] = [x1, y1, x2, y2] + if obj['category_id'] in all_class_inds: + valid_objs.append(obj) + + if i in save_seq: + entry = { + 'boxes': obj['clean_bbox'], + 'image_path': im_path + } + + self.cat_data[self.coco_cat_id_to_class_ind[obj['category_id']]].append(entry) + + objs = valid_objs + num_objs = len(objs) + + boxes = np.zeros((num_objs, 4), dtype=np.uint16) + gt_classes = np.zeros((num_objs), dtype=np.int32) + overlaps = np.zeros((num_objs, self.num_classes), dtype=np.float32) + seg_areas = np.zeros((num_objs), dtype=np.float32) + + + + for ix, obj in enumerate(objs): + cls = self.coco_cat_id_to_class_ind[obj['category_id']] + boxes[ix, :] = obj['clean_bbox'] + gt_classes[ix] = cls + seg_areas[ix] = obj['area'] + if obj['iscrowd']: + # Set overlap to -1 for all classes for crowd objects + # so they will be excluded during training + overlaps[ix, :] = -1.0 + else: + overlaps[ix, cls] = 1.0 + + ds_utils.validate_boxes(boxes, width=width, height=height) + overlaps = scipy.sparse.csr_matrix(overlaps) + return {'width': width, + 'height': height, + 'boxes': boxes, + 'gt_classes': gt_classes, + 'gt_overlaps': overlaps, + 'flipped': False, + 'seg_areas': seg_areas} + + def _get_widths(self): + return [r['width'] for r in self.roidb] + + def append_flipped_images(self): + num_images = self.num_images + widths = self._get_widths() + print(num_images) + print(len(widths)) + + for i in range(num_images): + boxes = self.roidb[i]['boxes'].copy() + oldx1 = boxes[:, 0].copy() + oldx2 = boxes[:, 2].copy() + boxes[:, 0] = widths[i] - oldx2 - 1 + boxes[:, 2] = widths[i] - oldx1 - 1 + assert (boxes[:, 2] >= boxes[:, 0]).all() + entry = {'width': widths[i], + 'height': self.roidb[i]['height'], + 'boxes': boxes, + 'gt_classes': self.roidb[i]['gt_classes'], + 'gt_overlaps': self.roidb[i]['gt_overlaps'], + 'flipped': True, + 'seg_areas': self.roidb[i]['seg_areas']} + + self.roidb.append(entry) + self._image_index = self._image_index * 2 + + def _get_box_file(self, index): + # first 14 chars / first 22 chars / all chars + .mat + # COCO_val2014_0/COCO_val2014_000000447/COCO_val2014_000000447991.mat + file_name = ('COCO_' + self._data_name + + '_' + str(index).zfill(12) + '.mat') + return osp.join(file_name[:14], file_name[:22], file_name) + + def _print_detection_eval_metrics(self, coco_eval): + IoU_lo_thresh = 0.5 + IoU_hi_thresh = 0.95 + + def _get_thr_ind(coco_eval, thr): + ind = np.where((coco_eval.params.iouThrs > thr - 1e-5) & + (coco_eval.params.iouThrs < thr + 1e-5))[0][0] + iou_thr = coco_eval.params.iouThrs[ind] + assert np.isclose(iou_thr, thr) + return ind + + ind_lo = _get_thr_ind(coco_eval, IoU_lo_thresh) + ind_hi = _get_thr_ind(coco_eval, IoU_hi_thresh) + # precision has dims (iou, recall, cls, area range, max dets) + # area range index 0: all area ranges + # max dets index 2: 100 per image + precision = \ + coco_eval.eval['precision'][ind_lo:(ind_hi + 1), :, :, 0, 2] + ap_default = np.mean(precision[precision > -1]) + print(('~~~~ Mean and per-category AP @ IoU=[{:.2f},{:.2f}] ' + '~~~~').format(IoU_lo_thresh, IoU_hi_thresh)) + print('{:.1f}'.format(100 * ap_default)) + for cls_ind, cls in enumerate(self.classes): + if cls == '__background__': + continue + # minus 1 because of __background__ + precision = coco_eval.eval['precision'][ind_lo:(ind_hi + 1), :, cls_ind - 1, 0, 2] + ap = np.mean(precision[precision > -1]) + print('{:.1f}'.format(100 * ap)) + + print('~~~~ Summary metrics ~~~~') + coco_eval.summarize() + + def _do_detection_eval(self, res_file, output_dir): + ann_type = 'bbox' + + tmp = [self.coco_cat_id_to_class_ind[i]-1 for i in self.list] + + coco_dt = self._COCO.loadRes(res_file) + + cocoEval = customCOCOeval(self._COCO, coco_dt, "bbox") + cocoEval.params.imgIds = self._image_index + cocoEval.evaluate() + print(cocoEval.get_mean_IOU()) + cocoEval.accumulate() + cocoEval.summarize(class_index=tmp) + + + + eval_file = osp.join(output_dir, 'detection_results.pkl') + with open(eval_file, 'wb') as fid: + pickle.dump(cocoEval, fid, pickle.HIGHEST_PROTOCOL) + print('Wrote COCO eval results to: {}'.format(eval_file)) + + def _coco_results_one_category(self, boxes, cat_id): + results = [] + for im_ind, index in enumerate(self.image_index): + dets = boxes[im_ind] + if dets == []: + continue + dets = np.array(dets).astype(np.float) + scores = dets[:, -1] + xs = dets[:, 0] + ys = dets[:, 1] + ws = dets[:, 2] - xs + 1 + hs = dets[:, 3] - ys + 1 + for k in range(len(dets)): + results.extend( + [{'image_id': index, + 'category_id': cat_id, + 'bbox': [xs[k], ys[k], ws[k], hs[k]], + 'score': scores[k]} ]) + return results + + def _write_coco_results_file(self, all_boxes, res_file): + # [{"image_id": 42, + # "category_id": 18, + # "bbox": [258.15,41.29,348.26,243.78], + # "score": 0.236}, ...] + results = [] + for cls_ind, cls in enumerate(self.classes): + if cls == '__background__': + continue + print('Collecting {} results ({:d}/{:d})'.format(cls, cls_ind, + self.num_classes - 1)) + coco_cat_id = self._class_to_coco_cat_id[cls] + results.extend(self._coco_results_one_category(all_boxes[cls_ind], coco_cat_id)) + print('Writing results json to {}'.format(res_file)) + with open(res_file, 'w') as fid: + json.dump(results, fid) + + def evaluate_detections(self, all_boxes, output_dir): + + + res_file = osp.join(output_dir, ('detections_' + + self._image_set + + self._year + + '_results')) + if self.config['use_salt']: + res_file += '_{}'.format(str(uuid.uuid4())) + res_file += '.json' + self._write_coco_results_file(all_boxes, res_file) + # Only do evaluation on non-test sets + if self._image_set.find('test') == -1: + self._do_detection_eval(res_file, output_dir) + # Optionally cleanup results json file + if self.config['cleanup']: + os.remove(res_file) + + def competition_mode(self, on): + if on: + self.config['use_salt'] = False + self.config['cleanup'] = False + else: + self.config['use_salt'] = True + self.config['cleanup'] = True + + def filter(self, seen=1): + + # if want to use train_categories, seen = 5 + # if want to use test_categories , seen = 6 + # if want to use both , seen = 7 + print(cfg.train_categories) + + if seen==1: + self.list = cfg.train_categories + if len(self.list)==1: + self.list = [self.coco_class_ind_to_cat_id[cat] for cat in range(1,57) if cat%4 != self.list[0]] + + elif seen==2: + self.list = cfg.train_categories + if len(self.list)==1: + self.list = [self.coco_class_ind_to_cat_id[cat] for cat in range(1,57) if cat%4 == self.list[0]] + elif seen==3: + self.list = [self.coco_class_ind_to_cat_id[cat] for cat in range(1,57)] + # print(self.list) + + + # Transfer categories id to class indices + self.inverse_list = [self.coco_cat_id_to_class_ind[i] for i in self.list ] + + # Which index need to be remove + all_index = list(range(len(self._image_index))) + + all_classes = list(self.coco_cat_id_to_class_ind.keys()) + + for index, info in enumerate(self.roidb): + for cat in info['gt_classes']: + # if cat not in all_classes: + if self.coco_class_ind_to_cat_id[cat] in self.list: + all_index.remove(index) + break + + # Remove index from the end to start + + all_index.reverse() + for index in all_index: + self._image_index.pop(index) + self.roidb.pop(index) \ No newline at end of file diff --git a/lib/datasets/ds_utils.py b/lib/datasets/ds_utils.py new file mode 100644 index 0000000..fd5ca4b --- /dev/null +++ b/lib/datasets/ds_utils.py @@ -0,0 +1,49 @@ +# -------------------------------------------------------- +# Fast/er R-CNN +# Licensed under The MIT License [see LICENSE for details] +# Written by Ross Girshick +# -------------------------------------------------------- +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +import numpy as np + + +def unique_boxes(boxes, scale=1.0): + """Return indices of unique boxes.""" + v = np.array([1, 1e3, 1e6, 1e9]) + hashes = np.round(boxes * scale).dot(v) + _, index = np.unique(hashes, return_index=True) + return np.sort(index) + + +def xywh_to_xyxy(boxes): + """Convert [x y w h] box format to [x1 y1 x2 y2] format.""" + return np.hstack((boxes[:, 0:2], boxes[:, 0:2] + boxes[:, 2:4] - 1)) + + +def xyxy_to_xywh(boxes): + """Convert [x1 y1 x2 y2] box format to [x y w h] format.""" + return np.hstack((boxes[:, 0:2], boxes[:, 2:4] - boxes[:, 0:2] + 1)) + + +def validate_boxes(boxes, width=0, height=0): + """Check that a set of boxes are valid.""" + x1 = boxes[:, 0] + y1 = boxes[:, 1] + x2 = boxes[:, 2] + y2 = boxes[:, 3] + assert (x1 >= 0).all() + assert (y1 >= 0).all() + assert (x2 >= x1).all() + assert (y2 >= y1).all() + assert (x2 < width).all() + assert (y2 < height).all() + + +def filter_small_boxes(boxes, min_size): + w = boxes[:, 2] - boxes[:, 0] + h = boxes[:, 3] - boxes[:, 1] + keep = np.where((w >= min_size) & (h > min_size))[0] + return keep diff --git a/lib/datasets/factory.py b/lib/datasets/factory.py new file mode 100644 index 0000000..3f6e047 --- /dev/null +++ b/lib/datasets/factory.py @@ -0,0 +1,72 @@ +# -------------------------------------------------------- +# Fast R-CNN +# Copyright (c) 2015 Microsoft +# Licensed under The MIT License [see LICENSE for details] +# Written by Ross Girshick +# -------------------------------------------------------- + +"""Factory method for easily getting imdbs by name.""" +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +__sets = {} +from datasets.pascal_voc import pascal_voc +from datasets.coco import coco +from datasets.imagenet import imagenet +from datasets.vg import vg + +import numpy as np + +# Set up voc__ +for year in ['2007', '2012']: + for split in ['train', 'val', 'trainval', 'test']: + name = 'voc_{}_{}'.format(year, split) + __sets[name] = (lambda split=split, year=year: pascal_voc(split, year)) + +# Set up coco_2014_ +for year in ['2014']: + for split in ['train', 'val', 'minival', 'valminusminival', 'trainval']: + name = 'coco_{}_{}'.format(year, split) + __sets[name] = (lambda split=split, year=year: coco(split, year)) + +# Set up coco_2014_cap_ +for year in ['2014', '2017']: + for split in ['train', 'val', 'capval', 'valminuscapval', 'trainval']: + name = 'coco_{}_{}'.format(year, split) + __sets[name] = (lambda split=split, year=year: coco(split, year)) + +# Set up coco_2015_ +for year in ['2015']: + for split in ['test', 'test-dev']: + name = 'coco_{}_{}'.format(year, split) + __sets[name] = (lambda split=split, year=year: coco(split, year)) + +# Set up vg_ +# for version in ['1600-400-20']: +# for split in ['minitrain', 'train', 'minival', 'val', 'test']: +# name = 'vg_{}_{}'.format(version,split) +# __sets[name] = (lambda split=split, version=version: vg(version, split)) +for version in ['150-50-20', '150-50-50', '500-150-80', '750-250-150', '1750-700-450', '1600-400-20']: + for split in ['minitrain', 'smalltrain', 'train', 'minival', 'smallval', 'val', 'test']: + name = 'vg_{}_{}'.format(version,split) + __sets[name] = (lambda split=split, version=version: vg(version, split)) + +# set up image net. +for split in ['train', 'val', 'val1', 'val2', 'test']: + name = 'imagenet_{}'.format(split) + devkit_path = 'data/imagenet/ILSVRC/devkit' + data_path = 'data/imagenet/ILSVRC' + __sets[name] = (lambda split=split, devkit_path=devkit_path, data_path=data_path: imagenet(split,devkit_path,data_path)) + +def get_imdb(name): + """Get an imdb (image database) by name.""" + + if name not in __sets: + raise KeyError('Unknown dataset: {}'.format(name)) + return __sets[name]() + + +def list_imdbs(): + """List all registered imdbs.""" + return list(__sets.keys()) diff --git a/lib/datasets/factory2.py b/lib/datasets/factory2.py new file mode 100644 index 0000000..16c4194 --- /dev/null +++ b/lib/datasets/factory2.py @@ -0,0 +1,72 @@ +# -------------------------------------------------------- +# Fast R-CNN +# Copyright (c) 2015 Microsoft +# Licensed under The MIT License [see LICENSE for details] +# Written by Ross Girshick +# -------------------------------------------------------- + +"""Factory method for easily getting imdbs by name.""" +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +__sets = {} +from datasets.pascal_voc_sketch_v2 import pascal_voc +from datasets.coco import coco_sketch +from datasets.imagenet import imagenet +from datasets.vg import vg + +import numpy as np + +# Set up voc__ +for year in ['2007', '2012']: + for split in ['train', 'val', 'trainval', 'test']: + name = 'voc_{}_{}'.format(year, split) + __sets[name] = (lambda split=split, year=year: pascal_voc(split, year)) + +# Set up coco_2014_ +for year in ['2014']: + for split in ['train', 'val', 'minival', 'valminusminival', 'trainval']: + name = 'coco_{}_{}'.format(year, split) + __sets[name] = (lambda split=split, year=year: coco_sketch(split, year)) + +# Set up coco_2014_cap_ +for year in ['2014', '2017']: + for split in ['train', 'val', 'capval', 'valminuscapval', 'trainval']: + name = 'coco_{}_{}'.format(year, split) + __sets[name] = (lambda split=split, year=year: coco_sketch(split, year)) + +# Set up coco_2015_ +for year in ['2015']: + for split in ['test', 'test-dev']: + name = 'coco_{}_{}'.format(year, split) + __sets[name] = (lambda split=split, year=year: coco_sketch(split, year)) + +# Set up vg_ +# for version in ['1600-400-20']: +# for split in ['minitrain', 'train', 'minival', 'val', 'test']: +# name = 'vg_{}_{}'.format(version,split) +# __sets[name] = (lambda split=split, version=version: vg(version, split)) +for version in ['150-50-20', '150-50-50', '500-150-80', '750-250-150', '1750-700-450', '1600-400-20']: + for split in ['minitrain', 'smalltrain', 'train', 'minival', 'smallval', 'val', 'test']: + name = 'vg_{}_{}'.format(version,split) + __sets[name] = (lambda split=split, version=version: vg(version, split)) + +# set up image net. +for split in ['train', 'val', 'val1', 'val2', 'test']: + name = 'imagenet_{}'.format(split) + devkit_path = 'data/imagenet/ILSVRC/devkit' + data_path = 'data/imagenet/ILSVRC' + __sets[name] = (lambda split=split, devkit_path=devkit_path, data_path=data_path: imagenet(split,devkit_path,data_path)) + +def get_imdb(name): + """Get an imdb (image database) by name.""" + + if name not in __sets: + raise KeyError('Unknown dataset: {}'.format(name)) + return __sets[name]() + + +def list_imdbs(): + """List all registered imdbs.""" + return list(__sets.keys()) \ No newline at end of file diff --git a/lib/datasets/imagenet.py b/lib/datasets/imagenet.py new file mode 100644 index 0000000..3243211 --- /dev/null +++ b/lib/datasets/imagenet.py @@ -0,0 +1,214 @@ +from __future__ import print_function +# -------------------------------------------------------- +# Fast R-CNN +# Copyright (c) 2015 Microsoft +# Licensed under The MIT License [see LICENSE for details] +# Written by Ross Girshick +# -------------------------------------------------------- + +import datasets +import datasets.imagenet +import os, sys +from datasets.imdb import imdb +import xml.dom.minidom as minidom +import numpy as np +import scipy.sparse +import scipy.io as sio +import subprocess +import pdb +import pickle +try: + xrange # Python 2 +except NameError: + xrange = range # Python 3 + + +class imagenet(imdb): + def __init__(self, image_set, devkit_path, data_path): + imdb.__init__(self, image_set) + self._image_set = image_set + self._devkit_path = devkit_path + self._data_path = data_path + synsets_image = sio.loadmat(os.path.join(self._devkit_path, 'data', 'meta_det.mat')) + synsets_video = sio.loadmat(os.path.join(self._devkit_path, 'data', 'meta_vid.mat')) + self._classes_image = ('__background__',) + self._wnid_image = (0,) + + self._classes = ('__background__',) + self._wnid = (0,) + + for i in xrange(200): + self._classes_image = self._classes_image + (synsets_image['synsets'][0][i][2][0],) + self._wnid_image = self._wnid_image + (synsets_image['synsets'][0][i][1][0],) + + for i in xrange(30): + self._classes = self._classes + (synsets_video['synsets'][0][i][2][0],) + self._wnid = self._wnid + (synsets_video['synsets'][0][i][1][0],) + + self._wnid_to_ind_image = dict(zip(self._wnid_image, xrange(201))) + self._class_to_ind_image = dict(zip(self._classes_image, xrange(201))) + + self._wnid_to_ind = dict(zip(self._wnid, xrange(31))) + self._class_to_ind = dict(zip(self._classes, xrange(31))) + + #check for valid intersection between video and image classes + self._valid_image_flag = [0]*201 + + for i in range(1,201): + if self._wnid_image[i] in self._wnid_to_ind: + self._valid_image_flag[i] = 1 + + self._image_ext = ['.JPEG'] + + self._image_index = self._load_image_set_index() + # Default to roidb handler + self._roidb_handler = self.gt_roidb + + # Specific config options + self.config = {'cleanup' : True, + 'use_salt' : True, + 'top_k' : 2000} + + assert os.path.exists(self._devkit_path), 'Devkit path does not exist: {}'.format(self._devkit_path) + assert os.path.exists(self._data_path), 'Path does not exist: {}'.format(self._data_path) + + def image_path_at(self, i): + """ + Return the absolute path to image i in the image sequence. + """ + return self.image_path_from_index(self._image_index[i]) + + def image_path_from_index(self, index): + """ + Construct an image path from the image's "index" identifier. + """ + image_path = os.path.join(self._data_path, 'Data', self._image_set, index + self._image_ext[0]) + assert os.path.exists(image_path), 'path does not exist: {}'.format(image_path) + return image_path + + def _load_image_set_index(self): + """ + Load the indexes listed in this dataset's image set file. + """ + # Example path to image set file: + # self._data_path + /ImageSets/val.txt + + if self._image_set == 'train': + image_set_file = os.path.join(self._data_path, 'ImageSets', 'trainr.txt') + image_index = [] + if os.path.exists(image_set_file): + f = open(image_set_file, 'r') + data = f.read().split() + for lines in data: + if lines != '': + image_index.append(lines) + f.close() + return image_index + + for i in range(1,200): + print(i) + image_set_file = os.path.join(self._data_path, 'ImageSets', 'DET', 'train_' + str(i) + '.txt') + with open(image_set_file) as f: + tmp_index = [x.strip() for x in f.readlines()] + vtmp_index = [] + for line in tmp_index: + line = line.split(' ') + image_list = os.popen('ls ' + self._data_path + '/Data/DET/train/' + line[0] + '/*.JPEG').read().split() + tmp_list = [] + for imgs in image_list: + tmp_list.append(imgs[:-5]) + vtmp_index = vtmp_index + tmp_list + + num_lines = len(vtmp_index) + ids = np.random.permutation(num_lines) + count = 0 + while count < 2000: + image_index.append(vtmp_index[ids[count % num_lines]]) + count = count + 1 + + for i in range(1,201): + if self._valid_image_flag[i] == 1: + image_set_file = os.path.join(self._data_path, 'ImageSets', 'train_pos_' + str(i) + '.txt') + with open(image_set_file) as f: + tmp_index = [x.strip() for x in f.readlines()] + num_lines = len(tmp_index) + ids = np.random.permutation(num_lines) + count = 0 + while count < 2000: + image_index.append(tmp_index[ids[count % num_lines]]) + count = count + 1 + image_set_file = os.path.join(self._data_path, 'ImageSets', 'trainr.txt') + f = open(image_set_file, 'w') + for lines in image_index: + f.write(lines + '\n') + f.close() + else: + image_set_file = os.path.join(self._data_path, 'ImageSets', 'val.txt') + with open(image_set_file) as f: + image_index = [x.strip() for x in f.readlines()] + return image_index + + def gt_roidb(self): + """ + Return the database of ground-truth regions of interest. + This function loads/saves from/to a cache file to speed up future calls. + """ + cache_file = os.path.join(self.cache_path, self.name + '_gt_roidb.pkl') + if os.path.exists(cache_file): + with open(cache_file, 'rb') as fid: + roidb = pickle.load(fid) + print('{} gt roidb loaded from {}'.format(self.name, cache_file)) + return roidb + + gt_roidb = [self._load_imagenet_annotation(index) + for index in self.image_index] + with open(cache_file, 'wb') as fid: + pickle.dump(gt_roidb, fid, pickle.HIGHEST_PROTOCOL) + print('wrote gt roidb to {}'.format(cache_file)) + + return gt_roidb + + + def _load_imagenet_annotation(self, index): + """ + Load image and bounding boxes info from txt files of imagenet. + """ + filename = os.path.join(self._data_path, 'Annotations', self._image_set, index + '.xml') + + # print 'Loading: {}'.format(filename) + def get_data_from_tag(node, tag): + return node.getElementsByTagName(tag)[0].childNodes[0].data + + with open(filename) as f: + data = minidom.parseString(f.read()) + + objs = data.getElementsByTagName('object') + num_objs = len(objs) + + boxes = np.zeros((num_objs, 4), dtype=np.uint16) + gt_classes = np.zeros((num_objs), dtype=np.int32) + overlaps = np.zeros((num_objs, self.num_classes), dtype=np.float32) + + # Load object bounding boxes into a data frame. + for ix, obj in enumerate(objs): + x1 = float(get_data_from_tag(obj, 'xmin')) + y1 = float(get_data_from_tag(obj, 'ymin')) + x2 = float(get_data_from_tag(obj, 'xmax')) + y2 = float(get_data_from_tag(obj, 'ymax')) + cls = self._wnid_to_ind[ + str(get_data_from_tag(obj, "name")).lower().strip()] + boxes[ix, :] = [x1, y1, x2, y2] + gt_classes[ix] = cls + overlaps[ix, cls] = 1.0 + + overlaps = scipy.sparse.csr_matrix(overlaps) + + return {'boxes' : boxes, + 'gt_classes': gt_classes, + 'gt_overlaps' : overlaps, + 'flipped' : False} + +if __name__ == '__main__': + d = datasets.imagenet('val', '') + res = d.roidb + from IPython import embed; embed() diff --git a/lib/datasets/imdb.py b/lib/datasets/imdb.py new file mode 100644 index 0000000..4c9c1b1 --- /dev/null +++ b/lib/datasets/imdb.py @@ -0,0 +1,265 @@ +# -------------------------------------------------------- +# Fast R-CNN +# Copyright (c) 2015 Microsoft +# Licensed under The MIT License [see LICENSE for details] +# Written by Ross Girshick and Xinlei Chen +# -------------------------------------------------------- +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +import os +import os.path as osp +import PIL +# from model.utils.cython_bbox import bbox_overlaps +import numpy as np +import scipy.sparse +from model.utils.config import cfg +import pdb + +ROOT_DIR = osp.join(osp.dirname(__file__), '..', '..') + +class imdb(object): + """Image database.""" + + def __init__(self, name, classes=None): + self._name = name + self._num_classes = 0 + if not classes: + self._classes = [] + else: + self._classes = classes + self._image_index = [] + self._obj_proposer = 'gt' + self._roidb = None + self._roidb_handler = self.default_roidb + # Use this dict for storing dataset specific config options + self.config = {} + + @property + def name(self): + return self._name + + @property + def num_classes(self): + return len(self._classes) + + @property + def classes(self): + return self._classes + + @property + def image_index(self): + return self._image_index + + @property + def roidb_handler(self): + return self._roidb_handler + + @roidb_handler.setter + def roidb_handler(self, val): + self._roidb_handler = val + + def set_proposal_method(self, method): + method = eval('self.' + method + '_roidb') + self.roidb_handler = method + + @property + def roidb(self): + # A roidb is a list of dictionaries, each with the following keys: + # boxes + # gt_overlaps + # gt_classes + # flipped + if self._roidb is not None: + return self._roidb + self._roidb = self.roidb_handler() + return self._roidb + + @property + def cache_path(self): + cache_path = osp.abspath(osp.join("../", 'cache')) + if not os.path.exists(cache_path): + os.makedirs(cache_path) + return cache_path + + @property + def num_images(self): + return len(self.image_index) + + def image_path_at(self, i): + raise NotImplementedError + + def image_id_at(self, i): + raise NotImplementedError + + def default_roidb(self): + raise NotImplementedError + + def evaluate_detections(self, all_boxes, output_dir=None): + """ + all_boxes is a list of length number-of-classes. + Each list element is a list of length number-of-images. + Each of those list elements is either an empty list [] + or a numpy array of detection. + + all_boxes[class][image] = [] or np.array of shape #dets x 5 + """ + raise NotImplementedError + + def _get_widths(self): + return [PIL.Image.open(self.image_path_at(i)).size[0] + for i in range(self.num_images)] + + def append_flipped_images(self): + num_images = self.num_images + widths = self._get_widths() + for i in range(num_images): + boxes = self.roidb[i]['boxes'].copy() + oldx1 = boxes[:, 0].copy() + oldx2 = boxes[:, 2].copy() + boxes[:, 0] = widths[i] - oldx2 - 1 + boxes[:, 2] = widths[i] - oldx1 - 1 + assert (boxes[:, 2] >= boxes[:, 0]).all() + entry = {'boxes': boxes, + 'gt_overlaps': self.roidb[i]['gt_overlaps'], + 'gt_classes': self.roidb[i]['gt_classes'], + 'flipped': True} + self.roidb.append(entry) + self._image_index = self._image_index * 2 + + # def evaluate_recall(self, candidate_boxes=None, thresholds=None, + # area='all', limit=None): + # """Evaluate detection proposal recall metrics. + # + # Returns: + # results: dictionary of results with keys + # 'ar': average recall + # 'recalls': vector recalls at each IoU overlap threshold + # 'thresholds': vector of IoU overlap thresholds + # 'gt_overlaps': vector of all ground-truth overlaps + # """ + # # Record max overlap value for each gt box + # # Return vector of overlap values + # areas = {'all': 0, 'small': 1, 'medium': 2, 'large': 3, + # '96-128': 4, '128-256': 5, '256-512': 6, '512-inf': 7} + # area_ranges = [[0 ** 2, 1e5 ** 2], # all + # [0 ** 2, 32 ** 2], # small + # [32 ** 2, 96 ** 2], # medium + # [96 ** 2, 1e5 ** 2], # large + # [96 ** 2, 128 ** 2], # 96-128 + # [128 ** 2, 256 ** 2], # 128-256 + # [256 ** 2, 512 ** 2], # 256-512 + # [512 ** 2, 1e5 ** 2], # 512-inf + # ] + # assert area in areas, 'unknown area range: {}'.format(area) + # area_range = area_ranges[areas[area]] + # gt_overlaps = np.zeros(0) + # num_pos = 0 + # for i in range(self.num_images): + # # Checking for max_overlaps == 1 avoids including crowd annotations + # # (...pretty hacking :/) + # max_gt_overlaps = self.roidb[i]['gt_overlaps'].toarray().max(axis=1) + # gt_inds = np.where((self.roidb[i]['gt_classes'] > 0) & + # (max_gt_overlaps == 1))[0] + # gt_boxes = self.roidb[i]['boxes'][gt_inds, :] + # gt_areas = self.roidb[i]['seg_areas'][gt_inds] + # valid_gt_inds = np.where((gt_areas >= area_range[0]) & + # (gt_areas <= area_range[1]))[0] + # gt_boxes = gt_boxes[valid_gt_inds, :] + # num_pos += len(valid_gt_inds) + # + # if candidate_boxes is None: + # # If candidate_boxes is not supplied, the default is to use the + # # non-ground-truth boxes from this roidb + # non_gt_inds = np.where(self.roidb[i]['gt_classes'] == 0)[0] + # boxes = self.roidb[i]['boxes'][non_gt_inds, :] + # else: + # boxes = candidate_boxes[i] + # if boxes.shape[0] == 0: + # continue + # if limit is not None and boxes.shape[0] > limit: + # boxes = boxes[:limit, :] + # + # overlaps = bbox_overlaps(boxes.astype(np.float), + # gt_boxes.astype(np.float)) + # + # _gt_overlaps = np.zeros((gt_boxes.shape[0])) + # for j in range(gt_boxes.shape[0]): + # # find which proposal box maximally covers each gt box + # argmax_overlaps = overlaps.argmax(axis=0) + # # and get the iou amount of coverage for each gt box + # max_overlaps = overlaps.max(axis=0) + # # find which gt box is 'best' covered (i.e. 'best' = most iou) + # gt_ind = max_overlaps.argmax() + # gt_ovr = max_overlaps.max() + # assert (gt_ovr >= 0) + # # find the proposal box that covers the best covered gt box + # box_ind = argmax_overlaps[gt_ind] + # # record the iou coverage of this gt box + # _gt_overlaps[j] = overlaps[box_ind, gt_ind] + # assert (_gt_overlaps[j] == gt_ovr) + # # mark the proposal box and the gt box as used + # overlaps[box_ind, :] = -1 + # overlaps[:, gt_ind] = -1 + # # append recorded iou coverage level + # gt_overlaps = np.hstack((gt_overlaps, _gt_overlaps)) + # + # gt_overlaps = np.sort(gt_overlaps) + # if thresholds is None: + # step = 0.05 + # thresholds = np.arange(0.5, 0.95 + 1e-5, step) + # recalls = np.zeros_like(thresholds) + # # compute recall for each iou threshold + # for i, t in enumerate(thresholds): + # recalls[i] = (gt_overlaps >= t).sum() / float(num_pos) + # # ar = 2 * np.trapz(recalls, thresholds) + # ar = recalls.mean() + # return {'ar': ar, 'recalls': recalls, 'thresholds': thresholds, + # 'gt_overlaps': gt_overlaps} + + def create_roidb_from_box_list(self, box_list, gt_roidb): + assert len(box_list) == self.num_images, \ + 'Number of boxes must match number of ground-truth images' + roidb = [] + for i in range(self.num_images): + boxes = box_list[i] + num_boxes = boxes.shape[0] + overlaps = np.zeros((num_boxes, self.num_classes), dtype=np.float32) + + if gt_roidb is not None and gt_roidb[i]['boxes'].size > 0: + gt_boxes = gt_roidb[i]['boxes'] + gt_classes = gt_roidb[i]['gt_classes'] + gt_overlaps = bbox_overlaps(boxes.astype(np.float), + gt_boxes.astype(np.float)) + argmaxes = gt_overlaps.argmax(axis=1) + maxes = gt_overlaps.max(axis=1) + I = np.where(maxes > 0)[0] + overlaps[I, gt_classes[argmaxes[I]]] = maxes[I] + + overlaps = scipy.sparse.csr_matrix(overlaps) + roidb.append({ + 'boxes': boxes, + 'gt_classes': np.zeros((num_boxes,), dtype=np.int32), + 'gt_overlaps': overlaps, + 'flipped': False, + 'seg_areas': np.zeros((num_boxes,), dtype=np.float32), + }) + return roidb + + @staticmethod + def merge_roidbs(a, b): + assert len(a) == len(b) + for i in range(len(a)): + a[i]['boxes'] = np.vstack((a[i]['boxes'], b[i]['boxes'])) + a[i]['gt_classes'] = np.hstack((a[i]['gt_classes'], + b[i]['gt_classes'])) + a[i]['gt_overlaps'] = scipy.sparse.vstack([a[i]['gt_overlaps'], + b[i]['gt_overlaps']]) + a[i]['seg_areas'] = np.hstack((a[i]['seg_areas'], + b[i]['seg_areas'])) + return a + + def competition_mode(self, on): + """Turn competition mode on or off.""" + pass diff --git a/lib/datasets/pascal_voc.py b/lib/datasets/pascal_voc.py new file mode 100644 index 0000000..a79ef90 --- /dev/null +++ b/lib/datasets/pascal_voc.py @@ -0,0 +1,415 @@ +from __future__ import print_function +from __future__ import absolute_import +# -------------------------------------------------------- +# Fast R-CNN +# Copyright (c) 2015 Microsoft +# Licensed under The MIT License [see LICENSE for details] +# Written by Ross Girshick +# -------------------------------------------------------- + +import xml.dom.minidom as minidom + +import os +# import PIL +import numpy as np +import scipy.sparse +import subprocess +import math +import glob +import uuid +import scipy.io as sio +import xml.etree.ElementTree as ET +import pickle +from .imdb import imdb +from .imdb import ROOT_DIR +from . import ds_utils +from .voc_eval import voc_eval + +# TODO: make fast_rcnn irrelevant +# >>>> obsolete, because it depends on sth outside of this project +from model.utils.config import cfg + +try: + xrange # Python 2 +except NameError: + xrange = range # Python 3 + +# <<<< obsolete + + +class pascal_voc(imdb): + def __init__(self, image_set, year, devkit_path=None): + imdb.__init__(self, 'voc_' + year + '_' + image_set) + self._year = year + self._image_set = image_set + self._devkit_path = "VOCdevkit2007" + # self._devkit_path = self._get_default_path() if devkit_path is None \ + # else devkit_path + self._data_path = os.path.join(self._devkit_path, 'VOC' + self._year) + self._classes = ('__background__', # always index 0 + 'aeroplane', 'bicycle', 'bird', 'boat', + 'bottle', 'bus', 'car', 'cat', 'chair', + 'cow', 'diningtable', 'dog', 'horse', + 'motorbike', 'person', 'pottedplant', + 'sheep', 'sofa', 'train', 'tvmonitor') + self._class_to_ind = dict(zip(self.classes, xrange(self.num_classes))) + + self._image_ext = '.jpg' + self._image_index = self._load_image_set_index() + # Default to roidb handler + # self._roidb_handler = self.selective_search_roidb + self._roidb_handler = self.gt_roidb + self._salt = str(uuid.uuid4()) + self._comp_id = 'comp4' + + # PASCAL specific config options + self.config = {'cleanup': True, + 'use_salt': True, + 'use_diff': False, + 'matlab_eval': False, + 'rpn_file': None, + 'min_size': 2} + + assert os.path.exists(self._devkit_path), \ + 'VOCdevkit path does not exist: {}'.format(self._devkit_path) + assert os.path.exists(self._data_path), \ + 'Path does not exist: {}'.format(self._data_path) + self.cat_data = {} + + for i in self._class_to_ind.values(): + # i = 0~20 + self.cat_data[i] = [] + + def image_path_at(self, i): + """ + Return the absolute path to image i in the image sequence. + """ + return self.image_path_from_index(self._image_index[i]) + + def image_id_at(self, i): + """ + Return the absolute path to image i in the image sequence. + """ + return i + + def image_path_from_index(self, index): + """ + Construct an image path from the image's "index" identifier. + """ + image_path = os.path.join(self._data_path, 'JPEGImages', + index + self._image_ext) + assert os.path.exists(image_path), \ + 'Path does not exist: {}'.format(image_path) + return image_path + + def _load_image_set_index(self): + """ + Load the indexes listed in this dataset's image set file. + """ + # Example path to image set file: + # self._devkit_path + /VOCdevkit2007/VOC2007/ImageSets/Main/val.txt + image_set_file = os.path.join(self._data_path, 'ImageSets', 'Main', + self._image_set + '.txt') + assert os.path.exists(image_set_file), \ + 'Path does not exist: {}'.format(image_set_file) + with open(image_set_file) as f: + image_index = [x.strip() for x in f.readlines()] + return image_index + + def _get_default_path(self): + """ + Return the default path where PASCAL VOC is expected to be installed. + """ + return os.path.join(cfg.DATA_DIR, 'VOCdevkit' + self._year) + + def gt_roidb(self): + """ + Return the database of ground-truth regions of interest. + + This function loads/saves from/to a cache file to speed up future calls. + """ + cache_file = os.path.join(self.cache_path, self.name + '_gt_roidb.pkl') + if os.path.exists(cache_file): + with open(cache_file, 'rb') as fid: + [roidb, self.cat_data] = pickle.load(fid) + print('{} gt roidb loaded from {}'.format(self.name, cache_file)) + return roidb + + gt_roidb = [self._load_pascal_annotation(index) + for index in self.image_index] + with open(cache_file, 'wb') as fid: + pickle.dump([gt_roidb,self.cat_data], fid, pickle.HIGHEST_PROTOCOL) + print('wrote gt roidb to {}'.format(cache_file)) + + return gt_roidb + + def selective_search_roidb(self): + """ + Return the database of selective search regions of interest. + Ground-truth ROIs are also included. + + This function loads/saves from/to a cache file to speed up future calls. + """ + cache_file = os.path.join(self.cache_path, + self.name + '_selective_search_roidb.pkl') + + if os.path.exists(cache_file): + with open(cache_file, 'rb') as fid: + roidb = pickle.load(fid) + print('{} ss roidb loaded from {}'.format(self.name, cache_file)) + return roidb + + if int(self._year) == 2007 or self._image_set != 'test': + gt_roidb = self.gt_roidb() + ss_roidb = self._load_selective_search_roidb(gt_roidb) + roidb = imdb.merge_roidbs(gt_roidb, ss_roidb) + else: + roidb = self._load_selective_search_roidb(None) + with open(cache_file, 'wb') as fid: + pickle.dump(roidb, fid, pickle.HIGHEST_PROTOCOL) + print('wrote ss roidb to {}'.format(cache_file)) + + return roidb + + def rpn_roidb(self): + if int(self._year) == 2007 or self._image_set != 'test': + gt_roidb = self.gt_roidb() + rpn_roidb = self._load_rpn_roidb(gt_roidb) + roidb = imdb.merge_roidbs(gt_roidb, rpn_roidb) + else: + roidb = self._load_rpn_roidb(None) + + return roidb + + def _load_rpn_roidb(self, gt_roidb): + filename = self.config['rpn_file'] + print('loading {}'.format(filename)) + assert os.path.exists(filename), \ + 'rpn data not found at: {}'.format(filename) + with open(filename, 'rb') as f: + box_list = pickle.load(f) + return self.create_roidb_from_box_list(box_list, gt_roidb) + + def _load_selective_search_roidb(self, gt_roidb): + filename = os.path.abspath(os.path.join(cfg.DATA_DIR, + 'selective_search_data', + self.name + '.mat')) + assert os.path.exists(filename), \ + 'Selective search data not found at: {}'.format(filename) + raw_data = sio.loadmat(filename)['boxes'].ravel() + + box_list = [] + for i in xrange(raw_data.shape[0]): + boxes = raw_data[i][:, (1, 0, 3, 2)] - 1 + keep = ds_utils.unique_boxes(boxes) + boxes = boxes[keep, :] + keep = ds_utils.filter_small_boxes(boxes, self.config['min_size']) + boxes = boxes[keep, :] + box_list.append(boxes) + + return self.create_roidb_from_box_list(box_list, gt_roidb) + + def _load_pascal_annotation(self, index): + """ + Load image and bounding boxes info from XML file in the PASCAL VOC + format. + """ + filename = os.path.join(self._data_path, 'Annotations', index + '.xml') + tree = ET.parse(filename) + objs = tree.findall('object') + # if not self.config['use_diff']: + # # Exclude the samples labeled as difficult + # non_diff_objs = [ + # obj for obj in objs if int(obj.find('difficult').text) == 0] + # # if len(non_diff_objs) != len(objs): + # # print 'Removed {} difficult objects'.format( + # # len(objs) - len(non_diff_objs)) + # objs = non_diff_objs + num_objs = len(objs) + im_path = self.image_path_from_index(index) + + boxes = np.zeros((num_objs, 4), dtype=np.uint16) + gt_classes = np.zeros((num_objs), dtype=np.int32) + overlaps = np.zeros((num_objs, self.num_classes), dtype=np.float32) + # "Seg" area for pascal is just the box area + seg_areas = np.zeros((num_objs), dtype=np.float32) + ishards = np.zeros((num_objs), dtype=np.int32) + + # Load object bounding boxes into a data frame. + for ix, obj in enumerate(objs): + bbox = obj.find('bndbox') + # Make pixel indexes 0-based + x1 = float(bbox.find('xmin').text) + y1 = float(bbox.find('ymin').text) + x2 = float(bbox.find('xmax').text) - 1 + y2 = float(bbox.find('ymax').text) - 1 + + + diffc = obj.find('difficult') + difficult = 0 if diffc == None else int(diffc.text) + ishards[ix] = difficult + + cls = self._class_to_ind[obj.find('name').text.lower().strip()] + boxes[ix, :] = [x1, y1, x2, y2] + gt_classes[ix] = cls + overlaps[ix, cls] = 1.0 + seg_areas[ix] = (x2 - x1 + 1) * (y2 - y1 + 1) + entry = { + 'boxes': [x1, y1, x2, y2], + 'image_path': im_path + } + self.cat_data[cls].append(entry) + + overlaps = scipy.sparse.csr_matrix(overlaps) + + return {'boxes': boxes, + 'gt_classes': gt_classes, + 'gt_ishard': ishards, + 'gt_overlaps': overlaps, + 'flipped': False, + 'seg_areas': seg_areas} + + def _get_comp_id(self): + comp_id = (self._comp_id + '_' + self._salt if self.config['use_salt'] + else self._comp_id) + return comp_id + + def _get_voc_results_file_template(self): + # VOCdevkit/results/VOC2007/Main/_det_test_aeroplane.txt + filename = self._get_comp_id() + '_det_' + self._image_set + '_{:s}.txt' + filedir = os.path.join(self._devkit_path, 'results', 'VOC' + self._year, 'Main') + if not os.path.exists(filedir): + os.makedirs(filedir) + path = os.path.join(filedir, filename) + return path + + def _write_voc_results_file(self, all_boxes): + for cls_ind, cls in enumerate(self.classes): + if cls == '__background__': + continue + print('Writing {} VOC results file'.format(cls)) + filename = self._get_voc_results_file_template().format(cls) + with open(filename, 'wt') as f: + for im_ind, index in enumerate(self.image_index): + dets = all_boxes[cls_ind][im_ind] + if dets == []: + continue + # the VOCdevkit expects 1-based indices + for k in xrange(dets.shape[0]): + f.write('{:s} {:.3f} {:.1f} {:.1f} {:.1f} {:.1f}\n'. + format(index, dets[k, -1], + dets[k, 0] + 1, dets[k, 1] + 1, + dets[k, 2] + 1, dets[k, 3] + 1)) + + def _do_python_eval(self, output_dir='output'): + annopath = os.path.join( + self._devkit_path, + 'VOC' + self._year, + 'Annotations', + '{:s}.xml') + imagesetfile = os.path.join( + self._devkit_path, + 'VOC' + self._year, + 'ImageSets', + 'Main', + self._image_set + '.txt') + cachedir = os.path.join(self._devkit_path, 'annotations_cache') + aps = [] + # The PASCAL VOC metric changed in 2010 + use_07_metric = True if int(self._year) < 2010 else False + print('VOC07 metric? ' + ('Yes' if use_07_metric else 'No')) + if not os.path.isdir(output_dir): + os.mkdir(output_dir) + for i, cls in enumerate(self._classes): + if cls == '__background__': + continue + filename = self._get_voc_results_file_template().format(cls) + rec, prec, ap = voc_eval( + filename, annopath, imagesetfile, cls, cachedir, ovthresh=0.5, + use_07_metric=use_07_metric) + aps += [ap] + print('AP for {} = {:.4f}'.format(cls, ap)) + with open(os.path.join(output_dir, cls + '_pr.pkl'), 'wb') as f: + pickle.dump({'rec': rec, 'prec': prec, 'ap': ap}, f) + print('Mean AP = {:.4f}'.format(np.mean(aps))) + print('~~~~~~~~') + print('Results:') + for ap in aps: + print('{:.3f}'.format(ap)) + print('{:.3f}'.format(np.mean(aps))) + print('~~~~~~~~') + print('') + print('--------------------------------------------------------------') + print('Results computed with the **unofficial** Python eval code.') + print('Results should be very close to the official MATLAB eval code.') + print('Recompute with `./tools/reval.py --matlab ...` for your paper.') + print('-- Thanks, The Management') + print('--------------------------------------------------------------') + return aps + + def _do_matlab_eval(self, output_dir='output'): + print('-----------------------------------------------------') + print('Computing results with the official MATLAB eval code.') + print('-----------------------------------------------------') + path = os.path.join(cfg.ROOT_DIR, 'lib', 'datasets', + 'VOCdevkit-matlab-wrapper') + cmd = 'cd {} && '.format(path) + cmd += '{:s} -nodisplay -nodesktop '.format(cfg.MATLAB) + cmd += '-r "dbstop if error; ' + cmd += 'voc_eval(\'{:s}\',\'{:s}\',\'{:s}\',\'{:s}\'); quit;"' \ + .format(self._devkit_path, self._get_comp_id(), + self._image_set, output_dir) + print('Running:\n{}'.format(cmd)) + status = subprocess.call(cmd, shell=True) + + def evaluate_detections(self, all_boxes, output_dir): + self._write_voc_results_file(all_boxes) + aps = self._do_python_eval(output_dir) + if self.config['matlab_eval']: + self._do_matlab_eval(output_dir) + if self.config['cleanup']: + for cls in self._classes: + if cls == '__background__': + continue + filename = self._get_voc_results_file_template().format(cls) + os.remove(filename) + return aps + + def competition_mode(self, on): + if on: + self.config['use_salt'] = False + self.config['cleanup'] = False + else: + self.config['use_salt'] = True + self.config['cleanup'] = True + + def filter(self, seen=1): + if seen==1: + self.list = [2,3,4,5,6,7,9,11,12,13,14,15,16,18,19,20] + elif seen==2: + self.list = [1,8,10,17] + elif seen==3: + self.list = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20] + + + + self.inverse_list = self.list + out = list(range(len(self._image_index))) + + for index,tmp in enumerate(self.roidb): + for j in tmp['gt_classes']: + if j in self.list: + out.remove(index) + break + out.reverse() + + for tmp in out: + self._image_index.pop(tmp) + self.roidb.pop(tmp) + +if __name__ == '__main__': + d = pascal_voc('trainval', '2007') + res = d.roidb + from IPython import embed; + + embed() diff --git a/lib/datasets/pascal_voc_rbg.py b/lib/datasets/pascal_voc_rbg.py new file mode 100644 index 0000000..23b4224 --- /dev/null +++ b/lib/datasets/pascal_voc_rbg.py @@ -0,0 +1,312 @@ +# -------------------------------------------------------- +# Fast R-CNN +# Copyright (c) 2015 Microsoft +# Licensed under The MIT License [see LICENSE for details] +# Written by Ross Girshick and Xinlei Chen +# -------------------------------------------------------- +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +import os +from datasets.imdb import imdb +import datasets.ds_utils as ds_utils +import xml.etree.ElementTree as ET +import numpy as np +import scipy.sparse +import scipy.io as sio +# import model.utils.cython_bbox +import pickle +import subprocess +import uuid +from .voc_eval import voc_eval +from model.utils.config import cfg +import pdb + + +class pascal_voc(imdb): + def __init__(self, image_set, year, devkit_path=None): + imdb.__init__(self, 'voc_' + year + '_' + image_set) + self._year = year + self._image_set = image_set + self._devkit_path = self._get_default_path() if devkit_path is None \ + else devkit_path + + + self._data_path = os.path.join(self._devkit_path, 'VOC' + self._year) + self._classes = ('__background__', # always index 0 + 'aeroplane', 'bicycle', 'bird', 'boat', + 'bottle', 'bus', 'car', 'cat', 'chair', + 'cow', 'diningtable', 'dog', 'horse', + 'motorbike', 'person', 'pottedplant', + 'sheep', 'sofa', 'train', 'tvmonitor') + self._class_to_ind = dict(list(zip(self.classes, list(range(self.num_classes))))) + self._image_ext = '.jpg' + self._image_index = self._load_image_set_index() + # Default to roidb handler + self._roidb_handler = self.gt_roidb + self._salt = str(uuid.uuid4()) + self._comp_id = 'comp4' + + # PASCAL specific config options + self.config = {'cleanup': True, + 'use_salt': True, + 'use_diff': False, + 'matlab_eval': False, + 'rpn_file': None} + + assert os.path.exists(self._devkit_path), \ + 'VOCdevkit path does not exist: {}'.format(self._devkit_path) + assert os.path.exists(self._data_path), \ + 'Path does not exist: {}'.format(self._data_path) + + def image_path_at(self, i): + """ + Return the absolute path to image i in the image sequence. + """ + return self.image_path_from_index(self._image_index[i]) + + def image_path_from_index(self, index): + """ + Construct an image path from the image's "index" identifier. + """ + image_path = os.path.join(self._data_path, 'JPEGImages', + index + self._image_ext) + assert os.path.exists(image_path), \ + 'Path does not exist: {}'.format(image_path) + return image_path + + def _load_image_set_index(self): + """ + Load the indexes listed in this dataset's image set file. + """ + # Example path to image set file: + # self._devkit_path + /VOCdevkit2007/VOC2007/ImageSets/Main/val.txt + image_set_file = os.path.join(self._data_path, 'ImageSets', 'Main', + self._image_set + '.txt') + + assert os.path.exists(image_set_file), \ + 'Path does not exist: {}'.format(image_set_file) + with open(image_set_file) as f: + image_index = [x.strip() for x in f.readlines()] + return image_index + + def _get_default_path(self): + """ + Return the default path where PASCAL VOC is expected to be installed. + """ + return os.path.join(cfg.DATA_DIR, 'VOCdevkit' + self._year) + + def gt_roidb(self): + """ + Return the database of ground-truth regions of interest. + + This function loads/saves from/to a cache file to speed up future calls. + """ + cache_file = os.path.join(self.cache_path, self.name + '_gt_roidb.pkl') + if os.path.exists(cache_file): + with open(cache_file, 'rb') as fid: + try: + roidb = pickle.load(fid) + except: + roidb = pickle.load(fid, encoding='bytes') + print('{} gt roidb loaded from {}'.format(self.name, cache_file)) + return roidb + + gt_roidb = [self._load_pascal_annotation(index) + for index in self.image_index] + with open(cache_file, 'wb') as fid: + pickle.dump(gt_roidb, fid, pickle.HIGHEST_PROTOCOL) + print('wrote gt roidb to {}'.format(cache_file)) + + return gt_roidb + + def rpn_roidb(self): + if int(self._year) == 2007 or self._image_set != 'test': + gt_roidb = self.gt_roidb() + rpn_roidb = self._load_rpn_roidb(gt_roidb) + roidb = imdb.merge_roidbs(gt_roidb, rpn_roidb) + else: + roidb = self._load_rpn_roidb(None) + + return roidb + + def _load_rpn_roidb(self, gt_roidb): + filename = self.config['rpn_file'] + print('loading {}'.format(filename)) + assert os.path.exists(filename), \ + 'rpn data not found at: {}'.format(filename) + with open(filename, 'rb') as f: + box_list = pickle.load(f) + return self.create_roidb_from_box_list(box_list, gt_roidb) + + def _load_pascal_annotation(self, index): + """ + Load image and bounding boxes info from XML file in the PASCAL VOC + format. + """ + filename = os.path.join(self._data_path, 'Annotations', index + '.xml') + tree = ET.parse(filename) + objs = tree.findall('object') + if not self.config['use_diff']: + # Exclude the samples labeled as difficult + non_diff_objs = [ + obj for obj in objs if int(obj.find('difficult').text) == 0] + # if len(non_diff_objs) != len(objs): + # print 'Removed {} difficult objects'.format( + # len(objs) - len(non_diff_objs)) + objs = non_diff_objs + num_objs = len(objs) + + boxes = np.zeros((num_objs, 4), dtype=np.uint16) + gt_classes = np.zeros((num_objs), dtype=np.int32) + overlaps = np.zeros((num_objs, self.num_classes), dtype=np.float32) + # "Seg" area for pascal is just the box area + seg_areas = np.zeros((num_objs), dtype=np.float32) + + # Load object bounding boxes into a data frame. + for ix, obj in enumerate(objs): + bbox = obj.find('bndbox') + # Make pixel indexes 0-based + x1 = float(bbox.find('xmin').text) - 1 + y1 = float(bbox.find('ymin').text) - 1 + x2 = float(bbox.find('xmax').text) - 1 + y2 = float(bbox.find('ymax').text) - 1 + cls = self._class_to_ind[obj.find('name').text.lower().strip()] + boxes[ix, :] = [x1, y1, x2, y2] + gt_classes[ix] = cls + overlaps[ix, cls] = 1.0 + seg_areas[ix] = (x2 - x1 + 1) * (y2 - y1 + 1) + + overlaps = scipy.sparse.csr_matrix(overlaps) + + return {'boxes': boxes, + 'gt_classes': gt_classes, + 'gt_overlaps': overlaps, + 'flipped': False, + 'seg_areas': seg_areas} + + def _get_comp_id(self): + comp_id = (self._comp_id + '_' + self._salt if self.config['use_salt'] + else self._comp_id) + return comp_id + + def _get_voc_results_file_template(self): + # VOCdevkit/results/VOC2007/Main/_det_test_aeroplane.txt + filename = self._get_comp_id() + '_det_' + self._image_set + '_{:s}.txt' + path = os.path.join( + self._devkit_path, + 'results', + 'VOC' + self._year, + 'Main', + filename) + return path + + def _write_voc_results_file(self, all_boxes): + for cls_ind, cls in enumerate(self.classes): + if cls == '__background__': + continue + print('Writing {} VOC results file'.format(cls)) + filename = self._get_voc_results_file_template().format(cls) + with open(filename, 'wt') as f: + for im_ind, index in enumerate(self.image_index): + dets = all_boxes[cls_ind][im_ind] + if dets == []: + continue + # the VOCdevkit expects 1-based indices + for k in range(dets.shape[0]): + f.write('{:s} {:.3f} {:.1f} {:.1f} {:.1f} {:.1f}\n'. + format(index, dets[k, -1], + dets[k, 0] + 1, dets[k, 1] + 1, + dets[k, 2] + 1, dets[k, 3] + 1)) + + def _do_python_eval(self, output_dir='output'): + annopath = os.path.join( + self._devkit_path, + 'VOC' + self._year, + 'Annotations', + '{:s}.xml') + imagesetfile = os.path.join( + self._devkit_path, + 'VOC' + self._year, + 'ImageSets', + 'Main', + self._image_set + '.txt') + cachedir = os.path.join(self._devkit_path, 'annotations_cache') + aps = [] + # The PASCAL VOC metric changed in 2010 + use_07_metric = True if int(self._year) < 2010 else False + print('VOC07 metric? ' + ('Yes' if use_07_metric else 'No')) + if not os.path.isdir(output_dir): + os.mkdir(output_dir) + for i, cls in enumerate(self._classes): + if cls == '__background__': + continue + filename = self._get_voc_results_file_template().format(cls) + rec, prec, ap = voc_eval( + filename, annopath, imagesetfile, cls, cachedir, ovthresh=0.5, + use_07_metric=use_07_metric) + aps += [ap] + print(('AP for {} = {:.4f}'.format(cls, ap))) + with open(os.path.join(output_dir, cls + '_pr.pkl'), 'wb') as f: + pickle.dump({'rec': rec, 'prec': prec, 'ap': ap}, f) + print(('Mean AP = {:.4f}'.format(np.mean(aps)))) + print('~~~~~~~~') + print('Results:') + for ap in aps: + print(('{:.3f}'.format(ap))) + print(('{:.3f}'.format(np.mean(aps)))) + print('~~~~~~~~') + print('') + print('--------------------------------------------------------------') + print('Results computed with the **unofficial** Python eval code.') + print('Results should be very close to the official MATLAB eval code.') + print('Recompute with `./tools/reval.py --matlab ...` for your paper.') + print('-- Thanks, The Management') + print('--------------------------------------------------------------') + + def _do_matlab_eval(self, output_dir='output'): + print('-----------------------------------------------------') + print('Computing results with the official MATLAB eval code.') + print('-----------------------------------------------------') + path = os.path.join(cfg.ROOT_DIR, 'lib', 'datasets', + 'VOCdevkit-matlab-wrapper') + cmd = 'cd {} && '.format(path) + cmd += '{:s} -nodisplay -nodesktop '.format(cfg.MATLAB) + cmd += '-r "dbstop if error; ' + cmd += 'voc_eval(\'{:s}\',\'{:s}\',\'{:s}\',\'{:s}\'); quit;"' \ + .format(self._devkit_path, self._get_comp_id(), + self._image_set, output_dir) + print(('Running:\n{}'.format(cmd))) + status = subprocess.call(cmd, shell=True) + + def evaluate_detections(self, all_boxes, output_dir): + pdb.set_trace() + self._write_voc_results_file(all_boxes) + self._do_python_eval(output_dir) + if self.config['matlab_eval']: + self._do_matlab_eval(output_dir) + if self.config['cleanup']: + for cls in self._classes: + if cls == '__background__': + continue + filename = self._get_voc_results_file_template().format(cls) + os.remove(filename) + + def competition_mode(self, on): + if on: + self.config['use_salt'] = False + self.config['cleanup'] = False + else: + self.config['use_salt'] = True + self.config['cleanup'] = True + + +if __name__ == '__main__': + from datasets.pascal_voc import pascal_voc + + d = pascal_voc('trainval', '2007') + res = d.roidb + from IPython import embed; + + embed() diff --git a/lib/datasets/pascal_voc_sketch.py b/lib/datasets/pascal_voc_sketch.py new file mode 100644 index 0000000..98868c0 --- /dev/null +++ b/lib/datasets/pascal_voc_sketch.py @@ -0,0 +1,420 @@ +from __future__ import print_function +from __future__ import absolute_import +# -------------------------------------------------------- +# Fast R-CNN +# Copyright (c) 2015 Microsoft +# Licensed under The MIT License [see LICENSE for details] +# Written by Ross Girshick +# -------------------------------------------------------- + +import xml.dom.minidom as minidom + +import os +# import PIL +import numpy as np +import scipy.sparse +import subprocess +import math +import glob +import uuid +import scipy.io as sio +import xml.etree.ElementTree as ET +import pickle +from .imdb import imdb +from .imdb import ROOT_DIR +from . import ds_utils +from .voc_eval import voc_eval + +# TODO: make fast_rcnn irrelevant +# >>>> obsolete, because it depends on sth outside of this project +from model.utils.config import cfg + +try: + xrange # Python 2 +except NameError: + xrange = range # Python 3 + +# <<<< obsolete + + +class pascal_voc(imdb): + def __init__(self, image_set, year, devkit_path=None): + imdb.__init__(self, 'voc_' + year + '_' + image_set) + self._year = year + self._image_set = image_set + self._devkit_path = "../data/VOCdevkit2007" + # self._devkit_path = self._get_default_path() if devkit_path is None \ + # else devkit_path + self._data_path = os.path.join(self._devkit_path, 'VOC' + self._year) + self._classes = ('__background__', + 'bicycle', 'bird', + 'bus', 'car', 'cat', 'chair', + 'cow', 'dog', 'horse', + 'sheep') + self._class_to_ind = dict(zip(self.classes, xrange(self.num_classes))) + + self._image_ext = '.jpg' + self._image_index = self._load_image_set_index() + # Default to roidb handler + # self._roidb_handler = self.selective_search_roidb + self._roidb_handler = self.gt_roidb + self._salt = str(uuid.uuid4()) + self._comp_id = 'comp4' + + # PASCAL specific config options + self.config = {'cleanup': True, + 'use_salt': True, + 'use_diff': False, + 'matlab_eval': False, + 'rpn_file': None, + 'min_size': 2} + + assert os.path.exists(self._devkit_path), \ + 'VOCdevkit path does not exist: {}'.format(self._devkit_path) + assert os.path.exists(self._data_path), \ + 'Path does not exist: {}'.format(self._data_path) + self.cat_data = {} + + for i in self._class_to_ind.values(): + # i = 0~20 + self.cat_data[i] = [] + + def image_path_at(self, i): + """ + Return the absolute path to image i in the image sequence. + """ + return self.image_path_from_index(self._image_index[i]) + + def image_id_at(self, i): + """ + Return the absolute path to image i in the image sequence. + """ + return i + + def image_path_from_index(self, index): + """ + Construct an image path from the image's "index" identifier. + """ + image_path = os.path.join(self._data_path, 'JPEGImages', + index + self._image_ext) + assert os.path.exists(image_path), \ + 'Path does not exist: {}'.format(image_path) + return image_path + + def _load_image_set_index(self): + """ + Load the indexes listed in this dataset's image set file. + """ + # Example path to image set file: + # self._devkit_path + /VOCdevkit2007/VOC2007/ImageSets/Main/val.txt + image_set_file = os.path.join(self._data_path, 'ImageSets', 'Main', + self._image_set + '.txt') + assert os.path.exists(image_set_file), \ + 'Path does not exist: {}'.format(image_set_file) + with open(image_set_file) as f: + image_index = [x.strip() for x in f.readlines()] + return image_index + + def _get_default_path(self): + """ + Return the default path where PASCAL VOC is expected to be installed. + """ + return os.path.join(cfg.DATA_DIR, 'VOCdevkit' + self._year) + + def gt_roidb(self): + """ + Return the database of ground-truth regions of interest. + + This function loads/saves from/to a cache file to speed up future calls. + """ + cache_file = os.path.join(self.cache_path, self.name + '_gt_roidb.pkl') + if os.path.exists(cache_file): + with open(cache_file, 'rb') as fid: + [roidb, self.cat_data] = pickle.load(fid) + print('{} gt roidb loaded from {}'.format(self.name, cache_file)) + return roidb + + gt_roidb = [self._load_pascal_annotation(index) + for index in self.image_index] + with open(cache_file, 'wb') as fid: + pickle.dump([gt_roidb,self.cat_data], fid, pickle.HIGHEST_PROTOCOL) + print('wrote gt roidb to {}'.format(cache_file)) + + return gt_roidb + + def selective_search_roidb(self): + """ + Return the database of selective search regions of interest. + Ground-truth ROIs are also included. + + This function loads/saves from/to a cache file to speed up future calls. + """ + cache_file = os.path.join(self.cache_path, + self.name + '_selective_search_roidb.pkl') + + if os.path.exists(cache_file): + with open(cache_file, 'rb') as fid: + roidb = pickle.load(fid) + print('{} ss roidb loaded from {}'.format(self.name, cache_file)) + return roidb + + if int(self._year) == 2007 or self._image_set != 'test': + gt_roidb = self.gt_roidb() + ss_roidb = self._load_selective_search_roidb(gt_roidb) + roidb = imdb.merge_roidbs(gt_roidb, ss_roidb) + else: + roidb = self._load_selective_search_roidb(None) + with open(cache_file, 'wb') as fid: + pickle.dump(roidb, fid, pickle.HIGHEST_PROTOCOL) + print('wrote ss roidb to {}'.format(cache_file)) + + return roidb + + def rpn_roidb(self): + if int(self._year) == 2007 or self._image_set != 'test': + gt_roidb = self.gt_roidb() + rpn_roidb = self._load_rpn_roidb(gt_roidb) + roidb = imdb.merge_roidbs(gt_roidb, rpn_roidb) + else: + roidb = self._load_rpn_roidb(None) + + return roidb + + def _load_rpn_roidb(self, gt_roidb): + filename = self.config['rpn_file'] + print('loading {}'.format(filename)) + assert os.path.exists(filename), \ + 'rpn data not found at: {}'.format(filename) + with open(filename, 'rb') as f: + box_list = pickle.load(f) + return self.create_roidb_from_box_list(box_list, gt_roidb) + + def _load_selective_search_roidb(self, gt_roidb): + filename = os.path.abspath(os.path.join(cfg.DATA_DIR, + 'selective_search_data', + self.name + '.mat')) + assert os.path.exists(filename), \ + 'Selective search data not found at: {}'.format(filename) + raw_data = sio.loadmat(filename)['boxes'].ravel() + + box_list = [] + for i in xrange(raw_data.shape[0]): + boxes = raw_data[i][:, (1, 0, 3, 2)] - 1 + keep = ds_utils.unique_boxes(boxes) + boxes = boxes[keep, :] + keep = ds_utils.filter_small_boxes(boxes, self.config['min_size']) + boxes = boxes[keep, :] + box_list.append(boxes) + + return self.create_roidb_from_box_list(box_list, gt_roidb) + + def _load_pascal_annotation(self, index): + """ + Load image and bounding boxes info from XML file in the PASCAL VOC + format. + """ + filename = os.path.join(self._data_path, 'Annotations', index + '.xml') + tree = ET.parse(filename) + objs = tree.findall('object') + # if not self.config['use_diff']: + # # Exclude the samples labeled as difficult + # non_diff_objs = [ + # obj for obj in objs if int(obj.find('difficult').text) == 0] + # # if len(non_diff_objs) != len(objs): + # # print 'Removed {} difficult objects'.format( + # # len(objs) - len(non_diff_objs)) + # objs = non_diff_objs + num_objs = len(objs) + im_path = self.image_path_from_index(index) + + boxes = np.zeros((num_objs, 4), dtype=np.uint16) + gt_classes = np.zeros((num_objs), dtype=np.int32) + overlaps = np.zeros((num_objs, self.num_classes), dtype=np.float32) + # "Seg" area for pascal is just the box area + seg_areas = np.zeros((num_objs), dtype=np.float32) + ishards = np.zeros((num_objs), dtype=np.int32) + + # Load object bounding boxes into a data frame. + for ix, obj in enumerate(objs): + bbox = obj.find('bndbox') + # Make pixel indexes 0-based + x1 = float(bbox.find('xmin').text) + y1 = float(bbox.find('ymin').text) + x2 = float(bbox.find('xmax').text) - 1 + y2 = float(bbox.find('ymax').text) - 1 + + + diffc = obj.find('difficult') + difficult = 0 if diffc == None else int(diffc.text) + ishards[ix] = difficult + if obj.find('name').text.lower().strip() in self._classes: + cls = self._class_to_ind[obj.find('name').text.lower().strip()] + boxes[ix, :] = [x1, y1, x2, y2] + gt_classes[ix] = cls + overlaps[ix, cls] = 1.0 + seg_areas[ix] = (x2 - x1 + 1) * (y2 - y1 + 1) + entry = { + 'boxes': [x1, y1, x2, y2], + 'image_path': im_path + } + self.cat_data[cls].append(entry) + + overlaps = scipy.sparse.csr_matrix(overlaps) + + return {'boxes': boxes, + 'gt_classes': gt_classes, + 'gt_ishard': ishards, + 'gt_overlaps': overlaps, + 'flipped': False, + 'seg_areas': seg_areas} + + def _get_comp_id(self): + comp_id = (self._comp_id + '_' + self._salt if self.config['use_salt'] + else self._comp_id) + return comp_id + + def _get_voc_results_file_template(self): + # VOCdevkit/results/VOC2007/Main/_det_test_aeroplane.txt + filename = self._get_comp_id() + '_det_' + self._image_set + '_{:s}.txt' + filedir = os.path.join(self._devkit_path, 'results', 'VOC' + self._year, 'Main') + if not os.path.exists(filedir): + os.makedirs(filedir) + path = os.path.join(filedir, filename) + return path + + def _write_voc_results_file(self, all_boxes): + for cls_ind, cls in enumerate(self.classes): + if cls == '__background__': + continue + print('Writing {} VOC results file'.format(cls)) + filename = self._get_voc_results_file_template().format(cls) + with open(filename, 'wt') as f: + for im_ind, index in enumerate(self.image_index): + dets = all_boxes[cls_ind][im_ind] + if dets == []: + continue + # the VOCdevkit expects 1-based indices + for k in xrange(dets.shape[0]): + f.write('{:s} {:.3f} {:.1f} {:.1f} {:.1f} {:.1f}\n'. + format(index, dets[k, -1], + dets[k, 0] + 1, dets[k, 1] + 1, + dets[k, 2] + 1, dets[k, 3] + 1)) + + def _do_python_eval(self, output_dir='output'): + annopath = os.path.join( + self._devkit_path, + 'VOC' + self._year, + 'Annotations', + '{:s}.xml') + imagesetfile = os.path.join( + self._devkit_path, + 'VOC' + self._year, + 'ImageSets', + 'Main', + self._image_set + '.txt') + cachedir = os.path.join(self._devkit_path, 'annotations_cache') + aps = [] + # The PASCAL VOC metric changed in 2010 + use_07_metric = True if int(self._year) < 2010 else False + print('VOC07 metric? ' + ('Yes' if use_07_metric else 'No')) + if not os.path.isdir(output_dir): + os.mkdir(output_dir) + for i, cls in enumerate(self._classes): + if cls == '__background__': + continue + print (i, cls) + filename = self._get_voc_results_file_template().format(cls) + rec, prec, ap = voc_eval( + filename, annopath, imagesetfile, cls, cachedir, ovthresh=0.5, + use_07_metric=use_07_metric) + aps += [ap] + print('AP for {} = {:.4f}'.format(cls, ap)) + with open(os.path.join(output_dir, cls + '_pr.pkl'), 'wb') as f: + pickle.dump({'rec': rec, 'prec': prec, 'ap': ap}, f) + print('Mean AP = {:.4f}'.format(np.mean(aps))) + print('~~~~~~~~') + print('Results:') + for ap in aps: + print('{:.3f}'.format(ap)) + print('{:.3f}'.format(np.mean(aps))) + print('~~~~~~~~') + print('') + print('--------------------------------------------------------------') + print('Results computed with the **unofficial** Python eval code.') + print('Results should be very close to the official MATLAB eval code.') + print('Recompute with `./tools/reval.py --matlab ...` for your paper.') + print('-- Thanks, The Management') + print('--------------------------------------------------------------') + return aps + + def _do_matlab_eval(self, output_dir='output'): + print('-----------------------------------------------------') + print('Computing results with the official MATLAB eval code.') + print('-----------------------------------------------------') + path = os.path.join(cfg.ROOT_DIR, 'lib', 'datasets', + 'VOCdevkit-matlab-wrapper') + cmd = 'cd {} && '.format(path) + cmd += '{:s} -nodisplay -nodesktop '.format(cfg.MATLAB) + cmd += '-r "dbstop if error; ' + cmd += 'voc_eval(\'{:s}\',\'{:s}\',\'{:s}\',\'{:s}\'); quit;"' \ + .format(self._devkit_path, self._get_comp_id(), + self._image_set, output_dir) + print('Running:\n{}'.format(cmd)) + status = subprocess.call(cmd, shell=True) + + def evaluate_detections(self, all_boxes, output_dir): + self._write_voc_results_file(all_boxes) + aps = self._do_python_eval(output_dir) + if self.config['matlab_eval']: + self._do_matlab_eval(output_dir) + if self.config['cleanup']: + for cls in self._classes: + if cls == '__background__': + continue + # filename = self._get_voc_results_file_template().format(cls) + # os.remove(filename) + return aps + + def competition_mode(self, on): + if on: + self.config['use_salt'] = False + self.config['cleanup'] = False + else: + self.config['use_salt'] = True + self.config['cleanup'] = True + + def filter(self, seen=1): + if seen==1: + self.list = [2,3,4,5,6,7,9,11,12,13,14,15,16,18,19,20] + elif seen==2: + self.list = [1,8,10,17] + elif seen==3: + self.list = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20] + elif seen==5: + self.list = [2,3,4,6,7,8,10] + elif seen==6: + self.list = [1,5,9] + elif seen==7 : + self.list = [1,2,3,4,5,6,7,8,9,10] + + + self.inverse_list = self.list + out = list(range(len(self._image_index))) + + for index,tmp in enumerate(self.roidb): + for j in tmp['gt_classes']: + if j in self.list: + out.remove(index) + break + out.reverse() + + for tmp in out: + self._image_index.pop(tmp) + self.roidb.pop(tmp) + +if __name__ == '__main__': + d = pascal_voc('trainval', '2007') + res = d.roidb + from IPython import embed; + + embed() \ No newline at end of file diff --git a/lib/datasets/pascal_voc_sketch_v2.py b/lib/datasets/pascal_voc_sketch_v2.py new file mode 100644 index 0000000..a962da2 --- /dev/null +++ b/lib/datasets/pascal_voc_sketch_v2.py @@ -0,0 +1,420 @@ +from __future__ import print_function +from __future__ import absolute_import +# -------------------------------------------------------- +# Fast R-CNN +# Copyright (c) 2015 Microsoft +# Licensed under The MIT License [see LICENSE for details] +# Written by Ross Girshick +# -------------------------------------------------------- + +import xml.dom.minidom as minidom + +import os +# import PIL +import numpy as np +import scipy.sparse +import subprocess +import math +import glob +import uuid +import scipy.io as sio +import xml.etree.ElementTree as ET +import pickle +from .imdb import imdb +from .imdb import ROOT_DIR +from . import ds_utils +from .voc_eval import voc_eval + +# TODO: make fast_rcnn irrelevant +# >>>> obsolete, because it depends on sth outside of this project +from model.utils.config import cfg + +try: + xrange # Python 2 +except NameError: + xrange = range # Python 3 + +# <<<< obsolete + + +class pascal_voc(imdb): + def __init__(self, image_set, year, devkit_path=None): + imdb.__init__(self, 'voc_' + year + '_' + image_set) + self._year = year + self._image_set = image_set + self._devkit_path = "../data/VOCdevkit2007" + # self._devkit_path = self._get_default_path() if devkit_path is None \ + # else devkit_path + self._data_path = os.path.join(self._devkit_path, 'VOC' + self._year) + self._classes = ( + 'bicycle', 'bird', + 'bus', 'car', 'cat', 'chair', + 'cow', 'dog', 'horse', + 'sheep') + self._class_to_ind = dict(zip(self.classes, xrange(self.num_classes))) + + self._image_ext = '.jpg' + self._image_index = self._load_image_set_index() + # Default to roidb handler + # self._roidb_handler = self.selective_search_roidb + self._roidb_handler = self.gt_roidb + self._salt = str(uuid.uuid4()) + self._comp_id = 'comp4' + + # PASCAL specific config options + self.config = {'cleanup': True, + 'use_salt': True, + 'use_diff': False, + 'matlab_eval': False, + 'rpn_file': None, + 'min_size': 2} + + assert os.path.exists(self._devkit_path), \ + 'VOCdevkit path does not exist: {}'.format(self._devkit_path) + assert os.path.exists(self._data_path), \ + 'Path does not exist: {}'.format(self._data_path) + self.cat_data = {} + + for i in self._class_to_ind.values(): + # i = 0~20 + self.cat_data[i] = [] + + def image_path_at(self, i): + """ + Return the absolute path to image i in the image sequence. + """ + return self.image_path_from_index(self._image_index[i]) + + def image_id_at(self, i): + """ + Return the absolute path to image i in the image sequence. + """ + return i + + def image_path_from_index(self, index): + """ + Construct an image path from the image's "index" identifier. + """ + image_path = os.path.join(self._data_path, 'JPEGImages', + index + self._image_ext) + assert os.path.exists(image_path), \ + 'Path does not exist: {}'.format(image_path) + return image_path + + def _load_image_set_index(self): + """ + Load the indexes listed in this dataset's image set file. + """ + # Example path to image set file: + # self._devkit_path + /VOCdevkit2007/VOC2007/ImageSets/Main/val.txt + image_set_file = os.path.join(self._data_path, 'ImageSets', 'Main', + self._image_set + '.txt') + assert os.path.exists(image_set_file), \ + 'Path does not exist: {}'.format(image_set_file) + with open(image_set_file) as f: + image_index = [x.strip() for x in f.readlines()] + return image_index + + def _get_default_path(self): + """ + Return the default path where PASCAL VOC is expected to be installed. + """ + return os.path.join(cfg.DATA_DIR, 'VOCdevkit' + self._year) + + def gt_roidb(self): + """ + Return the database of ground-truth regions of interest. + + This function loads/saves from/to a cache file to speed up future calls. + """ + cache_file = os.path.join(self.cache_path, self.name + '_gt_roidb.pkl') + if os.path.exists(cache_file): + with open(cache_file, 'rb') as fid: + [roidb, self.cat_data] = pickle.load(fid) + print('{} gt roidb loaded from {}'.format(self.name, cache_file)) + return roidb + + gt_roidb = [self._load_pascal_annotation(index) + for index in self.image_index] + with open(cache_file, 'wb') as fid: + pickle.dump([gt_roidb,self.cat_data], fid, pickle.HIGHEST_PROTOCOL) + print('wrote gt roidb to {}'.format(cache_file)) + + return gt_roidb + + def selective_search_roidb(self): + """ + Return the database of selective search regions of interest. + Ground-truth ROIs are also included. + + This function loads/saves from/to a cache file to speed up future calls. + """ + cache_file = os.path.join(self.cache_path, + self.name + '_selective_search_roidb.pkl') + + if os.path.exists(cache_file): + with open(cache_file, 'rb') as fid: + roidb = pickle.load(fid) + print('{} ss roidb loaded from {}'.format(self.name, cache_file)) + return roidb + + if int(self._year) == 2007 or self._image_set != 'test': + gt_roidb = self.gt_roidb() + ss_roidb = self._load_selective_search_roidb(gt_roidb) + roidb = imdb.merge_roidbs(gt_roidb, ss_roidb) + else: + roidb = self._load_selective_search_roidb(None) + with open(cache_file, 'wb') as fid: + pickle.dump(roidb, fid, pickle.HIGHEST_PROTOCOL) + print('wrote ss roidb to {}'.format(cache_file)) + + return roidb + + def rpn_roidb(self): + if int(self._year) == 2007 or self._image_set != 'test': + gt_roidb = self.gt_roidb() + rpn_roidb = self._load_rpn_roidb(gt_roidb) + roidb = imdb.merge_roidbs(gt_roidb, rpn_roidb) + else: + roidb = self._load_rpn_roidb(None) + + return roidb + + def _load_rpn_roidb(self, gt_roidb): + filename = self.config['rpn_file'] + print('loading {}'.format(filename)) + assert os.path.exists(filename), \ + 'rpn data not found at: {}'.format(filename) + with open(filename, 'rb') as f: + box_list = pickle.load(f) + return self.create_roidb_from_box_list(box_list, gt_roidb) + + def _load_selective_search_roidb(self, gt_roidb): + filename = os.path.abspath(os.path.join(cfg.DATA_DIR, + 'selective_search_data', + self.name + '.mat')) + assert os.path.exists(filename), \ + 'Selective search data not found at: {}'.format(filename) + raw_data = sio.loadmat(filename)['boxes'].ravel() + + box_list = [] + for i in xrange(raw_data.shape[0]): + boxes = raw_data[i][:, (1, 0, 3, 2)] - 1 + keep = ds_utils.unique_boxes(boxes) + boxes = boxes[keep, :] + keep = ds_utils.filter_small_boxes(boxes, self.config['min_size']) + boxes = boxes[keep, :] + box_list.append(boxes) + + return self.create_roidb_from_box_list(box_list, gt_roidb) + + def _load_pascal_annotation(self, index): + """ + Load image and bounding boxes info from XML file in the PASCAL VOC + format. + """ + filename = os.path.join(self._data_path, 'Annotations', index + '.xml') + tree = ET.parse(filename) + objs = tree.findall('object') + # if not self.config['use_diff']: + # # Exclude the samples labeled as difficult + # non_diff_objs = [ + # obj for obj in objs if int(obj.find('difficult').text) == 0] + # # if len(non_diff_objs) != len(objs): + # # print 'Removed {} difficult objects'.format( + # # len(objs) - len(non_diff_objs)) + # objs = non_diff_objs + num_objs = len(objs) + im_path = self.image_path_from_index(index) + + boxes = np.zeros((num_objs, 4), dtype=np.uint16) + gt_classes = np.zeros((num_objs), dtype=np.int32) + overlaps = np.zeros((num_objs, self.num_classes), dtype=np.float32) + # "Seg" area for pascal is just the box area + seg_areas = np.zeros((num_objs), dtype=np.float32) + ishards = np.zeros((num_objs), dtype=np.int32) + + # Load object bounding boxes into a data frame. + for ix, obj in enumerate(objs): + bbox = obj.find('bndbox') + # Make pixel indexes 0-based + x1 = float(bbox.find('xmin').text) + y1 = float(bbox.find('ymin').text) + x2 = float(bbox.find('xmax').text) - 1 + y2 = float(bbox.find('ymax').text) - 1 + + + diffc = obj.find('difficult') + difficult = 0 if diffc == None else int(diffc.text) + ishards[ix] = difficult + if obj.find('name').text.lower().strip() in self._classes: + cls = self._class_to_ind[obj.find('name').text.lower().strip()] + boxes[ix, :] = [x1, y1, x2, y2] + gt_classes[ix] = cls + overlaps[ix, cls] = 1.0 + seg_areas[ix] = (x2 - x1 + 1) * (y2 - y1 + 1) + entry = { + 'boxes': [x1, y1, x2, y2], + 'image_path': im_path + } + self.cat_data[cls].append(entry) + + overlaps = scipy.sparse.csr_matrix(overlaps) + + return {'boxes': boxes, + 'gt_classes': gt_classes, + 'gt_ishard': ishards, + 'gt_overlaps': overlaps, + 'flipped': False, + 'seg_areas': seg_areas} + + def _get_comp_id(self): + comp_id = (self._comp_id + '_' + self._salt if self.config['use_salt'] + else self._comp_id) + return comp_id + + def _get_voc_results_file_template(self): + # VOCdevkit/results/VOC2007/Main/_det_test_aeroplane.txt + filename = self._get_comp_id() + '_det_' + self._image_set + '_{:s}.txt' + filedir = os.path.join(self._devkit_path, 'results', 'VOC' + self._year, 'Main') + if not os.path.exists(filedir): + os.makedirs(filedir) + path = os.path.join(filedir, filename) + return path + + def _write_voc_results_file(self, all_boxes): + for cls_ind, cls in enumerate(self.classes): + if cls == '__background__': + continue + print('Writing {} VOC results file'.format(cls)) + filename = self._get_voc_results_file_template().format(cls) + with open(filename, 'wt') as f: + for im_ind, index in enumerate(self.image_index): + dets = all_boxes[cls_ind][im_ind] + if dets == []: + continue + # the VOCdevkit expects 1-based indices + for k in xrange(dets.shape[0]): + f.write('{:s} {:.3f} {:.1f} {:.1f} {:.1f} {:.1f}\n'. + format(index, dets[k, -1], + dets[k, 0] + 1, dets[k, 1] + 1, + dets[k, 2] + 1, dets[k, 3] + 1)) + + def _do_python_eval(self, output_dir='output'): + annopath = os.path.join( + self._devkit_path, + 'VOC' + self._year, + 'Annotations', + '{:s}.xml') + imagesetfile = os.path.join( + self._devkit_path, + 'VOC' + self._year, + 'ImageSets', + 'Main', + self._image_set + '.txt') + cachedir = os.path.join(self._devkit_path, 'annotations_cache') + aps = [] + # The PASCAL VOC metric changed in 2010 + use_07_metric = True if int(self._year) < 2010 else False + print('VOC07 metric? ' + ('Yes' if use_07_metric else 'No')) + if not os.path.isdir(output_dir): + os.mkdir(output_dir) + for i, cls in enumerate(self._classes): + if cls == '__background__': + continue + print (i, cls) + filename = self._get_voc_results_file_template().format(cls) + rec, prec, ap = voc_eval( + filename, annopath, imagesetfile, cls, cachedir, ovthresh=0.5, + use_07_metric=use_07_metric) + aps += [ap] + print('AP for {} = {:.4f}'.format(cls, ap)) + with open(os.path.join(output_dir, cls + '_pr.pkl'), 'wb') as f: + pickle.dump({'rec': rec, 'prec': prec, 'ap': ap}, f) + print('Mean AP = {:.4f}'.format(np.mean(aps))) + print('~~~~~~~~') + print('Results:') + for ap in aps: + print('{:.3f}'.format(ap)) + print('{:.3f}'.format(np.mean(aps))) + print('~~~~~~~~') + print('') + print('--------------------------------------------------------------') + print('Results computed with the **unofficial** Python eval code.') + print('Results should be very close to the official MATLAB eval code.') + print('Recompute with `./tools/reval.py --matlab ...` for your paper.') + print('-- Thanks, The Management') + print('--------------------------------------------------------------') + return aps + + def _do_matlab_eval(self, output_dir='output'): + print('-----------------------------------------------------') + print('Computing results with the official MATLAB eval code.') + print('-----------------------------------------------------') + path = os.path.join(cfg.ROOT_DIR, 'lib', 'datasets', + 'VOCdevkit-matlab-wrapper') + cmd = 'cd {} && '.format(path) + cmd += '{:s} -nodisplay -nodesktop '.format(cfg.MATLAB) + cmd += '-r "dbstop if error; ' + cmd += 'voc_eval(\'{:s}\',\'{:s}\',\'{:s}\',\'{:s}\'); quit;"' \ + .format(self._devkit_path, self._get_comp_id(), + self._image_set, output_dir) + print('Running:\n{}'.format(cmd)) + status = subprocess.call(cmd, shell=True) + + def evaluate_detections(self, all_boxes, output_dir): + self._write_voc_results_file(all_boxes) + aps = self._do_python_eval(output_dir) + if self.config['matlab_eval']: + self._do_matlab_eval(output_dir) + if self.config['cleanup']: + for cls in self._classes: + if cls == '__background__': + continue + # filename = self._get_voc_results_file_template().format(cls) + # os.remove(filename) + return aps + + def competition_mode(self, on): + if on: + self.config['use_salt'] = False + self.config['cleanup'] = False + else: + self.config['use_salt'] = True + self.config['cleanup'] = True + + def filter(self, seen=1): + if seen==1: + self.list = [2,3,4,5,6,7,9,11,12,13,14,15,16,18,19,20] + elif seen==2: + self.list = [1,8,10,17] + elif seen==3: + self.list = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20] + elif seen==5: + self.list = [2,3,4,6,7,8,10] + elif seen==6: + self.list = [1,5,9] + elif seen==7 : + self.list = [1,2,3,4,5,6,7,8,9,10] + + + self.inverse_list = self.list + out = list(range(len(self._image_index))) + + for index,tmp in enumerate(self.roidb): + for j in tmp['gt_classes']: + if j in self.list: + out.remove(index) + break + out.reverse() + + for tmp in out: + self._image_index.pop(tmp) + self.roidb.pop(tmp) + +if __name__ == '__main__': + d = pascal_voc('trainval', '2007') + res = d.roidb + from IPython import embed; + + embed() \ No newline at end of file diff --git a/lib/datasets/tools/mcg_munge.py b/lib/datasets/tools/mcg_munge.py new file mode 100644 index 0000000..854b3f8 --- /dev/null +++ b/lib/datasets/tools/mcg_munge.py @@ -0,0 +1,39 @@ +from __future__ import print_function +import os +import sys + +"""Hacky tool to convert file system layout of MCG boxes downloaded from +http://www.eecs.berkeley.edu/Research/Projects/CS/vision/grouping/mcg/ +so that it's consistent with those computed by Jan Hosang (see: +http://www.mpi-inf.mpg.de/departments/computer-vision-and-multimodal- + computing/research/object-recognition-and-scene-understanding/how- + good-are-detection-proposals-really/) + +NB: Boxes from the MCG website are in (y1, x1, y2, x2) order. +Boxes from Hosang et al. are in (x1, y1, x2, y2) order. +""" + +def munge(src_dir): + # stored as: ./MCG-COCO-val2014-boxes/COCO_val2014_000000193401.mat + # want: ./MCG/mat/COCO_val2014_0/COCO_val2014_000000141/COCO_val2014_000000141334.mat + + files = os.listdir(src_dir) + for fn in files: + base, ext = os.path.splitext(fn) + # first 14 chars / first 22 chars / all chars + .mat + # COCO_val2014_0/COCO_val2014_000000447/COCO_val2014_000000447991.mat + first = base[:14] + second = base[:22] + dst_dir = os.path.join('MCG', 'mat', first, second) + if not os.path.exists(dst_dir): + os.makedirs(dst_dir) + src = os.path.join(src_dir, fn) + dst = os.path.join(dst_dir, fn) + print('MV: {} -> {}'.format(src, dst)) + os.rename(src, dst) + +if __name__ == '__main__': + # src_dir should look something like: + # src_dir = 'MCG-COCO-val2014-boxes' + src_dir = sys.argv[1] + munge(src_dir) diff --git a/lib/datasets/vg.py b/lib/datasets/vg.py new file mode 100644 index 0000000..3c1a1a3 --- /dev/null +++ b/lib/datasets/vg.py @@ -0,0 +1,407 @@ +from __future__ import print_function +from __future__ import absolute_import +# -------------------------------------------------------- +# Fast R-CNN +# Copyright (c) 2015 Microsoft +# Licensed under The MIT License [see LICENSE for details] +# Written by Ross Girshick +# -------------------------------------------------------- + +import os +from datasets.imdb import imdb +import datasets.ds_utils as ds_utils +import xml.etree.ElementTree as ET +import numpy as np +import scipy.sparse +import gzip +import PIL +import json +from .vg_eval import vg_eval +from model.utils.config import cfg +import pickle +import pdb +try: + xrange # Python 2 +except NameError: + xrange = range # Python 3 + + +class vg(imdb): + def __init__(self, version, image_set, ): + imdb.__init__(self, 'vg_' + version + '_' + image_set) + self._version = version + self._image_set = image_set + self._data_path = os.path.join(cfg.DATA_DIR, 'genome') + self._img_path = os.path.join(cfg.DATA_DIR, 'vg') + # VG specific config options + self.config = {'cleanup' : False} + + # Load classes + self._classes = ['__background__'] + self._class_to_ind = {} + self._class_to_ind[self._classes[0]] = 0 + with open(os.path.join(self._data_path, self._version, 'objects_vocab.txt')) as f: + count = 1 + for object in f.readlines(): + names = [n.lower().strip() for n in object.split(',')] + self._classes.append(names[0]) + for n in names: + self._class_to_ind[n] = count + count += 1 + + # Load attributes + self._attributes = ['__no_attribute__'] + self._attribute_to_ind = {} + self._attribute_to_ind[self._attributes[0]] = 0 + with open(os.path.join(self._data_path, self._version, 'attributes_vocab.txt')) as f: + count = 1 + for att in f.readlines(): + names = [n.lower().strip() for n in att.split(',')] + self._attributes.append(names[0]) + for n in names: + self._attribute_to_ind[n] = count + count += 1 + + # Load relations + self._relations = ['__no_relation__'] + self._relation_to_ind = {} + self._relation_to_ind[self._relations[0]] = 0 + with open(os.path.join(self._data_path, self._version, 'relations_vocab.txt')) as f: + count = 1 + for rel in f.readlines(): + names = [n.lower().strip() for n in rel.split(',')] + self._relations.append(names[0]) + for n in names: + self._relation_to_ind[n] = count + count += 1 + + + self._image_ext = '.jpg' + load_index_from_file = False + if os.path.exists(os.path.join(self._data_path, "vg_image_index_{}.p".format(self._image_set))): + with open(os.path.join(self._data_path, "vg_image_index_{}.p".format(self._image_set)), 'rb') as fp: + self._image_index = pickle.load(fp) + load_index_from_file = True + + load_id_from_file = False + if os.path.exists(os.path.join(self._data_path, "vg_id_to_dir_{}.p".format(self._image_set))): + with open(os.path.join(self._data_path, "vg_id_to_dir_{}.p".format(self._image_set)), 'rb') as fp: + self._id_to_dir = pickle.load(fp) + load_id_from_file = True + + if not load_index_from_file or not load_id_from_file: + self._image_index, self._id_to_dir = self._load_image_set_index() + with open(os.path.join(self._data_path, "vg_image_index_{}.p".format(self._image_set)), 'wb') as fp: + pickle.dump(self._image_index, fp) + with open(os.path.join(self._data_path, "vg_id_to_dir_{}.p".format(self._image_set)), 'wb') as fp: + pickle.dump(self._id_to_dir, fp) + + self._roidb_handler = self.gt_roidb + + + def image_path_at(self, i): + """ + Return the absolute path to image i in the image sequence. + """ + return self.image_path_from_index(self._image_index[i]) + + def image_id_at(self, i): + """ + Return the absolute path to image i in the image sequence. + """ + return i + # return self._image_index[i] + + def image_path_from_index(self, index): + """ + Construct an image path from the image's "index" identifier. + """ + folder = self._id_to_dir[index] + image_path = os.path.join(self._img_path, folder, + str(index) + self._image_ext) + assert os.path.exists(image_path), \ + 'Path does not exist: {}'.format(image_path) + return image_path + + def _image_split_path(self): + if self._image_set == "minitrain": + return os.path.join(self._data_path, 'train.txt') + if self._image_set == "smalltrain": + return os.path.join(self._data_path, 'train.txt') + if self._image_set == "minival": + return os.path.join(self._data_path, 'val.txt') + if self._image_set == "smallval": + return os.path.join(self._data_path, 'val.txt') + else: + return os.path.join(self._data_path, self._image_set+'.txt') + + def _load_image_set_index(self): + """ + Load the indexes listed in this dataset's image set file. + """ + training_split_file = self._image_split_path() + assert os.path.exists(training_split_file), \ + 'Path does not exist: {}'.format(training_split_file) + with open(training_split_file) as f: + metadata = f.readlines() + if self._image_set == "minitrain": + metadata = metadata[:1000] + elif self._image_set == "smalltrain": + metadata = metadata[:20000] + elif self._image_set == "minival": + metadata = metadata[:100] + elif self._image_set == "smallval": + metadata = metadata[:2000] + + image_index = [] + id_to_dir = {} + for line in metadata: + im_file,ann_file = line.split() + image_id = int(ann_file.split('/')[-1].split('.')[0]) + filename = self._annotation_path(image_id) + if os.path.exists(filename): + # Some images have no bboxes after object filtering, so there + # is no xml annotation for these. + tree = ET.parse(filename) + for obj in tree.findall('object'): + obj_name = obj.find('name').text.lower().strip() + if obj_name in self._class_to_ind: + # We have to actually load and check these to make sure they have + # at least one object actually in vocab + image_index.append(image_id) + id_to_dir[image_id] = im_file.split('/')[0] + break + return image_index, id_to_dir + + def gt_roidb(self): + """ + Return the database of ground-truth regions of interest. + + This function loads/saves from/to a cache file to speed up future calls. + """ + cache_file = os.path.join(self.cache_path, self.name + '_gt_roidb.pkl') + if os.path.exists(cache_file): + fid = gzip.open(cache_file,'rb') + roidb = pickle.load(fid) + fid.close() + print('{} gt roidb loaded from {}'.format(self.name, cache_file)) + return roidb + + gt_roidb = [self._load_vg_annotation(index) + for index in self.image_index] + fid = gzip.open(cache_file,'wb') + pickle.dump(gt_roidb, fid, pickle.HIGHEST_PROTOCOL) + fid.close() + print('wrote gt roidb to {}'.format(cache_file)) + return gt_roidb + + def _get_size(self, index): + return PIL.Image.open(self.image_path_from_index(index)).size + + def _annotation_path(self, index): + return os.path.join(self._data_path, 'xml', str(index) + '.xml') + + def _load_vg_annotation(self, index): + """ + Load image and bounding boxes info from XML file in the PASCAL VOC + format. + """ + width, height = self._get_size(index) + filename = self._annotation_path(index) + tree = ET.parse(filename) + objs = tree.findall('object') + num_objs = len(objs) + + boxes = np.zeros((num_objs, 4), dtype=np.uint16) + gt_classes = np.zeros((num_objs), dtype=np.int32) + # Max of 16 attributes are observed in the data + gt_attributes = np.zeros((num_objs, 16), dtype=np.int32) + overlaps = np.zeros((num_objs, self.num_classes), dtype=np.float32) + # "Seg" area for pascal is just the box area + seg_areas = np.zeros((num_objs), dtype=np.float32) + + # Load object bounding boxes into a data frame. + obj_dict = {} + ix = 0 + for obj in objs: + obj_name = obj.find('name').text.lower().strip() + if obj_name in self._class_to_ind: + bbox = obj.find('bndbox') + x1 = max(0,float(bbox.find('xmin').text)) + y1 = max(0,float(bbox.find('ymin').text)) + x2 = min(width-1,float(bbox.find('xmax').text)) + y2 = min(height-1,float(bbox.find('ymax').text)) + # If bboxes are not positive, just give whole image coords (there are a few examples) + if x2 < x1 or y2 < y1: + print('Failed bbox in %s, object %s' % (filename, obj_name)) + x1 = 0 + y1 = 0 + x2 = width-1 + y2 = width-1 + cls = self._class_to_ind[obj_name] + obj_dict[obj.find('object_id').text] = ix + atts = obj.findall('attribute') + n = 0 + for att in atts: + att = att.text.lower().strip() + if att in self._attribute_to_ind: + gt_attributes[ix, n] = self._attribute_to_ind[att] + n += 1 + if n >= 16: + break + boxes[ix, :] = [x1, y1, x2, y2] + gt_classes[ix] = cls + overlaps[ix, cls] = 1.0 + seg_areas[ix] = (x2 - x1 + 1) * (y2 - y1 + 1) + ix += 1 + # clip gt_classes and gt_relations + gt_classes = gt_classes[:ix] + gt_attributes = gt_attributes[:ix, :] + + overlaps = scipy.sparse.csr_matrix(overlaps) + gt_attributes = scipy.sparse.csr_matrix(gt_attributes) + + rels = tree.findall('relation') + num_rels = len(rels) + gt_relations = set() # Avoid duplicates + for rel in rels: + pred = rel.find('predicate').text + if pred: # One is empty + pred = pred.lower().strip() + if pred in self._relation_to_ind: + try: + triple = [] + triple.append(obj_dict[rel.find('subject_id').text]) + triple.append(self._relation_to_ind[pred]) + triple.append(obj_dict[rel.find('object_id').text]) + gt_relations.add(tuple(triple)) + except: + pass # Object not in dictionary + gt_relations = np.array(list(gt_relations), dtype=np.int32) + + return {'boxes' : boxes, + 'gt_classes': gt_classes, + 'gt_attributes' : gt_attributes, + 'gt_relations' : gt_relations, + 'gt_overlaps' : overlaps, + 'width' : width, + 'height': height, + 'flipped' : False, + 'seg_areas' : seg_areas} + + def evaluate_detections(self, all_boxes, output_dir): + self._write_voc_results_file(self.classes, all_boxes, output_dir) + self._do_python_eval(output_dir) + if self.config['cleanup']: + for cls in self._classes: + if cls == '__background__': + continue + filename = self._get_vg_results_file_template(output_dir).format(cls) + os.remove(filename) + + def evaluate_attributes(self, all_boxes, output_dir): + self._write_voc_results_file(self.attributes, all_boxes, output_dir) + self._do_python_eval(output_dir, eval_attributes = True) + if self.config['cleanup']: + for cls in self._attributes: + if cls == '__no_attribute__': + continue + filename = self._get_vg_results_file_template(output_dir).format(cls) + os.remove(filename) + + def _get_vg_results_file_template(self, output_dir): + filename = 'detections_' + self._image_set + '_{:s}.txt' + path = os.path.join(output_dir, filename) + return path + + def _write_voc_results_file(self, classes, all_boxes, output_dir): + for cls_ind, cls in enumerate(classes): + if cls == '__background__': + continue + print('Writing "{}" vg results file'.format(cls)) + filename = self._get_vg_results_file_template(output_dir).format(cls) + with open(filename, 'wt') as f: + for im_ind, index in enumerate(self.image_index): + dets = all_boxes[cls_ind][im_ind] + if dets == []: + continue + # the VOCdevkit expects 1-based indices + for k in xrange(dets.shape[0]): + f.write('{:s} {:.3f} {:.1f} {:.1f} {:.1f} {:.1f}\n'. + format(str(index), dets[k, -1], + dets[k, 0] + 1, dets[k, 1] + 1, + dets[k, 2] + 1, dets[k, 3] + 1)) + + + def _do_python_eval(self, output_dir, pickle=True, eval_attributes = False): + # We re-use parts of the pascal voc python code for visual genome + aps = [] + nposs = [] + thresh = [] + # The PASCAL VOC metric changed in 2010 + use_07_metric = False + print('VOC07 metric? ' + ('Yes' if use_07_metric else 'No')) + if not os.path.isdir(output_dir): + os.mkdir(output_dir) + # Load ground truth + gt_roidb = self.gt_roidb() + if eval_attributes: + classes = self._attributes + else: + classes = self._classes + for i, cls in enumerate(classes): + if cls == '__background__' or cls == '__no_attribute__': + continue + filename = self._get_vg_results_file_template(output_dir).format(cls) + rec, prec, ap, scores, npos = vg_eval( + filename, gt_roidb, self.image_index, i, ovthresh=0.5, + use_07_metric=use_07_metric, eval_attributes=eval_attributes) + + # Determine per class detection thresholds that maximise f score + if npos > 1: + f = np.nan_to_num((prec*rec)/(prec+rec)) + thresh += [scores[np.argmax(f)]] + else: + thresh += [0] + aps += [ap] + nposs += [float(npos)] + print('AP for {} = {:.4f} (npos={:,})'.format(cls, ap, npos)) + if pickle: + with open(os.path.join(output_dir, cls + '_pr.pkl'), 'wb') as f: + pickle.dump({'rec': rec, 'prec': prec, 'ap': ap, + 'scores': scores, 'npos':npos}, f) + + # Set thresh to mean for classes with poor results + thresh = np.array(thresh) + avg_thresh = np.mean(thresh[thresh!=0]) + thresh[thresh==0] = avg_thresh + if eval_attributes: + filename = 'attribute_thresholds_' + self._image_set + '.txt' + else: + filename = 'object_thresholds_' + self._image_set + '.txt' + path = os.path.join(output_dir, filename) + with open(path, 'wt') as f: + for i, cls in enumerate(classes[1:]): + f.write('{:s} {:.3f}\n'.format(cls, thresh[i])) + + weights = np.array(nposs) + weights /= weights.sum() + print('Mean AP = {:.4f}'.format(np.mean(aps))) + print('Weighted Mean AP = {:.4f}'.format(np.average(aps, weights=weights))) + print('Mean Detection Threshold = {:.3f}'.format(avg_thresh)) + print('~~~~~~~~') + print('Results:') + for ap,npos in zip(aps,nposs): + print('{:.3f}\t{:.3f}'.format(ap,npos)) + print('{:.3f}'.format(np.mean(aps))) + print('~~~~~~~~') + print('') + print('--------------------------------------------------------------') + print('Results computed with the **unofficial** PASCAL VOC Python eval code.') + print('--------------------------------------------------------------') + + +if __name__ == '__main__': + d = vg('val') + res = d.roidb + from IPython import embed; embed() diff --git a/lib/datasets/vg_eval.py b/lib/datasets/vg_eval.py new file mode 100644 index 0000000..b4d9b4b --- /dev/null +++ b/lib/datasets/vg_eval.py @@ -0,0 +1,123 @@ +from __future__ import absolute_import +# -------------------------------------------------------- +# Fast/er R-CNN +# Licensed under The MIT License [see LICENSE for details] +# Written by Bharath Hariharan +# -------------------------------------------------------- + +import xml.etree.ElementTree as ET +import os +import numpy as np +from .voc_eval import voc_ap + +def vg_eval( detpath, + gt_roidb, + image_index, + classindex, + ovthresh=0.5, + use_07_metric=False, + eval_attributes=False): + """rec, prec, ap, sorted_scores, npos = voc_eval( + detpath, + gt_roidb, + image_index, + classindex, + [ovthresh], + [use_07_metric]) + + Top level function that does the Visual Genome evaluation. + + detpath: Path to detections + gt_roidb: List of ground truth structs. + image_index: List of image ids. + classindex: Category index + [ovthresh]: Overlap threshold (default = 0.5) + [use_07_metric]: Whether to use VOC07's 11 point AP computation + (default False) + """ + # extract gt objects for this class + class_recs = {} + npos = 0 + for item,imagename in zip(gt_roidb,image_index): + if eval_attributes: + bbox = item['boxes'][np.where(np.any(item['gt_attributes'].toarray() == classindex, axis=1))[0], :] + else: + bbox = item['boxes'][np.where(item['gt_classes'] == classindex)[0], :] + difficult = np.zeros((bbox.shape[0],)).astype(np.bool) + det = [False] * bbox.shape[0] + npos = npos + sum(~difficult) + class_recs[str(imagename)] = {'bbox': bbox, + 'difficult': difficult, + 'det': det} + if npos == 0: + # No ground truth examples + return 0,0,0,0,npos + + # read dets + with open(detpath, 'r') as f: + lines = f.readlines() + if len(lines) == 0: + # No detection examples + return 0,0,0,0,npos + + splitlines = [x.strip().split(' ') for x in lines] + image_ids = [x[0] for x in splitlines] + confidence = np.array([float(x[1]) for x in splitlines]) + BB = np.array([[float(z) for z in x[2:]] for x in splitlines]) + + # sort by confidence + sorted_ind = np.argsort(-confidence) + sorted_scores = -np.sort(-confidence) + BB = BB[sorted_ind, :] + image_ids = [image_ids[x] for x in sorted_ind] + + # go down dets and mark TPs and FPs + nd = len(image_ids) + tp = np.zeros(nd) + fp = np.zeros(nd) + for d in range(nd): + R = class_recs[image_ids[d]] + bb = BB[d, :].astype(float) + ovmax = -np.inf + BBGT = R['bbox'].astype(float) + + if BBGT.size > 0: + # compute overlaps + # intersection + ixmin = np.maximum(BBGT[:, 0], bb[0]) + iymin = np.maximum(BBGT[:, 1], bb[1]) + ixmax = np.minimum(BBGT[:, 2], bb[2]) + iymax = np.minimum(BBGT[:, 3], bb[3]) + iw = np.maximum(ixmax - ixmin + 1., 0.) + ih = np.maximum(iymax - iymin + 1., 0.) + inters = iw * ih + + # union + uni = ((bb[2] - bb[0] + 1.) * (bb[3] - bb[1] + 1.) + + (BBGT[:, 2] - BBGT[:, 0] + 1.) * + (BBGT[:, 3] - BBGT[:, 1] + 1.) - inters) + + overlaps = inters / uni + ovmax = np.max(overlaps) + jmax = np.argmax(overlaps) + + if ovmax > ovthresh: + if not R['difficult'][jmax]: + if not R['det'][jmax]: + tp[d] = 1. + R['det'][jmax] = 1 + else: + fp[d] = 1. + else: + fp[d] = 1. + + # compute precision recall + fp = np.cumsum(fp) + tp = np.cumsum(tp) + rec = tp / float(npos) + # avoid divide by zero in case the first detection matches a difficult + # ground truth + prec = tp / np.maximum(tp + fp, np.finfo(np.float64).eps) + ap = voc_ap(rec, prec, use_07_metric) + + return rec, prec, ap, sorted_scores, npos diff --git a/lib/datasets/voc_eval.py b/lib/datasets/voc_eval.py new file mode 100644 index 0000000..36a0fb6 --- /dev/null +++ b/lib/datasets/voc_eval.py @@ -0,0 +1,211 @@ +# -------------------------------------------------------- +# Fast/er R-CNN +# Licensed under The MIT License [see LICENSE for details] +# Written by Bharath Hariharan +# -------------------------------------------------------- +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +import xml.etree.ElementTree as ET +import os +import pickle +import numpy as np + +def parse_rec(filename): + """ Parse a PASCAL VOC xml file """ + tree = ET.parse(filename) + objects = [] + for obj in tree.findall('object'): + obj_struct = {} + obj_struct['name'] = obj.find('name').text + obj_struct['pose'] = obj.find('pose').text + obj_struct['truncated'] = int(obj.find('truncated').text) + obj_struct['difficult'] = int(obj.find('difficult').text) + bbox = obj.find('bndbox') + obj_struct['bbox'] = [int(bbox.find('xmin').text), + int(bbox.find('ymin').text), + int(bbox.find('xmax').text), + int(bbox.find('ymax').text)] + objects.append(obj_struct) + + return objects + + +def voc_ap(rec, prec, use_07_metric=False): + """ ap = voc_ap(rec, prec, [use_07_metric]) + Compute VOC AP given precision and recall. + If use_07_metric is true, uses the + VOC 07 11 point method (default:False). + """ + if use_07_metric: + # 11 point metric + ap = 0. + for t in np.arange(0., 1.1, 0.1): + if np.sum(rec >= t) == 0: + p = 0 + else: + p = np.max(prec[rec >= t]) + ap = ap + p / 11. + else: + # correct AP calculation + # first append sentinel values at the end + mrec = np.concatenate(([0.], rec, [1.])) + mpre = np.concatenate(([0.], prec, [0.])) + + # compute the precision envelope + for i in range(mpre.size - 1, 0, -1): + mpre[i - 1] = np.maximum(mpre[i - 1], mpre[i]) + + # to calculate area under PR curve, look for points + # where X axis (recall) changes value + i = np.where(mrec[1:] != mrec[:-1])[0] + + # and sum (\Delta recall) * prec + ap = np.sum((mrec[i + 1] - mrec[i]) * mpre[i + 1]) + return ap + + +def voc_eval(detpath, + annopath, + imagesetfile, + classname, + cachedir, + ovthresh=0.5, + use_07_metric=False): + """rec, prec, ap = voc_eval(detpath, + annopath, + imagesetfile, + classname, + [ovthresh], + [use_07_metric]) + + Top level function that does the PASCAL VOC evaluation. + + detpath: Path to detections + detpath.format(classname) should produce the detection results file. + annopath: Path to annotations + annopath.format(imagename) should be the xml annotations file. + imagesetfile: Text file containing the list of images, one image per line. + classname: Category name (duh) + cachedir: Directory for caching the annotations + [ovthresh]: Overlap threshold (default = 0.5) + [use_07_metric]: Whether to use VOC07's 11 point AP computation + (default False) + """ + # assumes detections are in detpath.format(classname) + # assumes annotations are in annopath.format(imagename) + # assumes imagesetfile is a text file with each line an image name + # cachedir caches the annotations in a pickle file + + # first load gt + if not os.path.isdir(cachedir): + os.mkdir(cachedir) + # cachefile = os.path.join(cachedir, '%s_annots.pkl' % imagesetfile) + cachefile = '%s_annots.pkl' % imagesetfile + # read list of images + with open(imagesetfile, 'r') as f: + lines = f.readlines() + imagenames = [x.strip() for x in lines] + + if not os.path.isfile(cachefile): + # load annotations + recs = {} + for i, imagename in enumerate(imagenames): + recs[imagename] = parse_rec(annopath.format(imagename)) + if i % 100 == 0: + print('Reading annotation for {:d}/{:d}'.format( + i + 1, len(imagenames))) + # save + print('Saving cached annotations to {:s}'.format(cachefile)) + with open(cachefile, 'wb') as f: + pickle.dump(recs, f) + else: + # load + with open(cachefile, 'rb') as f: + try: + recs = pickle.load(f) + except: + recs = pickle.load(f, encoding='bytes') + + # extract gt objects for this class + class_recs = {} + npos = 0 + for imagename in imagenames: + R = [obj for obj in recs[imagename] if obj['name'] == classname] + bbox = np.array([x['bbox'] for x in R]) + difficult = np.array([x['difficult'] for x in R]).astype(np.bool) + det = [False] * len(R) + npos = npos + sum(~difficult) + class_recs[imagename] = {'bbox': bbox, + 'difficult': difficult, + 'det': det} + + # read dets + detfile = detpath.format(classname) + with open(detfile, 'r') as f: + lines = f.readlines() + + splitlines = [x.strip().split(' ') for x in lines] + image_ids = [x[0] for x in splitlines] + confidence = np.array([float(x[1]) for x in splitlines]) + BB = np.array([[float(z) for z in x[2:]] for x in splitlines]) + + nd = len(image_ids) + tp = np.zeros(nd) + fp = np.zeros(nd) + + if BB.shape[0] > 0: + # sort by confidence + sorted_ind = np.argsort(-confidence) + sorted_scores = np.sort(-confidence) + BB = BB[sorted_ind, :] + image_ids = [image_ids[x] for x in sorted_ind] + + # go down dets and mark TPs and FPs + for d in range(nd): + R = class_recs[image_ids[d]] + bb = BB[d, :].astype(float) + ovmax = -np.inf + BBGT = R['bbox'].astype(float) + + if BBGT.size > 0: + # compute overlaps + # intersection + ixmin = np.maximum(BBGT[:, 0], bb[0]) + iymin = np.maximum(BBGT[:, 1], bb[1]) + ixmax = np.minimum(BBGT[:, 2], bb[2]) + iymax = np.minimum(BBGT[:, 3], bb[3]) + iw = np.maximum(ixmax - ixmin + 1., 0.) + ih = np.maximum(iymax - iymin + 1., 0.) + inters = iw * ih + + # union + uni = ((bb[2] - bb[0] + 1.) * (bb[3] - bb[1] + 1.) + + (BBGT[:, 2] - BBGT[:, 0] + 1.) * + (BBGT[:, 3] - BBGT[:, 1] + 1.) - inters) + + overlaps = inters / uni + ovmax = np.max(overlaps) + jmax = np.argmax(overlaps) + + if ovmax > ovthresh: + if not R['difficult'][jmax]: + if not R['det'][jmax]: + tp[d] = 1. + R['det'][jmax] = 1 + else: + fp[d] = 1. + else: + fp[d] = 1. + + # compute precision recall + fp = np.cumsum(fp) + tp = np.cumsum(tp) + rec = tp / float(npos) + # avoid divide by zero in case the first detection matches a difficult + # ground truth + prec = tp / np.maximum(tp + fp, np.finfo(np.float64).eps) + ap = voc_ap(rec, prec, use_07_metric) + + return rec, prec, ap diff --git a/lib/model/__init__.py b/lib/model/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/lib/model/csrc/ROIAlign.h b/lib/model/csrc/ROIAlign.h new file mode 100644 index 0000000..3907dea --- /dev/null +++ b/lib/model/csrc/ROIAlign.h @@ -0,0 +1,46 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. +#pragma once + +#include "cpu/vision.h" + +#ifdef WITH_CUDA +#include "cuda/vision.h" +#endif + +// Interface for Python +at::Tensor ROIAlign_forward(const at::Tensor& input, + const at::Tensor& rois, + const float spatial_scale, + const int pooled_height, + const int pooled_width, + const int sampling_ratio) { + if (input.type().is_cuda()) { +#ifdef WITH_CUDA + return ROIAlign_forward_cuda(input, rois, spatial_scale, pooled_height, pooled_width, sampling_ratio); +#else + AT_ERROR("Not compiled with GPU support"); +#endif + } + return ROIAlign_forward_cpu(input, rois, spatial_scale, pooled_height, pooled_width, sampling_ratio); +} + +at::Tensor ROIAlign_backward(const at::Tensor& grad, + const at::Tensor& rois, + const float spatial_scale, + const int pooled_height, + const int pooled_width, + const int batch_size, + const int channels, + const int height, + const int width, + const int sampling_ratio) { + if (grad.type().is_cuda()) { +#ifdef WITH_CUDA + return ROIAlign_backward_cuda(grad, rois, spatial_scale, pooled_height, pooled_width, batch_size, channels, height, width, sampling_ratio); +#else + AT_ERROR("Not compiled with GPU support"); +#endif + } + AT_ERROR("Not implemented on the CPU"); +} + diff --git a/lib/model/csrc/ROIPool.h b/lib/model/csrc/ROIPool.h new file mode 100644 index 0000000..200fd73 --- /dev/null +++ b/lib/model/csrc/ROIPool.h @@ -0,0 +1,48 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. +#pragma once + +#include "cpu/vision.h" + +#ifdef WITH_CUDA +#include "cuda/vision.h" +#endif + + +std::tuple ROIPool_forward(const at::Tensor& input, + const at::Tensor& rois, + const float spatial_scale, + const int pooled_height, + const int pooled_width) { + if (input.type().is_cuda()) { +#ifdef WITH_CUDA + return ROIPool_forward_cuda(input, rois, spatial_scale, pooled_height, pooled_width); +#else + AT_ERROR("Not compiled with GPU support"); +#endif + } + AT_ERROR("Not implemented on the CPU"); +} + +at::Tensor ROIPool_backward(const at::Tensor& grad, + const at::Tensor& input, + const at::Tensor& rois, + const at::Tensor& argmax, + const float spatial_scale, + const int pooled_height, + const int pooled_width, + const int batch_size, + const int channels, + const int height, + const int width) { + if (grad.type().is_cuda()) { +#ifdef WITH_CUDA + return ROIPool_backward_cuda(grad, input, rois, argmax, spatial_scale, pooled_height, pooled_width, batch_size, channels, height, width); +#else + AT_ERROR("Not compiled with GPU support"); +#endif + } + AT_ERROR("Not implemented on the CPU"); +} + + + diff --git a/lib/model/csrc/cpu/ROIAlign_cpu.cpp b/lib/model/csrc/cpu/ROIAlign_cpu.cpp new file mode 100644 index 0000000..d35aedf --- /dev/null +++ b/lib/model/csrc/cpu/ROIAlign_cpu.cpp @@ -0,0 +1,257 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. +#include "cpu/vision.h" + +// implementation taken from Caffe2 +template +struct PreCalc { + int pos1; + int pos2; + int pos3; + int pos4; + T w1; + T w2; + T w3; + T w4; +}; + +template +void pre_calc_for_bilinear_interpolate( + const int height, + const int width, + const int pooled_height, + const int pooled_width, + const int iy_upper, + const int ix_upper, + T roi_start_h, + T roi_start_w, + T bin_size_h, + T bin_size_w, + int roi_bin_grid_h, + int roi_bin_grid_w, + std::vector>& pre_calc) { + int pre_calc_index = 0; + for (int ph = 0; ph < pooled_height; ph++) { + for (int pw = 0; pw < pooled_width; pw++) { + for (int iy = 0; iy < iy_upper; iy++) { + const T yy = roi_start_h + ph * bin_size_h + + static_cast(iy + .5f) * bin_size_h / + static_cast(roi_bin_grid_h); // e.g., 0.5, 1.5 + for (int ix = 0; ix < ix_upper; ix++) { + const T xx = roi_start_w + pw * bin_size_w + + static_cast(ix + .5f) * bin_size_w / + static_cast(roi_bin_grid_w); + + T x = xx; + T y = yy; + // deal with: inverse elements are out of feature map boundary + if (y < -1.0 || y > height || x < -1.0 || x > width) { + // empty + PreCalc pc; + pc.pos1 = 0; + pc.pos2 = 0; + pc.pos3 = 0; + pc.pos4 = 0; + pc.w1 = 0; + pc.w2 = 0; + pc.w3 = 0; + pc.w4 = 0; + pre_calc[pre_calc_index] = pc; + pre_calc_index += 1; + continue; + } + + if (y <= 0) { + y = 0; + } + if (x <= 0) { + x = 0; + } + + int y_low = (int)y; + int x_low = (int)x; + int y_high; + int x_high; + + if (y_low >= height - 1) { + y_high = y_low = height - 1; + y = (T)y_low; + } else { + y_high = y_low + 1; + } + + if (x_low >= width - 1) { + x_high = x_low = width - 1; + x = (T)x_low; + } else { + x_high = x_low + 1; + } + + T ly = y - y_low; + T lx = x - x_low; + T hy = 1. - ly, hx = 1. - lx; + T w1 = hy * hx, w2 = hy * lx, w3 = ly * hx, w4 = ly * lx; + + // save weights and indeces + PreCalc pc; + pc.pos1 = y_low * width + x_low; + pc.pos2 = y_low * width + x_high; + pc.pos3 = y_high * width + x_low; + pc.pos4 = y_high * width + x_high; + pc.w1 = w1; + pc.w2 = w2; + pc.w3 = w3; + pc.w4 = w4; + pre_calc[pre_calc_index] = pc; + + pre_calc_index += 1; + } + } + } + } +} + +template +void ROIAlignForward_cpu_kernel( + const int nthreads, + const T* bottom_data, + const T& spatial_scale, + const int channels, + const int height, + const int width, + const int pooled_height, + const int pooled_width, + const int sampling_ratio, + const T* bottom_rois, + //int roi_cols, + T* top_data) { + //AT_ASSERT(roi_cols == 4 || roi_cols == 5); + int roi_cols = 5; + + int n_rois = nthreads / channels / pooled_width / pooled_height; + // (n, c, ph, pw) is an element in the pooled output + // can be parallelized using omp + // #pragma omp parallel for num_threads(32) + for (int n = 0; n < n_rois; n++) { + int index_n = n * channels * pooled_width * pooled_height; + + // roi could have 4 or 5 columns + const T* offset_bottom_rois = bottom_rois + n * roi_cols; + int roi_batch_ind = 0; + if (roi_cols == 5) { + roi_batch_ind = offset_bottom_rois[0]; + offset_bottom_rois++; + } + + // Do not using rounding; this implementation detail is critical + T roi_start_w = offset_bottom_rois[0] * spatial_scale; + T roi_start_h = offset_bottom_rois[1] * spatial_scale; + T roi_end_w = offset_bottom_rois[2] * spatial_scale; + T roi_end_h = offset_bottom_rois[3] * spatial_scale; + // T roi_start_w = round(offset_bottom_rois[0] * spatial_scale); + // T roi_start_h = round(offset_bottom_rois[1] * spatial_scale); + // T roi_end_w = round(offset_bottom_rois[2] * spatial_scale); + // T roi_end_h = round(offset_bottom_rois[3] * spatial_scale); + + // Force malformed ROIs to be 1x1 + T roi_width = std::max(roi_end_w - roi_start_w, (T)1.); + T roi_height = std::max(roi_end_h - roi_start_h, (T)1.); + T bin_size_h = static_cast(roi_height) / static_cast(pooled_height); + T bin_size_w = static_cast(roi_width) / static_cast(pooled_width); + + // We use roi_bin_grid to sample the grid and mimic integral + int roi_bin_grid_h = (sampling_ratio > 0) + ? sampling_ratio + : ceil(roi_height / pooled_height); // e.g., = 2 + int roi_bin_grid_w = + (sampling_ratio > 0) ? sampling_ratio : ceil(roi_width / pooled_width); + + // We do average (integral) pooling inside a bin + const T count = roi_bin_grid_h * roi_bin_grid_w; // e.g. = 4 + + // we want to precalculate indeces and weights shared by all chanels, + // this is the key point of optimiation + std::vector> pre_calc( + roi_bin_grid_h * roi_bin_grid_w * pooled_width * pooled_height); + pre_calc_for_bilinear_interpolate( + height, + width, + pooled_height, + pooled_width, + roi_bin_grid_h, + roi_bin_grid_w, + roi_start_h, + roi_start_w, + bin_size_h, + bin_size_w, + roi_bin_grid_h, + roi_bin_grid_w, + pre_calc); + + for (int c = 0; c < channels; c++) { + int index_n_c = index_n + c * pooled_width * pooled_height; + const T* offset_bottom_data = + bottom_data + (roi_batch_ind * channels + c) * height * width; + int pre_calc_index = 0; + + for (int ph = 0; ph < pooled_height; ph++) { + for (int pw = 0; pw < pooled_width; pw++) { + int index = index_n_c + ph * pooled_width + pw; + + T output_val = 0.; + for (int iy = 0; iy < roi_bin_grid_h; iy++) { + for (int ix = 0; ix < roi_bin_grid_w; ix++) { + PreCalc pc = pre_calc[pre_calc_index]; + output_val += pc.w1 * offset_bottom_data[pc.pos1] + + pc.w2 * offset_bottom_data[pc.pos2] + + pc.w3 * offset_bottom_data[pc.pos3] + + pc.w4 * offset_bottom_data[pc.pos4]; + + pre_calc_index += 1; + } + } + output_val /= count; + + top_data[index] = output_val; + } // for pw + } // for ph + } // for c + } // for n +} + +at::Tensor ROIAlign_forward_cpu(const at::Tensor& input, + const at::Tensor& rois, + const float spatial_scale, + const int pooled_height, + const int pooled_width, + const int sampling_ratio) { + AT_ASSERTM(!input.type().is_cuda(), "input must be a CPU tensor"); + AT_ASSERTM(!rois.type().is_cuda(), "rois must be a CPU tensor"); + + auto num_rois = rois.size(0); + auto channels = input.size(1); + auto height = input.size(2); + auto width = input.size(3); + + auto output = at::empty({num_rois, channels, pooled_height, pooled_width}, input.options()); + auto output_size = num_rois * pooled_height * pooled_width * channels; + + if (output.numel() == 0) { + return output; + } + + AT_DISPATCH_FLOATING_TYPES(input.type(), "ROIAlign_forward", [&] { + ROIAlignForward_cpu_kernel( + output_size, + input.data(), + spatial_scale, + channels, + height, + width, + pooled_height, + pooled_width, + sampling_ratio, + rois.data(), + output.data()); + }); + return output; +} diff --git a/lib/model/csrc/cpu/nms_cpu.cpp b/lib/model/csrc/cpu/nms_cpu.cpp new file mode 100644 index 0000000..1153dea --- /dev/null +++ b/lib/model/csrc/cpu/nms_cpu.cpp @@ -0,0 +1,75 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. +#include "cpu/vision.h" + + +template +at::Tensor nms_cpu_kernel(const at::Tensor& dets, + const at::Tensor& scores, + const float threshold) { + AT_ASSERTM(!dets.type().is_cuda(), "dets must be a CPU tensor"); + AT_ASSERTM(!scores.type().is_cuda(), "scores must be a CPU tensor"); + AT_ASSERTM(dets.type() == scores.type(), "dets should have the same type as scores"); + + if (dets.numel() == 0) { + return at::empty({0}, dets.options().dtype(at::kLong).device(at::kCPU)); + } + + auto x1_t = dets.select(1, 0).contiguous(); + auto y1_t = dets.select(1, 1).contiguous(); + auto x2_t = dets.select(1, 2).contiguous(); + auto y2_t = dets.select(1, 3).contiguous(); + + at::Tensor areas_t = (x2_t - x1_t + 1) * (y2_t - y1_t + 1); + + auto order_t = std::get<1>(scores.sort(0, /* descending=*/true)); + + auto ndets = dets.size(0); + at::Tensor suppressed_t = at::zeros({ndets}, dets.options().dtype(at::kByte).device(at::kCPU)); + + auto suppressed = suppressed_t.data(); + auto order = order_t.data(); + auto x1 = x1_t.data(); + auto y1 = y1_t.data(); + auto x2 = x2_t.data(); + auto y2 = y2_t.data(); + auto areas = areas_t.data(); + + for (int64_t _i = 0; _i < ndets; _i++) { + auto i = order[_i]; + if (suppressed[i] == 1) + continue; + auto ix1 = x1[i]; + auto iy1 = y1[i]; + auto ix2 = x2[i]; + auto iy2 = y2[i]; + auto iarea = areas[i]; + + for (int64_t _j = _i + 1; _j < ndets; _j++) { + auto j = order[_j]; + if (suppressed[j] == 1) + continue; + auto xx1 = std::max(ix1, x1[j]); + auto yy1 = std::max(iy1, y1[j]); + auto xx2 = std::min(ix2, x2[j]); + auto yy2 = std::min(iy2, y2[j]); + + auto w = std::max(static_cast(0), xx2 - xx1 + 1); + auto h = std::max(static_cast(0), yy2 - yy1 + 1); + auto inter = w * h; + auto ovr = inter / (iarea + areas[j] - inter); + if (ovr >= threshold) + suppressed[j] = 1; + } + } + return at::nonzero(suppressed_t == 0).squeeze(1); +} + +at::Tensor nms_cpu(const at::Tensor& dets, + const at::Tensor& scores, + const float threshold) { + at::Tensor result; + AT_DISPATCH_FLOATING_TYPES(dets.type(), "nms", [&] { + result = nms_cpu_kernel(dets, scores, threshold); + }); + return result; +} diff --git a/lib/model/csrc/cpu/vision.h b/lib/model/csrc/cpu/vision.h new file mode 100644 index 0000000..9261125 --- /dev/null +++ b/lib/model/csrc/cpu/vision.h @@ -0,0 +1,16 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. +#pragma once +#include + + +at::Tensor ROIAlign_forward_cpu(const at::Tensor& input, + const at::Tensor& rois, + const float spatial_scale, + const int pooled_height, + const int pooled_width, + const int sampling_ratio); + + +at::Tensor nms_cpu(const at::Tensor& dets, + const at::Tensor& scores, + const float threshold); diff --git a/lib/model/csrc/cuda/ROIAlign_cuda.cu b/lib/model/csrc/cuda/ROIAlign_cuda.cu new file mode 100644 index 0000000..5fe97ca --- /dev/null +++ b/lib/model/csrc/cuda/ROIAlign_cuda.cu @@ -0,0 +1,346 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. +#include +#include + +#include +#include +#include + +// TODO make it in a common file +#define CUDA_1D_KERNEL_LOOP(i, n) \ + for (int i = blockIdx.x * blockDim.x + threadIdx.x; i < n; \ + i += blockDim.x * gridDim.x) + + +template +__device__ T bilinear_interpolate(const T* bottom_data, + const int height, const int width, + T y, T x, + const int index /* index for debug only*/) { + + // deal with cases that inverse elements are out of feature map boundary + if (y < -1.0 || y > height || x < -1.0 || x > width) { + //empty + return 0; + } + + if (y <= 0) y = 0; + if (x <= 0) x = 0; + + int y_low = (int) y; + int x_low = (int) x; + int y_high; + int x_high; + + if (y_low >= height - 1) { + y_high = y_low = height - 1; + y = (T) y_low; + } else { + y_high = y_low + 1; + } + + if (x_low >= width - 1) { + x_high = x_low = width - 1; + x = (T) x_low; + } else { + x_high = x_low + 1; + } + + T ly = y - y_low; + T lx = x - x_low; + T hy = 1. - ly, hx = 1. - lx; + // do bilinear interpolation + T v1 = bottom_data[y_low * width + x_low]; + T v2 = bottom_data[y_low * width + x_high]; + T v3 = bottom_data[y_high * width + x_low]; + T v4 = bottom_data[y_high * width + x_high]; + T w1 = hy * hx, w2 = hy * lx, w3 = ly * hx, w4 = ly * lx; + + T val = (w1 * v1 + w2 * v2 + w3 * v3 + w4 * v4); + + return val; +} + +template +__global__ void RoIAlignForward(const int nthreads, const T* bottom_data, + const T spatial_scale, const int channels, + const int height, const int width, + const int pooled_height, const int pooled_width, + const int sampling_ratio, + const T* bottom_rois, T* top_data) { + CUDA_1D_KERNEL_LOOP(index, nthreads) { + // (n, c, ph, pw) is an element in the pooled output + int pw = index % pooled_width; + int ph = (index / pooled_width) % pooled_height; + int c = (index / pooled_width / pooled_height) % channels; + int n = index / pooled_width / pooled_height / channels; + + const T* offset_bottom_rois = bottom_rois + n * 5; + int roi_batch_ind = offset_bottom_rois[0]; + + // Do not using rounding; this implementation detail is critical + T roi_start_w = offset_bottom_rois[1] * spatial_scale; + T roi_start_h = offset_bottom_rois[2] * spatial_scale; + T roi_end_w = offset_bottom_rois[3] * spatial_scale; + T roi_end_h = offset_bottom_rois[4] * spatial_scale; + // T roi_start_w = round(offset_bottom_rois[1] * spatial_scale); + // T roi_start_h = round(offset_bottom_rois[2] * spatial_scale); + // T roi_end_w = round(offset_bottom_rois[3] * spatial_scale); + // T roi_end_h = round(offset_bottom_rois[4] * spatial_scale); + + // Force malformed ROIs to be 1x1 + T roi_width = max(roi_end_w - roi_start_w, (T)1.); + T roi_height = max(roi_end_h - roi_start_h, (T)1.); + T bin_size_h = static_cast(roi_height) / static_cast(pooled_height); + T bin_size_w = static_cast(roi_width) / static_cast(pooled_width); + + const T* offset_bottom_data = bottom_data + (roi_batch_ind * channels + c) * height * width; + + // We use roi_bin_grid to sample the grid and mimic integral + int roi_bin_grid_h = (sampling_ratio > 0) ? sampling_ratio : ceil(roi_height / pooled_height); // e.g., = 2 + int roi_bin_grid_w = (sampling_ratio > 0) ? sampling_ratio : ceil(roi_width / pooled_width); + + // We do average (integral) pooling inside a bin + const T count = roi_bin_grid_h * roi_bin_grid_w; // e.g. = 4 + + T output_val = 0.; + for (int iy = 0; iy < roi_bin_grid_h; iy ++) // e.g., iy = 0, 1 + { + const T y = roi_start_h + ph * bin_size_h + static_cast(iy + .5f) * bin_size_h / static_cast(roi_bin_grid_h); // e.g., 0.5, 1.5 + for (int ix = 0; ix < roi_bin_grid_w; ix ++) + { + const T x = roi_start_w + pw * bin_size_w + static_cast(ix + .5f) * bin_size_w / static_cast(roi_bin_grid_w); + + T val = bilinear_interpolate(offset_bottom_data, height, width, y, x, index); + output_val += val; + } + } + output_val /= count; + + top_data[index] = output_val; + } +} + + +template +__device__ void bilinear_interpolate_gradient( + const int height, const int width, + T y, T x, + T & w1, T & w2, T & w3, T & w4, + int & x_low, int & x_high, int & y_low, int & y_high, + const int index /* index for debug only*/) { + + // deal with cases that inverse elements are out of feature map boundary + if (y < -1.0 || y > height || x < -1.0 || x > width) { + //empty + w1 = w2 = w3 = w4 = 0.; + x_low = x_high = y_low = y_high = -1; + return; + } + + if (y <= 0) y = 0; + if (x <= 0) x = 0; + + y_low = (int) y; + x_low = (int) x; + + if (y_low >= height - 1) { + y_high = y_low = height - 1; + y = (T) y_low; + } else { + y_high = y_low + 1; + } + + if (x_low >= width - 1) { + x_high = x_low = width - 1; + x = (T) x_low; + } else { + x_high = x_low + 1; + } + + T ly = y - y_low; + T lx = x - x_low; + T hy = 1. - ly, hx = 1. - lx; + + // reference in forward + // T v1 = bottom_data[y_low * width + x_low]; + // T v2 = bottom_data[y_low * width + x_high]; + // T v3 = bottom_data[y_high * width + x_low]; + // T v4 = bottom_data[y_high * width + x_high]; + // T val = (w1 * v1 + w2 * v2 + w3 * v3 + w4 * v4); + + w1 = hy * hx, w2 = hy * lx, w3 = ly * hx, w4 = ly * lx; + + return; +} + +template +__global__ void RoIAlignBackwardFeature(const int nthreads, const T* top_diff, + const int num_rois, const T spatial_scale, + const int channels, const int height, const int width, + const int pooled_height, const int pooled_width, + const int sampling_ratio, + T* bottom_diff, + const T* bottom_rois) { + CUDA_1D_KERNEL_LOOP(index, nthreads) { + // (n, c, ph, pw) is an element in the pooled output + int pw = index % pooled_width; + int ph = (index / pooled_width) % pooled_height; + int c = (index / pooled_width / pooled_height) % channels; + int n = index / pooled_width / pooled_height / channels; + + const T* offset_bottom_rois = bottom_rois + n * 5; + int roi_batch_ind = offset_bottom_rois[0]; + + // Do not using rounding; this implementation detail is critical + T roi_start_w = offset_bottom_rois[1] * spatial_scale; + T roi_start_h = offset_bottom_rois[2] * spatial_scale; + T roi_end_w = offset_bottom_rois[3] * spatial_scale; + T roi_end_h = offset_bottom_rois[4] * spatial_scale; + // T roi_start_w = round(offset_bottom_rois[1] * spatial_scale); + // T roi_start_h = round(offset_bottom_rois[2] * spatial_scale); + // T roi_end_w = round(offset_bottom_rois[3] * spatial_scale); + // T roi_end_h = round(offset_bottom_rois[4] * spatial_scale); + + // Force malformed ROIs to be 1x1 + T roi_width = max(roi_end_w - roi_start_w, (T)1.); + T roi_height = max(roi_end_h - roi_start_h, (T)1.); + T bin_size_h = static_cast(roi_height) / static_cast(pooled_height); + T bin_size_w = static_cast(roi_width) / static_cast(pooled_width); + + T* offset_bottom_diff = bottom_diff + (roi_batch_ind * channels + c) * height * width; + + int top_offset = (n * channels + c) * pooled_height * pooled_width; + const T* offset_top_diff = top_diff + top_offset; + const T top_diff_this_bin = offset_top_diff[ph * pooled_width + pw]; + + // We use roi_bin_grid to sample the grid and mimic integral + int roi_bin_grid_h = (sampling_ratio > 0) ? sampling_ratio : ceil(roi_height / pooled_height); // e.g., = 2 + int roi_bin_grid_w = (sampling_ratio > 0) ? sampling_ratio : ceil(roi_width / pooled_width); + + // We do average (integral) pooling inside a bin + const T count = roi_bin_grid_h * roi_bin_grid_w; // e.g. = 4 + + for (int iy = 0; iy < roi_bin_grid_h; iy ++) // e.g., iy = 0, 1 + { + const T y = roi_start_h + ph * bin_size_h + static_cast(iy + .5f) * bin_size_h / static_cast(roi_bin_grid_h); // e.g., 0.5, 1.5 + for (int ix = 0; ix < roi_bin_grid_w; ix ++) + { + const T x = roi_start_w + pw * bin_size_w + static_cast(ix + .5f) * bin_size_w / static_cast(roi_bin_grid_w); + + T w1, w2, w3, w4; + int x_low, x_high, y_low, y_high; + + bilinear_interpolate_gradient(height, width, y, x, + w1, w2, w3, w4, + x_low, x_high, y_low, y_high, + index); + + T g1 = top_diff_this_bin * w1 / count; + T g2 = top_diff_this_bin * w2 / count; + T g3 = top_diff_this_bin * w3 / count; + T g4 = top_diff_this_bin * w4 / count; + + if (x_low >= 0 && x_high >= 0 && y_low >= 0 && y_high >= 0) + { + atomicAdd(offset_bottom_diff + y_low * width + x_low, static_cast(g1)); + atomicAdd(offset_bottom_diff + y_low * width + x_high, static_cast(g2)); + atomicAdd(offset_bottom_diff + y_high * width + x_low, static_cast(g3)); + atomicAdd(offset_bottom_diff + y_high * width + x_high, static_cast(g4)); + } // if + } // ix + } // iy + } // CUDA_1D_KERNEL_LOOP +} // RoIAlignBackward + + +at::Tensor ROIAlign_forward_cuda(const at::Tensor& input, + const at::Tensor& rois, + const float spatial_scale, + const int pooled_height, + const int pooled_width, + const int sampling_ratio) { + AT_ASSERTM(input.type().is_cuda(), "input must be a CUDA tensor"); + AT_ASSERTM(rois.type().is_cuda(), "rois must be a CUDA tensor"); + + auto num_rois = rois.size(0); + auto channels = input.size(1); + auto height = input.size(2); + auto width = input.size(3); + + auto output = at::empty({num_rois, channels, pooled_height, pooled_width}, input.options()); + auto output_size = num_rois * pooled_height * pooled_width * channels; + cudaStream_t stream = at::cuda::getCurrentCUDAStream(); + + dim3 grid(std::min(THCCeilDiv(output_size, 512L), 4096L)); + dim3 block(512); + + if (output.numel() == 0) { + THCudaCheck(cudaGetLastError()); + return output; + } + + AT_DISPATCH_FLOATING_TYPES(input.type(), "ROIAlign_forward", [&] { + RoIAlignForward<<>>( + output_size, + input.contiguous().data(), + spatial_scale, + channels, + height, + width, + pooled_height, + pooled_width, + sampling_ratio, + rois.contiguous().data(), + output.data()); + }); + THCudaCheck(cudaGetLastError()); + return output; +} + +// TODO remove the dependency on input and use instead its sizes -> save memory +at::Tensor ROIAlign_backward_cuda(const at::Tensor& grad, + const at::Tensor& rois, + const float spatial_scale, + const int pooled_height, + const int pooled_width, + const int batch_size, + const int channels, + const int height, + const int width, + const int sampling_ratio) { + AT_ASSERTM(grad.type().is_cuda(), "grad must be a CUDA tensor"); + AT_ASSERTM(rois.type().is_cuda(), "rois must be a CUDA tensor"); + + auto num_rois = rois.size(0); + auto grad_input = at::zeros({batch_size, channels, height, width}, grad.options()); + + cudaStream_t stream = at::cuda::getCurrentCUDAStream(); + + dim3 grid(std::min(THCCeilDiv(grad.numel(), 512L), 4096L)); + dim3 block(512); + + // handle possibly empty gradients + if (grad.numel() == 0) { + THCudaCheck(cudaGetLastError()); + return grad_input; + } + + AT_DISPATCH_FLOATING_TYPES(grad.type(), "ROIAlign_backward", [&] { + RoIAlignBackwardFeature<<>>( + grad.numel(), + grad.contiguous().data(), + num_rois, + spatial_scale, + channels, + height, + width, + pooled_height, + pooled_width, + sampling_ratio, + grad_input.data(), + rois.contiguous().data()); + }); + THCudaCheck(cudaGetLastError()); + return grad_input; +} diff --git a/lib/model/csrc/cuda/ROIPool_cuda.cu b/lib/model/csrc/cuda/ROIPool_cuda.cu new file mode 100644 index 0000000..b826dd9 --- /dev/null +++ b/lib/model/csrc/cuda/ROIPool_cuda.cu @@ -0,0 +1,202 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. +#include +#include + +#include +#include +#include + + +// TODO make it in a common file +#define CUDA_1D_KERNEL_LOOP(i, n) \ + for (int i = blockIdx.x * blockDim.x + threadIdx.x; i < n; \ + i += blockDim.x * gridDim.x) + + +template +__global__ void RoIPoolFForward(const int nthreads, const T* bottom_data, + const T spatial_scale, const int channels, const int height, + const int width, const int pooled_height, const int pooled_width, + const T* bottom_rois, T* top_data, int* argmax_data) { + CUDA_1D_KERNEL_LOOP(index, nthreads) { + // (n, c, ph, pw) is an element in the pooled output + int pw = index % pooled_width; + int ph = (index / pooled_width) % pooled_height; + int c = (index / pooled_width / pooled_height) % channels; + int n = index / pooled_width / pooled_height / channels; + + const T* offset_bottom_rois = bottom_rois + n * 5; + int roi_batch_ind = offset_bottom_rois[0]; + int roi_start_w = round(offset_bottom_rois[1] * spatial_scale); + int roi_start_h = round(offset_bottom_rois[2] * spatial_scale); + int roi_end_w = round(offset_bottom_rois[3] * spatial_scale); + int roi_end_h = round(offset_bottom_rois[4] * spatial_scale); + + // Force malformed ROIs to be 1x1 + int roi_width = max(roi_end_w - roi_start_w + 1, 1); + int roi_height = max(roi_end_h - roi_start_h + 1, 1); + T bin_size_h = static_cast(roi_height) + / static_cast(pooled_height); + T bin_size_w = static_cast(roi_width) + / static_cast(pooled_width); + + int hstart = static_cast(floor(static_cast(ph) + * bin_size_h)); + int wstart = static_cast(floor(static_cast(pw) + * bin_size_w)); + int hend = static_cast(ceil(static_cast(ph + 1) + * bin_size_h)); + int wend = static_cast(ceil(static_cast(pw + 1) + * bin_size_w)); + + // Add roi offsets and clip to input boundaries + hstart = min(max(hstart + roi_start_h, 0), height); + hend = min(max(hend + roi_start_h, 0), height); + wstart = min(max(wstart + roi_start_w, 0), width); + wend = min(max(wend + roi_start_w, 0), width); + bool is_empty = (hend <= hstart) || (wend <= wstart); + + // Define an empty pooling region to be zero + T maxval = is_empty ? 0 : -FLT_MAX; + // If nothing is pooled, argmax = -1 causes nothing to be backprop'd + int maxidx = -1; + const T* offset_bottom_data = + bottom_data + (roi_batch_ind * channels + c) * height * width; + for (int h = hstart; h < hend; ++h) { + for (int w = wstart; w < wend; ++w) { + int bottom_index = h * width + w; + if (offset_bottom_data[bottom_index] > maxval) { + maxval = offset_bottom_data[bottom_index]; + maxidx = bottom_index; + } + } + } + top_data[index] = maxval; + argmax_data[index] = maxidx; + } +} + +template +__global__ void RoIPoolFBackward(const int nthreads, const T* top_diff, + const int* argmax_data, const int num_rois, const T spatial_scale, + const int channels, const int height, const int width, + const int pooled_height, const int pooled_width, T* bottom_diff, + const T* bottom_rois) { + CUDA_1D_KERNEL_LOOP(index, nthreads) { + // (n, c, ph, pw) is an element in the pooled output + int pw = index % pooled_width; + int ph = (index / pooled_width) % pooled_height; + int c = (index / pooled_width / pooled_height) % channels; + int n = index / pooled_width / pooled_height / channels; + + const T* offset_bottom_rois = bottom_rois + n * 5; + int roi_batch_ind = offset_bottom_rois[0]; + int bottom_offset = (roi_batch_ind * channels + c) * height * width; + int top_offset = (n * channels + c) * pooled_height * pooled_width; + const T* offset_top_diff = top_diff + top_offset; + T* offset_bottom_diff = bottom_diff + bottom_offset; + const int* offset_argmax_data = argmax_data + top_offset; + + int argmax = offset_argmax_data[ph * pooled_width + pw]; + if (argmax != -1) { + atomicAdd( + offset_bottom_diff + argmax, + static_cast(offset_top_diff[ph * pooled_width + pw])); + + } + } +} + +std::tuple ROIPool_forward_cuda(const at::Tensor& input, + const at::Tensor& rois, + const float spatial_scale, + const int pooled_height, + const int pooled_width) { + AT_ASSERTM(input.type().is_cuda(), "input must be a CUDA tensor"); + AT_ASSERTM(rois.type().is_cuda(), "rois must be a CUDA tensor"); + + auto num_rois = rois.size(0); + auto channels = input.size(1); + auto height = input.size(2); + auto width = input.size(3); + + auto output = at::empty({num_rois, channels, pooled_height, pooled_width}, input.options()); + auto output_size = num_rois * pooled_height * pooled_width * channels; + auto argmax = at::zeros({num_rois, channels, pooled_height, pooled_width}, input.options().dtype(at::kInt)); + + cudaStream_t stream = at::cuda::getCurrentCUDAStream(); + + dim3 grid(std::min(THCCeilDiv(output_size, 512L), 4096L)); + dim3 block(512); + + if (output.numel() == 0) { + THCudaCheck(cudaGetLastError()); + return std::make_tuple(output, argmax); + } + + AT_DISPATCH_FLOATING_TYPES(input.type(), "ROIPool_forward", [&] { + RoIPoolFForward<<>>( + output_size, + input.contiguous().data(), + spatial_scale, + channels, + height, + width, + pooled_height, + pooled_width, + rois.contiguous().data(), + output.data(), + argmax.data()); + }); + THCudaCheck(cudaGetLastError()); + return std::make_tuple(output, argmax); +} + +// TODO remove the dependency on input and use instead its sizes -> save memory +at::Tensor ROIPool_backward_cuda(const at::Tensor& grad, + const at::Tensor& input, + const at::Tensor& rois, + const at::Tensor& argmax, + const float spatial_scale, + const int pooled_height, + const int pooled_width, + const int batch_size, + const int channels, + const int height, + const int width) { + AT_ASSERTM(grad.type().is_cuda(), "grad must be a CUDA tensor"); + AT_ASSERTM(rois.type().is_cuda(), "rois must be a CUDA tensor"); + // TODO add more checks + + auto num_rois = rois.size(0); + auto grad_input = at::zeros({batch_size, channels, height, width}, grad.options()); + + cudaStream_t stream = at::cuda::getCurrentCUDAStream(); + + dim3 grid(std::min(THCCeilDiv(grad.numel(), 512L), 4096L)); + dim3 block(512); + + // handle possibly empty gradients + if (grad.numel() == 0) { + THCudaCheck(cudaGetLastError()); + return grad_input; + } + + AT_DISPATCH_FLOATING_TYPES(grad.type(), "ROIPool_backward", [&] { + RoIPoolFBackward<<>>( + grad.numel(), + grad.contiguous().data(), + argmax.data(), + num_rois, + spatial_scale, + channels, + height, + width, + pooled_height, + pooled_width, + grad_input.data(), + rois.contiguous().data()); + }); + THCudaCheck(cudaGetLastError()); + return grad_input; +} diff --git a/lib/model/csrc/cuda/nms.cu b/lib/model/csrc/cuda/nms.cu new file mode 100644 index 0000000..833d852 --- /dev/null +++ b/lib/model/csrc/cuda/nms.cu @@ -0,0 +1,131 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. +#include +#include + +#include +#include + +#include +#include + +int const threadsPerBlock = sizeof(unsigned long long) * 8; + +__device__ inline float devIoU(float const * const a, float const * const b) { + float left = max(a[0], b[0]), right = min(a[2], b[2]); + float top = max(a[1], b[1]), bottom = min(a[3], b[3]); + float width = max(right - left + 1, 0.f), height = max(bottom - top + 1, 0.f); + float interS = width * height; + float Sa = (a[2] - a[0] + 1) * (a[3] - a[1] + 1); + float Sb = (b[2] - b[0] + 1) * (b[3] - b[1] + 1); + return interS / (Sa + Sb - interS); +} + +__global__ void nms_kernel(const int n_boxes, const float nms_overlap_thresh, + const float *dev_boxes, unsigned long long *dev_mask) { + const int row_start = blockIdx.y; + const int col_start = blockIdx.x; + + // if (row_start > col_start) return; + + const int row_size = + min(n_boxes - row_start * threadsPerBlock, threadsPerBlock); + const int col_size = + min(n_boxes - col_start * threadsPerBlock, threadsPerBlock); + + __shared__ float block_boxes[threadsPerBlock * 5]; + if (threadIdx.x < col_size) { + block_boxes[threadIdx.x * 5 + 0] = + dev_boxes[(threadsPerBlock * col_start + threadIdx.x) * 5 + 0]; + block_boxes[threadIdx.x * 5 + 1] = + dev_boxes[(threadsPerBlock * col_start + threadIdx.x) * 5 + 1]; + block_boxes[threadIdx.x * 5 + 2] = + dev_boxes[(threadsPerBlock * col_start + threadIdx.x) * 5 + 2]; + block_boxes[threadIdx.x * 5 + 3] = + dev_boxes[(threadsPerBlock * col_start + threadIdx.x) * 5 + 3]; + block_boxes[threadIdx.x * 5 + 4] = + dev_boxes[(threadsPerBlock * col_start + threadIdx.x) * 5 + 4]; + } + __syncthreads(); + + if (threadIdx.x < row_size) { + const int cur_box_idx = threadsPerBlock * row_start + threadIdx.x; + const float *cur_box = dev_boxes + cur_box_idx * 5; + int i = 0; + unsigned long long t = 0; + int start = 0; + if (row_start == col_start) { + start = threadIdx.x + 1; + } + for (i = start; i < col_size; i++) { + if (devIoU(cur_box, block_boxes + i * 5) > nms_overlap_thresh) { + t |= 1ULL << i; + } + } + const int col_blocks = THCCeilDiv(n_boxes, threadsPerBlock); + dev_mask[cur_box_idx * col_blocks + col_start] = t; + } +} + +// boxes is a N x 5 tensor +at::Tensor nms_cuda(const at::Tensor boxes, float nms_overlap_thresh) { + using scalar_t = float; + AT_ASSERTM(boxes.type().is_cuda(), "boxes must be a CUDA tensor"); + auto scores = boxes.select(1, 4); + auto order_t = std::get<1>(scores.sort(0, /* descending=*/true)); + auto boxes_sorted = boxes.index_select(0, order_t); + + int boxes_num = boxes.size(0); + + const int col_blocks = THCCeilDiv(boxes_num, threadsPerBlock); + + scalar_t* boxes_dev = boxes_sorted.data(); + + THCState *state = at::globalContext().lazyInitCUDA(); // TODO replace with getTHCState + + unsigned long long* mask_dev = NULL; + //THCudaCheck(THCudaMalloc(state, (void**) &mask_dev, + // boxes_num * col_blocks * sizeof(unsigned long long))); + + mask_dev = (unsigned long long*) THCudaMalloc(state, boxes_num * col_blocks * sizeof(unsigned long long)); + + dim3 blocks(THCCeilDiv(boxes_num, threadsPerBlock), + THCCeilDiv(boxes_num, threadsPerBlock)); + dim3 threads(threadsPerBlock); + nms_kernel<<>>(boxes_num, + nms_overlap_thresh, + boxes_dev, + mask_dev); + + std::vector mask_host(boxes_num * col_blocks); + THCudaCheck(cudaMemcpy(&mask_host[0], + mask_dev, + sizeof(unsigned long long) * boxes_num * col_blocks, + cudaMemcpyDeviceToHost)); + + std::vector remv(col_blocks); + memset(&remv[0], 0, sizeof(unsigned long long) * col_blocks); + + at::Tensor keep = at::empty({boxes_num}, boxes.options().dtype(at::kLong).device(at::kCPU)); + int64_t* keep_out = keep.data(); + + int num_to_keep = 0; + for (int i = 0; i < boxes_num; i++) { + int nblock = i / threadsPerBlock; + int inblock = i % threadsPerBlock; + + if (!(remv[nblock] & (1ULL << inblock))) { + keep_out[num_to_keep++] = i; + unsigned long long *p = &mask_host[0] + i * col_blocks; + for (int j = nblock; j < col_blocks; j++) { + remv[j] |= p[j]; + } + } + } + + THCudaFree(state, mask_dev); + // TODO improve this part + return std::get<0>(order_t.index({ + keep.narrow(/*dim=*/0, /*start=*/0, /*length=*/num_to_keep).to( + order_t.device(), keep.scalar_type()) + }).sort(0, false)); +} diff --git a/lib/model/csrc/cuda/vision.h b/lib/model/csrc/cuda/vision.h new file mode 100644 index 0000000..977cef7 --- /dev/null +++ b/lib/model/csrc/cuda/vision.h @@ -0,0 +1,48 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. +#pragma once +#include + + +at::Tensor ROIAlign_forward_cuda(const at::Tensor& input, + const at::Tensor& rois, + const float spatial_scale, + const int pooled_height, + const int pooled_width, + const int sampling_ratio); + +at::Tensor ROIAlign_backward_cuda(const at::Tensor& grad, + const at::Tensor& rois, + const float spatial_scale, + const int pooled_height, + const int pooled_width, + const int batch_size, + const int channels, + const int height, + const int width, + const int sampling_ratio); + + +std::tuple ROIPool_forward_cuda(const at::Tensor& input, + const at::Tensor& rois, + const float spatial_scale, + const int pooled_height, + const int pooled_width); + +at::Tensor ROIPool_backward_cuda(const at::Tensor& grad, + const at::Tensor& input, + const at::Tensor& rois, + const at::Tensor& argmax, + const float spatial_scale, + const int pooled_height, + const int pooled_width, + const int batch_size, + const int channels, + const int height, + const int width); + +at::Tensor nms_cuda(const at::Tensor boxes, float nms_overlap_thresh); + + +at::Tensor compute_flow_cuda(const at::Tensor& boxes, + const int height, + const int width); diff --git a/lib/model/csrc/nms.h b/lib/model/csrc/nms.h new file mode 100644 index 0000000..312fed4 --- /dev/null +++ b/lib/model/csrc/nms.h @@ -0,0 +1,28 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. +#pragma once +#include "cpu/vision.h" + +#ifdef WITH_CUDA +#include "cuda/vision.h" +#endif + + +at::Tensor nms(const at::Tensor& dets, + const at::Tensor& scores, + const float threshold) { + + if (dets.type().is_cuda()) { +#ifdef WITH_CUDA + // TODO raise error if not compiled with CUDA + if (dets.numel() == 0) + return at::empty({0}, dets.options().dtype(at::kLong).device(at::kCPU)); + auto b = at::cat({dets, scores.unsqueeze(1)}, 1); + return nms_cuda(b, threshold); +#else + AT_ERROR("Not compiled with GPU support"); +#endif + } + + at::Tensor result = nms_cpu(dets, scores, threshold); + return result; +} diff --git a/lib/model/csrc/vision.cpp b/lib/model/csrc/vision.cpp new file mode 100644 index 0000000..ff00258 --- /dev/null +++ b/lib/model/csrc/vision.cpp @@ -0,0 +1,13 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. +#include "nms.h" +#include "ROIAlign.h" +#include "ROIPool.h" + + +PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) { + m.def("nms", &nms, "non-maximum suppression"); + m.def("roi_align_forward", &ROIAlign_forward, "ROIAlign_forward"); + m.def("roi_align_backward", &ROIAlign_backward, "ROIAlign_backward"); + m.def("roi_pool_forward", &ROIPool_forward, "ROIPool_forward"); + m.def("roi_pool_backward", &ROIPool_backward, "ROIPool_backward"); +} diff --git a/lib/model/faster_rcnn/__init__.py b/lib/model/faster_rcnn/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/lib/model/faster_rcnn/faster_rcnn_early_fusion.py b/lib/model/faster_rcnn/faster_rcnn_early_fusion.py new file mode 100644 index 0000000..c9c8d02 --- /dev/null +++ b/lib/model/faster_rcnn/faster_rcnn_early_fusion.py @@ -0,0 +1,387 @@ +import random +import torch +import torch.nn as nn +import torch.nn.functional as F +from torch.autograd import Variable +import torchvision.models as models +from torch.autograd import Variable +import numpy as np +from model.utils.config import cfg + +from model.rpn.rpn import _RPN +import random + +from model.roi_layers import ROIAlign, ROIPool + +# from model.roi_pooling.modules.roi_pool import _RoIPooling +# from model.roi_align.modules.roi_align import RoIAlignAvg + +from model.rpn.proposal_target_layer_cascade import _ProposalTargetLayer +import time +import pdb +from model.utils.net_utils import _smooth_l1_loss, _crop_pool_layer, _affine_grid_gen, _affine_theta +from model.utils.net_utils import * +from torch.autograd import Function + + +class attention(nn.Module): + def __init__(self, inplanes): + super(attention, self).__init__() + self.in_channels = inplanes + self.inter_channels = None + + if self.inter_channels is None: + self.inter_channels = self.in_channels // 2 + if self.inter_channels == 0: + self.inter_channels = 1 + conv_nd = nn.Conv2d + self.maxpool_2d = nn.MaxPool2d(self.in_channels) + + bn = nn.BatchNorm2d + + self.theta_sketch = nn.Sequential(conv_nd(in_channels=self.in_channels, out_channels=self.in_channels, + kernel_size=1, stride=1, padding=0, bias=True), + bn(self.in_channels), + nn.ReLU(), + conv_nd(in_channels=self.in_channels, out_channels=self.in_channels, + kernel_size=1, stride=1, padding=0, bias=False)) + + self.theta_image = nn.Sequential(conv_nd(in_channels=self.in_channels, out_channels=self.in_channels, + kernel_size=1, stride=1, padding=0, bias=True), + bn(self.in_channels), + nn.ReLU(), + conv_nd(in_channels=self.in_channels, out_channels=self.in_channels, + kernel_size=1, stride=1, padding=0, bias=False)) + + self.op = nn.Sequential(conv_nd(in_channels=1, out_channels=1, + kernel_size=1, stride=1, padding=0, bias=True)) + + nn.init.xavier_uniform_(self.theta_sketch[0].weight) + nn.init.xavier_uniform_(self.theta_image[0].weight) + nn.init.xavier_uniform_(self.op[0].weight) + + def forward(self, image_feats, sketch_feats): + img_feats = self.theta_image(image_feats) + sketch_feats_ = self.theta_sketch(sketch_feats) + + batch_size, n_channels, w, h = img_feats.shape + image_feats = image_feats.view(batch_size, n_channels, -1) + + sketch_feats_ = sketch_feats_.view(batch_size, n_channels, -1) + sketch_max_feats, _ = torch.max(sketch_feats_, dim=2) + + img_feats = img_feats.view(batch_size, n_channels, -1) + + + attention_feats = torch.bmm(sketch_max_feats.unsqueeze(1), img_feats) + + sketch_max_feats = sketch_max_feats.unsqueeze(2).expand_as(img_feats) + attention_feats = attention_feats.view(batch_size, 1, w, h) + + attention_feats = self.op(attention_feats) + + attention_feats = attention_feats.view(batch_size, 1, -1) + attention_feats = attention_feats/256 + attention_map = attention_feats.clone().view(batch_size,1,w,h) + + + attention_feats = image_feats*attention_feats.expand_as(image_feats) + attention_feats = attention_feats.view(batch_size, n_channels, w, h) + + return attention_feats, sketch_feats,attention_map + + + + +class attention_early_fusion_multi_query(nn.Module): + def __init__(self, inplanes): + super(attention_early_fusion_multi_query, self).__init__() + self.in_channels = inplanes + self.inter_channels = None + + if self.inter_channels is None: + self.inter_channels = self.in_channels // 2 + if self.inter_channels == 0: + self.inter_channels = 1 + conv_nd = nn.Conv2d + self.maxpool_2d = nn.MaxPool2d(self.in_channels) + + bn = nn.BatchNorm2d + + + self.theta_sketch = nn.Sequential(conv_nd(in_channels=self.in_channels, out_channels=self.in_channels, + kernel_size=1, stride=1, padding=0, bias=True), + bn(self.in_channels), + nn.ReLU(), + conv_nd(in_channels=self.in_channels, out_channels=self.in_channels, + kernel_size=1, stride=1, padding=0, bias=False)) + + self.theta_image = nn.Sequential(conv_nd(in_channels=self.in_channels, out_channels=self.in_channels, + kernel_size=1, stride=1, padding=0, bias=True), + bn(self.in_channels), + nn.ReLU(), + conv_nd(in_channels=self.in_channels, out_channels=self.in_channels, + kernel_size=1, stride=1, padding=0, bias=False)) + + self.op = nn.Sequential(conv_nd(in_channels=1, out_channels=1, + kernel_size=1, stride=1, padding=0, bias=True)) + + self.fusion_layer = nn.Sequential(conv_nd(in_channels=3, out_channels=1, + kernel_size=1, stride=1, padding=0, bias=True)) + + self.sketch_fusion = nn.Sequential(conv_nd(in_channels=self.in_channels*3, out_channels=self.in_channels, + kernel_size=1, stride=1, padding=0, bias=False)) + + nn.init.xavier_uniform_(self.theta_sketch[0].weight) + nn.init.xavier_uniform_(self.theta_image[0].weight) + nn.init.xavier_uniform_(self.op[0].weight) + nn.init.xavier_uniform_(self.fusion_layer[0].weight) + + def forward(self, image_feats, sketch_feats_1, sketch_feats_2, sketch_feats_3): + img_feats = self.theta_image(image_feats) + sketch_feats__1 = self.theta_sketch(sketch_feats_1) + sketch_feats__2 = self.theta_sketch(sketch_feats_2) + sketch_feats__3 = self.theta_sketch(sketch_feats_3) + + sketches = self.sketch_fusion(torch.cat([sketch_feats_1, sketch_feats_2, sketch_feats_3], dim=1)) + + + batch_size, n_channels, w, h = img_feats.shape + image_feats = image_feats.view(batch_size, n_channels, -1) + + sketch_feats__1 = sketch_feats__1.view(batch_size, n_channels, -1) + sketch_max_feats_1, _ = torch.max(sketch_feats__1, dim=2) + + sketch_feats__2 = sketch_feats__2.view(batch_size, n_channels, -1) + sketch_max_feats_2, _ = torch.max(sketch_feats__2, dim=2) + + sketch_feats__3 = sketch_feats__3.view(batch_size, n_channels, -1) + sketch_max_feats_3, _ = torch.max(sketch_feats__3, dim=2) + + + img_feats = img_feats.view(batch_size, n_channels, -1) + + + attention_feats_1 = torch.bmm(sketch_max_feats_1.unsqueeze(1), img_feats) + attention_feats_2 = torch.bmm(sketch_max_feats_2.unsqueeze(1), img_feats) + attention_feats_3 = torch.bmm(sketch_max_feats_3.unsqueeze(1), img_feats) + + + attention_feats_1 = attention_feats_1.view(batch_size, 1, w, h) + attention_feats_2 = attention_feats_2.view(batch_size, 1, w, h) + attention_feats_3 = attention_feats_3.view(batch_size, 1, w, h) + + attention_feats_1 = self.op(attention_feats_1) + attention_feats_2 = self.op(attention_feats_2) + attention_feats_3 = self.op(attention_feats_3) + + attention_map_1 = attention_feats_1.clone() + attention_map_2 = attention_feats_2.clone() + attention_map_3 = attention_feats_3.clone() + + + attention_feats = torch.cat([attention_feats_1, attention_feats_2, attention_feats_3], dim=1) + final_atten_map = attention_feats.clone() + + # attention_feats , _ = torch.max(attention_feats, dim=1) + attention_feats = attention_feats.mean(1) + + attention_feats = attention_feats.view(batch_size, 1, -1) + attention_feats = attention_feats/256 + attention_feats = image_feats*attention_feats.expand_as(image_feats) + attention_feats = attention_feats.view(batch_size, n_channels, w, h) + + return attention_feats, sketches, [attention_map_1, attention_feats_2, attention_feats_3, final_atten_map] + + +class ReverseLayerF(Function): + + @staticmethod + def forward(ctx, x, alpha): + ctx.alpha = alpha + + return x.view_as(x) + + @staticmethod + def backward(ctx, grad_output): + output = grad_output.neg() * ctx.alpha + + return output, None + +class _fasterRCNN(nn.Module): + """ faster RCNN """ + def __init__(self, classes, class_agnostic, model_type="attention", fusion='query'): + super(_fasterRCNN, self).__init__() + self.classes = classes + self.n_classes = len(classes) + self.class_agnostic = class_agnostic + conv_nd = nn.Conv2d + self.fusion = fusion + + if fusion == 'query': + self.attention_net = attention(self.dout_base_model) + elif fusion == 'attention': + self.attention_net = attention_early_fusion_multi_query(self.dout_base_model) + + + self.projection = conv_nd(in_channels=1024*2, out_channels=1024, + kernel_size=1, stride=1, padding=0, bias=False) + + nn.init.xavier_uniform_(self.projection.weight) + + + + # loss + self.RCNN_loss_cls = 0 + self.RCNN_loss_bbox = 0 + + # define rpn + self.RCNN_rpn = _RPN(self.dout_base_model) + self.RCNN_proposal_target = _ProposalTargetLayer(self.n_classes) + + # self.RCNN_roi_pool = _RoIPooling(cfg.POOLING_SIZE, cfg.POOLING_SIZE, 1.0/16.0) + # self.RCNN_roi_align = RoIAlignAvg(cfg.POOLING_SIZE, cfg.POOLING_SIZE, 1.0/16.0) + + self.RCNN_roi_pool = ROIPool((cfg.POOLING_SIZE, cfg.POOLING_SIZE), 1.0/16.0) + self.RCNN_roi_align = ROIAlign((cfg.POOLING_SIZE, cfg.POOLING_SIZE), 1.0/16.0, 0) + self.triplet_loss = torch.nn.MarginRankingLoss(margin=cfg.TRAIN.MARGIN) + + def forward(self, im_data, query, im_info, gt_boxes, num_boxes): + batch_size = im_data.size(0) + + im_info = im_info.data + gt_boxes = gt_boxes.data + num_boxes = num_boxes.data + + # feed image data to base model to obtain base feature map + detect_feat = self.RCNN_base(im_data) + query_feat_1 = self.RCNN_base_sketch(query.permute(1,0,2,3,4)[0]) + query_feat_2 = self.RCNN_base_sketch(query.permute(1,0,2,3,4)[1]) + query_feat_3 = self.RCNN_base_sketch(query.permute(1,0,2,3,4)[2]) + + comulative_query = torch.cat([query_feat_1.unsqueeze(4),query_feat_2.unsqueeze(4), query_feat_3.unsqueeze(4)], dim=4) + + comulative_query,_ = torch.max(comulative_query, dim=4) + + domain_loss = 0 + + + + # rpn_feat, act_feat, act_aim, c_weight = self.match_net(detect_feat, query_feat) + c_weight = None + if self.fusion == 'query': + act_feat, act_aim, attention_map = self.attention_net(detect_feat, query_feat_1, query_feat_2, query_feat_3) + elif self.fusion == 'attention': + act_feat, act_aim, attention_map = self.attention_net(detect_feat, comulative_query) + act_aim = comulative_query + # c_weight = None + + act_feat = torch.cat([act_feat, detect_feat], dim=1) + act_feat = self.projection(act_feat) + + # feed base feature map tp RPN to obtain rois + rois, rpn_loss_cls, rpn_loss_bbox = self.RCNN_rpn(act_feat, im_info, gt_boxes, num_boxes) + + # if it is training phrase, then use ground trubut bboxes for refining + if self.training: + roi_data = self.RCNN_proposal_target(rois, gt_boxes, num_boxes) + rois, rois_label, rois_target, rois_inside_ws, rois_outside_ws = roi_data + + rois_label = Variable(rois_label.view(-1).long()) + rois_target = Variable(rois_target.view(-1, rois_target.size(2))) + rois_inside_ws = Variable(rois_inside_ws.view(-1, rois_inside_ws.size(2))) + rois_outside_ws = Variable(rois_outside_ws.view(-1, rois_outside_ws.size(2))) + else: + rois_label = None + rois_target = None + rois_inside_ws = None + rois_outside_ws = None + rpn_loss_cls = 0 + margin_loss = 0 + rpn_loss_bbox = 0 + score_label = None + + rois = Variable(rois) + + # do roi pooling based on predicted rois + if cfg.POOLING_MODE == 'align': + pooled_feat = self.RCNN_roi_align(act_feat, rois.view(-1, 5)) + + elif cfg.POOLING_MODE == 'pool': + pooled_feat = self.RCNN_roi_pool(act_feat, rois.view(-1,5)) + + + # feed pooled features to top model + pooled_feat = self._head_to_tail(pooled_feat) + # pooled_feat_atten = self._head_to_tail(pooled_feat_atten) + query_feat = self._head_to_tail(act_aim) + batch_size = query_feat.shape[0] + + + # domain_loss = 0 + + # compute bbox offset + bbox_pred = self.RCNN_bbox_pred(pooled_feat) + + + pooled_feat = pooled_feat.view(batch_size, rois.size(1), -1) + query_feat = query_feat.unsqueeze(1).repeat(1,rois.size(1),1) + + + pooled_feat = torch.cat((pooled_feat.expand_as(query_feat),query_feat), dim=2).view(-1, 4096) + + # compute object classification probability + score = self.RCNN_cls_score(pooled_feat) + + score_prob = F.softmax(score, 1)[:, 1] + + RCNN_loss_cls = 0 + RCNN_loss_bbox = 0 + + + if self.training: + # if True: + # classification loss + score_label = rois_label.view(batch_size, -1).float() + gt_map = torch.abs(score_label.unsqueeze(1)-score_label.unsqueeze(-1)) + + score_prob = score_prob.view(batch_size, -1) + pr_map = torch.abs(score_prob.unsqueeze(1)-score_prob.unsqueeze(-1)) + target = -((gt_map-1)**2) + gt_map + + RCNN_loss_cls = F.cross_entropy(score, rois_label) + + margin_loss = 3 * self.triplet_loss(pr_map, gt_map, target) + + # bounding box regression L1 loss + RCNN_loss_bbox = _smooth_l1_loss(bbox_pred, rois_target, rois_inside_ws, rois_outside_ws) + + cls_prob = score_prob.view(batch_size, rois.size(1), -1) + bbox_pred = bbox_pred.view(batch_size, rois.size(1), -1) + # c_weight = None + + return rois, cls_prob, bbox_pred, rpn_loss_cls, rpn_loss_bbox, RCNN_loss_cls, margin_loss, RCNN_loss_bbox, rois_label, c_weight, domain_loss, attention_map + + def _init_weights(self): + def normal_init(m, mean, stddev, truncated=False): + """ + weight initalizer: truncated normal and random normal. + """ + # x is a parameter + if truncated: + m.weight.data.normal_().fmod_(2).mul_(stddev).add_(mean) # not a perfect approximation + else: + m.weight.data.normal_(mean, stddev) + m.bias.data.zero_() + + normal_init(self.RCNN_rpn.RPN_Conv, 0, 0.01, cfg.TRAIN.TRUNCATED) + normal_init(self.RCNN_rpn.RPN_cls_score, 0, 0.01, cfg.TRAIN.TRUNCATED) + normal_init(self.RCNN_rpn.RPN_bbox_pred, 0, 0.01, cfg.TRAIN.TRUNCATED) + normal_init(self.RCNN_cls_score[0], 0, 0.01, cfg.TRAIN.TRUNCATED) + normal_init(self.RCNN_cls_score[1], 0, 0.01, cfg.TRAIN.TRUNCATED) + normal_init(self.RCNN_bbox_pred, 0, 0.001, cfg.TRAIN.TRUNCATED) + + + def create_architecture(self): + self._init_modules() + self._init_weights() diff --git a/lib/model/faster_rcnn/faster_rcnn_oneshot.py b/lib/model/faster_rcnn/faster_rcnn_oneshot.py new file mode 100644 index 0000000..6f26e0e --- /dev/null +++ b/lib/model/faster_rcnn/faster_rcnn_oneshot.py @@ -0,0 +1,383 @@ +import random +import torch +import torch.nn as nn +import torch.nn.functional as F +from torch.autograd import Variable +import torchvision.models as models +from torch.autograd import Variable +import numpy as np +from model.utils.config import cfg + +from model.rpn.rpn import _RPN +import random + +from model.roi_layers import ROIAlign, ROIPool + +from model.rpn.proposal_target_layer_cascade import _ProposalTargetLayer +import time +import pdb +from model.utils.net_utils import _smooth_l1_loss, _crop_pool_layer, _affine_grid_gen, _affine_theta +from model.utils.net_utils import * + +class match_block(nn.Module): + def __init__(self, inplanes): + super(match_block, self).__init__() + + self.sub_sample = False + + self.in_channels = inplanes + self.inter_channels = None + + if self.inter_channels is None: + self.inter_channels = self.in_channels // 2 + if self.inter_channels == 0: + self.inter_channels = 1 + + conv_nd = nn.Conv2d + max_pool_layer = nn.MaxPool2d(kernel_size=(2, 2)) + bn = nn.BatchNorm2d + + self.g = conv_nd(in_channels=self.in_channels, out_channels=self.inter_channels, + kernel_size=1, stride=1, padding=0) + + + self.W = nn.Sequential( + conv_nd(in_channels=self.inter_channels, out_channels=self.in_channels, + kernel_size=1, stride=1, padding=0), + bn(self.in_channels) + ) + nn.init.constant_(self.W[1].weight, 0) + nn.init.constant_(self.W[1].bias, 0) + + self.Q = nn.Sequential( + conv_nd(in_channels=self.inter_channels, out_channels=self.in_channels, + kernel_size=1, stride=1, padding=0), + bn(self.in_channels) + ) + nn.init.constant_(self.Q[1].weight, 0) + nn.init.constant_(self.Q[1].bias, 0) + + self.theta = conv_nd(in_channels=self.in_channels, out_channels=self.inter_channels, + kernel_size=1, stride=1, padding=0) + + self.phi = conv_nd(in_channels=self.in_channels, out_channels=self.inter_channels, + kernel_size=1, stride=1, padding=0) + + self.concat_project = nn.Sequential( + nn.Conv2d(self.inter_channels * 2, 1, 1, 1, 0, bias=False), + nn.ReLU() + ) + + self.ChannelGate = ChannelGate(self.in_channels) + self.globalAvgPool = nn.AdaptiveAvgPool2d(1) + + + + def forward(self, detect, aim): + + + + batch_size, channels, height_a, width_a = aim.shape + batch_size, channels, height_d, width_d = detect.shape + + + #####################################find aim image similar object #################################################### + + d_x = self.g(detect).view(batch_size, self.inter_channels, -1) + d_x = d_x.permute(0, 2, 1).contiguous() + + a_x = self.g(aim).view(batch_size, self.inter_channels, -1) + a_x = a_x.permute(0, 2, 1).contiguous() + + theta_x = self.theta(aim).view(batch_size, self.inter_channels, -1) + theta_x = theta_x.permute(0, 2, 1) + + phi_x = self.phi(detect).view(batch_size, self.inter_channels, -1) + + + + f = torch.matmul(theta_x, phi_x) + N = f.size(-1) + f_div_C = f / N + aa = f_div_C[f_div_C > 0] + + + + f = f.permute(0, 2, 1).contiguous() + N = f.size(-1) + fi_div_C = f / N + + non_aim = torch.matmul(f_div_C, d_x) + non_aim = non_aim.permute(0, 2, 1).contiguous() + non_aim = non_aim.view(batch_size, self.inter_channels, height_a, width_a) + non_aim = self.W(non_aim) + non_aim = non_aim + aim + non_det = torch.matmul(fi_div_C, a_x) + non_det = non_det.permute(0, 2, 1).contiguous() + + non_det = non_det.view(batch_size, self.inter_channels, height_d, width_d) + non_det = self.Q(non_det) + non_det = non_det + detect + + ##################################### Response in chaneel weight #################################################### + + c_weight = self.ChannelGate(non_aim) + act_aim = non_aim * c_weight + act_det = non_det * c_weight + + return non_det, act_det, act_aim, c_weight + + +from torch.autograd import Function + + +class attention(nn.Module): + def __init__(self, inplanes): + super(attention, self).__init__() + self.in_channels = inplanes + self.inter_channels = None + + if self.inter_channels is None: + self.inter_channels = self.in_channels // 2 + if self.inter_channels == 0: + self.inter_channels = 1 + conv_nd = nn.Conv2d + self.maxpool_2d = nn.MaxPool2d(self.in_channels) + + bn = nn.BatchNorm2d + + + self.theta_sketch = nn.Sequential(conv_nd(in_channels=self.in_channels, out_channels=self.in_channels, + kernel_size=1, stride=1, padding=0, bias=True), + bn(self.in_channels), + nn.ReLU(), + conv_nd(in_channels=self.in_channels, out_channels=self.in_channels, + kernel_size=1, stride=1, padding=0, bias=False)) + + self.theta_image = nn.Sequential(conv_nd(in_channels=self.in_channels, out_channels=self.in_channels, + kernel_size=1, stride=1, padding=0, bias=True), + bn(self.in_channels), + nn.ReLU(), + conv_nd(in_channels=self.in_channels, out_channels=self.in_channels, + kernel_size=1, stride=1, padding=0, bias=False)) + + + self.op = nn.Sequential(conv_nd(in_channels=1, out_channels=1, + kernel_size=1, stride=1, padding=0, bias=True)) + + nn.init.xavier_uniform_(self.theta_sketch[0].weight) + nn.init.xavier_uniform_(self.theta_image[0].weight) + nn.init.xavier_uniform_(self.op[0].weight) + + def forward(self, image_feats, sketch_feats): + img_feats = self.theta_image(image_feats) + sketch_feats_ = self.theta_sketch(sketch_feats) + + + batch_size, n_channels, w, h = img_feats.shape + image_feats = image_feats.view(batch_size, n_channels, -1) + + sketch_feats_ = sketch_feats_.view(batch_size, n_channels, -1) + sketch_mean_feats, _ = torch.max(sketch_feats_, dim=2) + + img_feats = img_feats.view(batch_size, n_channels, -1) + + + attention_feats = torch.bmm(sketch_mean_feats.unsqueeze(1), img_feats) + + sketch_mean_feats = sketch_mean_feats.unsqueeze(2).expand_as(img_feats) + attention_feats = attention_feats.view(batch_size, 1, w, h) + + attention_feats = self.op(attention_feats) + attention_map = attention_feats.clone() + + attention_feats = attention_feats.view(batch_size, 1, -1) + attention_feats = attention_feats/256 + + attention_feats = image_feats*attention_feats.expand_as(image_feats) + attention_feats = attention_feats.view(batch_size, n_channels, w, h) + + return attention_feats, sketch_feats, attention_map + + +class ReverseLayerF(Function): + + @staticmethod + def forward(ctx, x, alpha): + ctx.alpha = alpha + + return x.view_as(x) + + @staticmethod + def backward(ctx, grad_output): + output = grad_output.neg() * ctx.alpha + + return output, None + +class _fasterRCNN(nn.Module): + """ faster RCNN """ + def __init__(self, classes, class_agnostic, model_type): + super(_fasterRCNN, self).__init__() + self.classes = classes + self.n_classes = len(classes) + self.model_type = model_type + print(self.classes) + self.class_agnostic = class_agnostic + conv_nd = nn.Conv2d + + if self.model_type in ["match_net"]: + self.match_net = match_block(self.dout_base_model) + if self.model_type == "attention": + self.attention_net = attention(self.dout_base_model) + + + self.projection = conv_nd(in_channels=1024*2, out_channels=1024, + kernel_size=1, stride=1, padding=0, bias=False) + + nn.init.xavier_uniform_(self.projection.weight) + + + + # loss + self.RCNN_loss_cls = 0 + self.RCNN_loss_bbox = 0 + + # define rpn + self.RCNN_rpn = _RPN(self.dout_base_model) + self.RCNN_proposal_target = _ProposalTargetLayer(self.n_classes) + + + self.RCNN_roi_pool = ROIPool((cfg.POOLING_SIZE, cfg.POOLING_SIZE), 1.0/16.0) + self.RCNN_roi_align = ROIAlign((cfg.POOLING_SIZE, cfg.POOLING_SIZE), 1.0/16.0, 0) + self.triplet_loss = torch.nn.MarginRankingLoss(margin=cfg.TRAIN.MARGIN) + + def forward(self, im_data, query, im_info, gt_boxes, num_boxes, alpha): + batch_size = im_data.size(0) + + im_info = im_info.data + gt_boxes = gt_boxes.data + num_boxes = num_boxes.data + + # feed image data to base model to obtain base feature map + detect_feat = self.RCNN_base(im_data) + query_feat = self.RCNN_base_sketch(query) + + + if self.model_type == "match_net": + rpn_feat, act_feat, act_aim, c_weight = self.match_net(detect_feat, query_feat) + c_weight = None + + + if self.model_type == "attention": + act_feat, act_aim, attention_map = self.attention_net(detect_feat, query_feat) + act_feat = torch.cat([act_feat, detect_feat], dim=1) + act_feat = self.projection(act_feat) + + if self.model_type == "basic": + act_feat = detect_feat + act_aim = query_feat + + + if self.model_type in ["basic", "attention"]: + rois, rpn_loss_cls, rpn_loss_bbox = self.RCNN_rpn(act_feat, im_info, gt_boxes, num_boxes) + + if self.model_type == "match_net": + rois, rpn_loss_cls, rpn_loss_bbox = self.RCNN_rpn(rpn_feat, im_info, gt_boxes, num_boxes) + attention_map = None + + # if it is training phrase, then use ground trubut bboxes for refining + if self.training: + # if True: + roi_data = self.RCNN_proposal_target(rois, gt_boxes, num_boxes) + rois, rois_label, rois_target, rois_inside_ws, rois_outside_ws = roi_data + + rois_label = Variable(rois_label.view(-1).long()) + rois_target = Variable(rois_target.view(-1, rois_target.size(2))) + rois_inside_ws = Variable(rois_inside_ws.view(-1, rois_inside_ws.size(2))) + rois_outside_ws = Variable(rois_outside_ws.view(-1, rois_outside_ws.size(2))) + else: + rois_label = None + rois_target = None + rois_inside_ws = None + rois_outside_ws = None + rpn_loss_cls = 0 + margin_loss = 0 + rpn_loss_bbox = 0 + score_label = None + + rois = Variable(rois) + + # do roi pooling based on predicted rois + if cfg.POOLING_MODE == 'align': + pooled_feat = self.RCNN_roi_align(act_feat, rois.view(-1, 5)) + + elif cfg.POOLING_MODE == 'pool': + pooled_feat = self.RCNN_roi_pool(act_feat, rois.view(-1,5)) + + + pooled_feat = self._head_to_tail(pooled_feat) + query_feat = self._head_to_tail(act_aim) + + batch_size = query_feat.shape[0] + + + # compute bbox offset + bbox_pred = self.RCNN_bbox_pred(pooled_feat) + + + pooled_feat = pooled_feat.view(batch_size, rois.size(1), -1) + query_feat = query_feat.unsqueeze(1).repeat(1,rois.size(1),1) + + + pooled_feat = torch.cat((pooled_feat.expand_as(query_feat),query_feat), dim=2).view(-1, 4096) + + # compute object classification probability + score = self.RCNN_cls_score(pooled_feat) + + score_prob = F.softmax(score, 1)[:, 1] + + RCNN_loss_cls = 0 + RCNN_loss_bbox = 0 + + + if self.training: + score_label = rois_label.view(batch_size, -1).float() + gt_map = torch.abs(score_label.unsqueeze(1)-score_label.unsqueeze(-1)) + + score_prob = score_prob.view(batch_size, -1) + pr_map = torch.abs(score_prob.unsqueeze(1)-score_prob.unsqueeze(-1)) + target = -((gt_map-1)**2) + gt_map + + RCNN_loss_cls = F.cross_entropy(score, rois_label) + + margin_loss = 3 * self.triplet_loss(pr_map, gt_map, target) + + RCNN_loss_bbox = _smooth_l1_loss(bbox_pred, rois_target, rois_inside_ws, rois_outside_ws) + + cls_prob = score_prob.view(batch_size, rois.size(1), -1) + bbox_pred = bbox_pred.view(batch_size, rois.size(1), -1) + + return rois, cls_prob, bbox_pred, rpn_loss_cls, rpn_loss_bbox, RCNN_loss_cls, margin_loss, RCNN_loss_bbox, rois_label, c_weight, attention_map + + def _init_weights(self): + def normal_init(m, mean, stddev, truncated=False): + """ + weight initalizer: truncated normal and random normal. + """ + # x is a parameter + if truncated: + m.weight.data.normal_().fmod_(2).mul_(stddev).add_(mean) # not a perfect approximation + else: + m.weight.data.normal_(mean, stddev) + m.bias.data.zero_() + + normal_init(self.RCNN_rpn.RPN_Conv, 0, 0.01, cfg.TRAIN.TRUNCATED) + normal_init(self.RCNN_rpn.RPN_cls_score, 0, 0.01, cfg.TRAIN.TRUNCATED) + normal_init(self.RCNN_rpn.RPN_bbox_pred, 0, 0.01, cfg.TRAIN.TRUNCATED) + normal_init(self.RCNN_cls_score[0], 0, 0.01, cfg.TRAIN.TRUNCATED) + normal_init(self.RCNN_cls_score[1], 0, 0.01, cfg.TRAIN.TRUNCATED) + normal_init(self.RCNN_bbox_pred, 0, 0.001, cfg.TRAIN.TRUNCATED) + + def create_architecture(self): + self._init_modules() + self._init_weights() diff --git a/lib/model/faster_rcnn/resnet_oneshot.py b/lib/model/faster_rcnn/resnet_oneshot.py new file mode 100644 index 0000000..e747c4c --- /dev/null +++ b/lib/model/faster_rcnn/resnet_oneshot.py @@ -0,0 +1,357 @@ +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +from model.utils.config import cfg +from model.faster_rcnn.faster_rcnn_oneshot import _fasterRCNN + +import torch +import torch.nn as nn +import torch.nn.functional as F +from torch.autograd import Variable +import math +import torch.utils.model_zoo as model_zoo +import pdb +import copy +from torchvision import models +__all__ = ['ResNet', 'resnet18', 'resnet34', 'resnet50', 'resnet101', + 'resnet152'] + + +model_urls = { + 'resnet18': 'https://s3.amazonaws.com/pytorch/models/resnet18-5c106cde.pth', + 'resnet34': 'https://s3.amazonaws.com/pytorch/models/resnet34-333f7ec4.pth', + 'resnet50': 'https://s3.amazonaws.com/pytorch/models/resnet50-19c8e357.pth', + 'resnet101': 'https://s3.amazonaws.com/pytorch/models/resnet101-5d3b4d8f.pth', + 'resnet152': 'https://s3.amazonaws.com/pytorch/models/resnet152-b121ed2d.pth', +} + +def conv3x3(in_planes, out_planes, stride=1): + "3x3 convolution with padding" + return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride, + padding=1, bias=False) + + +class BasicBlock(nn.Module): + expansion = 1 + + def __init__(self, inplanes, planes, stride=1, downsample=None): + super(BasicBlock, self).__init__() + self.conv1 = conv3x3(inplanes, planes, stride) + self.bn1 = nn.BatchNorm2d(planes) + self.relu = nn.ReLU(inplace=True) + self.conv2 = conv3x3(planes, planes) + self.bn2 = nn.BatchNorm2d(planes) + self.downsample = downsample + self.stride = stride + + def forward(self, x): + residual = x + + out = self.conv1(x) + out = self.bn1(out) + out = self.relu(out) + + out = self.conv2(out) + out = self.bn2(out) + + if self.downsample is not None: + residual = self.downsample(x) + + out += residual + out = self.relu(out) + + return out + + +class Bottleneck(nn.Module): + expansion = 4 + + def __init__(self, inplanes, planes, stride=1, downsample=None): + super(Bottleneck, self).__init__() + self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, stride=stride, bias=False) # change + self.bn1 = nn.BatchNorm2d(planes) + self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=1, # change + padding=1, bias=False) + self.bn2 = nn.BatchNorm2d(planes) + self.conv3 = nn.Conv2d(planes, planes * 4, kernel_size=1, bias=False) + self.bn3 = nn.BatchNorm2d(planes * 4) + self.relu = nn.ReLU(inplace=True) + self.downsample = downsample + self.stride = stride + + def forward(self, x): + residual = x + + out = self.conv1(x) + out = self.bn1(out) + out = self.relu(out) + + out = self.conv2(out) + out = self.bn2(out) + out = self.relu(out) + + out = self.conv3(out) + out = self.bn3(out) + + if self.downsample is not None: + residual = self.downsample(x) + + out += residual + out = self.relu(out) + + return out + + +class ResNet(nn.Module): + def __init__(self, block, layers, num_classes=1000): + self.inplanes = 64 + super(ResNet, self).__init__() + self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, + bias=False) + self.bn1 = nn.BatchNorm2d(64) + self.relu = nn.ReLU(inplace=True) + self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=0, ceil_mode=True) # change + self.layer1 = self._make_layer(block, 64, layers[0]) + self.layer2 = self._make_layer(block, 128, layers[1], stride=2) + self.layer3 = self._make_layer(block, 256, layers[2], stride=2) + self.layer4 = self._make_layer(block, 512, layers[3], stride=2) + # it is slightly better whereas slower to set stride = 1 + # self.layer4 = self._make_layer(block, 512, layers[3], stride=1) + self.avgpool = nn.AvgPool2d(7) + self.fc = nn.Linear(512 * block.expansion, num_classes) + + for m in self.modules(): + if isinstance(m, nn.Conv2d): + n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels + m.weight.data.normal_(0, math.sqrt(2. / n)) + elif isinstance(m, nn.BatchNorm2d): + m.weight.data.fill_(1) + m.bias.data.zero_() + + def _make_layer(self, block, planes, blocks, stride=1): + downsample = None + if stride != 1 or self.inplanes != planes * block.expansion: + downsample = nn.Sequential( + nn.Conv2d(self.inplanes, planes * block.expansion, + kernel_size=1, stride=stride, bias=False), + nn.BatchNorm2d(planes * block.expansion), + ) + + layers = [] + layers.append(block(self.inplanes, planes, stride, downsample)) + self.inplanes = planes * block.expansion + for i in range(1, blocks): + layers.append(block(self.inplanes, planes)) + + return nn.Sequential(*layers) + + def forward(self, x): + x = self.conv1(x) + x = self.bn1(x) + x = self.relu(x) + x = self.maxpool(x) + + x = self.layer1(x) + x = self.layer2(x) + x = self.layer3(x) + x = self.layer4(x) + + x = self.avgpool(x) + x = x.view(x.size(0), -1) + x = self.fc(x) + + return x + + +def resnet18(pretrained=False): + """Constructs a ResNet-18 model. + Args: + pretrained (bool): If True, returns a model pre-trained on ImageNet + """ + model = ResNet(BasicBlock, [2, 2, 2, 2]) + if pretrained: + model.load_state_dict(model_zoo.load_url(model_urls['resnet18'])) + return model + + +def resnet34(pretrained=False): + """Constructs a ResNet-34 model. + Args: + pretrained (bool): If True, returns a model pre-trained on ImageNet + """ + model = ResNet(BasicBlock, [3, 4, 6, 3]) + if pretrained: + model.load_state_dict(model_zoo.load_url(model_urls['resnet34'])) + return model + + +def resnet50(pretrained=False): + """Constructs a ResNet-50 model. + Args: + pretrained (bool): If True, returns a model pre-trained on ImageNet + """ + model = ResNet(Bottleneck, [3, 4, 6, 3]) + if pretrained: + model.load_state_dict(model_zoo.load_url(model_urls['resnet50'])) + return model + + +def resnet101(pretrained=False): + """Constructs a ResNet-101 model. + Args: + pretrained (bool): If True, returns a model pre-trained on ImageNet + """ + model = ResNet(Bottleneck, [3, 4, 23, 3]) + if pretrained: + model.load_state_dict(model_zoo.load_url(model_urls['resnet101'])) + return model + + +def resnet152(pretrained=False): + """Constructs a ResNet-152 model. + Args: + pretrained (bool): If True, returns a model pre-trained on ImageNet + """ + model = ResNet(Bottleneck, [3, 8, 36, 3]) + if pretrained: + model.load_state_dict(model_zoo.load_url(model_urls['resnet152'])) + return model + +class sketch_embedding(nn.Module): + def __init__(self): + super(sketch_embedding, self).__init__() + self.requires_grad = True + self.model = models.resnet50(pretrained=False) + num_fltrs = self.model.fc.in_features + # self.model.fc = nn.Linear(num_fltrs, 331) + self.model.fc = nn.Linear(num_fltrs, 328) + self.base_layer = nn.Sequential(*list(self.model.children())[:-1]) + for param in self.base_layer.parameters(): + param.requires_grad = self.requires_grad + + self.RCNN_base_sketch = nn.Sequential(self.model.conv1, self.model.bn1, self.model.relu, + self.model.maxpool,self.model.layer1,self.model.layer2,self.model.layer3) + # self.RCNN_top = nn.Sequential(self.model.layer4) # commented for older model + + #num_filters = self.model.fc.in_features + #self.model.fc = nn.Linear(num_filters, self.num_classes) + def forward(self, x): + x = self.base_layer(x) + x = x.view(x.size(0), -1) + return x + def get_activation_map(self, x): + x = self.base_layer[0](x) + act_map = self.base_layer[1](x) + act = self.base_layer[2](act_map) + return act, act_map + +class GetSketchEmbedding(nn.Module): + def __init__(self): + super(GetSketchEmbedding, self).__init__() + self.sketch_embedd = sketch_embedding() + self.RCNN_base_sketch = self.sketch_embedd.RCNN_base_sketch + self.sketch_embedd.load_state_dict(torch.load('../data/pretrained_coco-qkdraw_res50.pth', map_location="cuda:0"), strict=False) + self.fc = nn.Linear(2048, 2048, bias=True) + + def forward(self, sketch): + sketch = self.sketch_embedd(sketch) + sketch = self.fc(sketch) + sketch = sketch / torch.norm(sketch, p=2, dim=1, keepdim=True).expand_as(sketch) + return sketch + +class resnet(_fasterRCNN): + def __init__(self, classes, num_layers=101, pretrained=False, class_agnostic=False, model_type="basic_model"): + if num_layers==50: + self.model_path = '../data/pretrain_imagenet_resnet50/model_best.pth.tar' + elif num_layers==101: + self.model_path = '../data/pretrain_imagenet_resnet101/model_best.pth.tar' + self.dout_base_model = 1024 + self.pretrained = pretrained + self.class_agnostic = class_agnostic + self.num_layers = num_layers + + _fasterRCNN.__init__(self, classes, class_agnostic, model_type) + self.get_sketch_embedding = GetSketchEmbedding() # Uncomment for sketch model + + def _init_modules(self): + if self.num_layers==50: + resnet = resnet50() + else: + resnet = resnet101() + + if self.pretrained == True: + print("Loading pretrained weights from %s" %(self.model_path)) + state_dict = torch.load(self.model_path) + state_dict = state_dict['state_dict'] + + state_dict_v2 = copy.deepcopy(state_dict) + + for key in state_dict: + pre, post = key.split('module.') + state_dict_v2[post] = state_dict_v2.pop(key) + + resnet.load_state_dict(state_dict_v2) + + # Build resnet. + self.RCNN_base = nn.Sequential(resnet.conv1, resnet.bn1,resnet.relu, + resnet.maxpool,resnet.layer1,resnet.layer2,resnet.layer3) + self.RCNN_base_sketch = self.get_sketch_embedding.RCNN_base_sketch + + self.RCNN_top = nn.Sequential(resnet.layer4) + + + self.RCNN_cls_score = nn.Sequential( + nn.Linear(2048*2, 8), + nn.Linear(8, 2) + ) + + if self.class_agnostic: + self.RCNN_bbox_pred = nn.Linear(2048, 4) + else: + self.RCNN_bbox_pred = nn.Linear(2048, 4 * self.n_classes) + + # Fix blocks + for p in self.RCNN_base[0].parameters(): p.requires_grad=False + for p in self.RCNN_base[1].parameters(): p.requires_grad=False + + assert (0 <= cfg.RESNET.FIXED_BLOCKS < 4) + if cfg.RESNET.FIXED_BLOCKS >= 3: + for p in self.RCNN_base[6].parameters(): p.requires_grad=False + if cfg.RESNET.FIXED_BLOCKS >= 2: + for p in self.RCNN_base[5].parameters(): p.requires_grad=False + if cfg.RESNET.FIXED_BLOCKS >= 1: + for p in self.RCNN_base[4].parameters(): p.requires_grad=False + + def set_bn_fix(m): + classname = m.__class__.__name__ + if classname.find('BatchNorm') != -1: + for p in m.parameters(): p.requires_grad=False + + self.RCNN_base.apply(set_bn_fix) + self.RCNN_top.apply(set_bn_fix) + + + def train(self, mode=True): + nn.Module.train(self, mode) + if mode: + # Set fixed blocks to be in eval mode + self.RCNN_base.eval() + self.RCNN_base[5].train() + self.RCNN_base[6].train() + + def set_bn_eval(m): + classname = m.__class__.__name__ + if classname.find('BatchNorm') != -1: + m.eval() + + self.RCNN_base.apply(set_bn_eval) + self.RCNN_top.apply(set_bn_eval) + # self.get_sketch_embedding.RCNN_top_sketch.apply(set_bn_eval) # Commented for older experiment + + def _head_to_tail(self, pool5): + fc7 = self.RCNN_top(pool5).mean(3).mean(2) + return fc7 + def _head_to_tail_sketch(self, pool5): + fc7 = self.get_sketch_embedding.RCNN_top_sketch(pool5).mean(3).mean(2) + return fc7 diff --git a/lib/model/faster_rcnn/vgg16.py b/lib/model/faster_rcnn/vgg16.py new file mode 100644 index 0000000..90fe0d7 --- /dev/null +++ b/lib/model/faster_rcnn/vgg16.py @@ -0,0 +1,62 @@ +# -------------------------------------------------------- +# Tensorflow Faster R-CNN +# Licensed under The MIT License [see LICENSE for details] +# Written by Xinlei Chen +# -------------------------------------------------------- +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +import torch +import torch.nn as nn +import torch.nn.functional as F +from torch.autograd import Variable +import math +import torchvision.models as models +from model.faster_rcnn.faster_rcnn import _fasterRCNN +import pdb + +class vgg16(_fasterRCNN): + def __init__(self, classes, pretrained=False, class_agnostic=False): + self.model_path = 'data/pretrained_model/vgg16_caffe.pth' + self.dout_base_model = 512 + self.pretrained = pretrained + self.class_agnostic = class_agnostic + + _fasterRCNN.__init__(self, classes, class_agnostic) + + def _init_modules(self): + vgg = models.vgg16() + if self.pretrained: + print("Loading pretrained weights from %s" %(self.model_path)) + state_dict = torch.load(self.model_path) + vgg.load_state_dict({k:v for k,v in state_dict.items() if k in vgg.state_dict()}) + + vgg.classifier = nn.Sequential(*list(vgg.classifier._modules.values())[:-1]) + + # not using the last maxpool layer + self.RCNN_base = nn.Sequential(*list(vgg.features._modules.values())[:-1]) + + # Fix the layers before conv3: + for layer in range(10): + for p in self.RCNN_base[layer].parameters(): p.requires_grad = False + + # self.RCNN_base = _RCNN_base(vgg.features, self.classes, self.dout_base_model) + + self.RCNN_top = vgg.classifier + + # not using the last maxpool layer + self.RCNN_cls_score = nn.Linear(4096, self.n_classes) + + if self.class_agnostic: + self.RCNN_bbox_pred = nn.Linear(4096, 4) + else: + self.RCNN_bbox_pred = nn.Linear(4096, 4 * self.n_classes) + + def _head_to_tail(self, pool5): + + pool5_flat = pool5.view(pool5.size(0), -1) + fc7 = self.RCNN_top(pool5_flat) + + return fc7 + diff --git a/lib/model/nms/.gitignore b/lib/model/nms/.gitignore new file mode 100644 index 0000000..15a165d --- /dev/null +++ b/lib/model/nms/.gitignore @@ -0,0 +1,3 @@ +*.c +*.cpp +*.so diff --git a/lib/model/nms/__init__.py b/lib/model/nms/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/lib/model/nms/_ext/__init__.py b/lib/model/nms/_ext/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/lib/model/nms/_ext/nms/__init__.py b/lib/model/nms/_ext/nms/__init__.py new file mode 100644 index 0000000..d71786f --- /dev/null +++ b/lib/model/nms/_ext/nms/__init__.py @@ -0,0 +1,15 @@ + +from torch.utils.ffi import _wrap_function +from ._nms import lib as _lib, ffi as _ffi + +__all__ = [] +def _import_symbols(locals): + for symbol in dir(_lib): + fn = getattr(_lib, symbol) + if callable(fn): + locals[symbol] = _wrap_function(fn, _ffi) + else: + locals[symbol] = fn + __all__.append(symbol) + +_import_symbols(locals()) diff --git a/lib/model/nms/build.py b/lib/model/nms/build.py new file mode 100644 index 0000000..4f0a665 --- /dev/null +++ b/lib/model/nms/build.py @@ -0,0 +1,37 @@ +from __future__ import print_function +import os +import torch +from torch.utils.ffi import create_extension + +#this_file = os.path.dirname(__file__) + +sources = [] +headers = [] +defines = [] +with_cuda = False + +if torch.cuda.is_available(): + print('Including CUDA code.') + sources += ['src/nms_cuda.c'] + headers += ['src/nms_cuda.h'] + defines += [('WITH_CUDA', None)] + with_cuda = True + +this_file = os.path.dirname(os.path.realpath(__file__)) +print(this_file) +extra_objects = ['src/nms_cuda_kernel.cu.o'] +extra_objects = [os.path.join(this_file, fname) for fname in extra_objects] +print(extra_objects) + +ffi = create_extension( + '_ext.nms', + headers=headers, + sources=sources, + define_macros=defines, + relative_to=__file__, + with_cuda=with_cuda, + extra_objects=extra_objects +) + +if __name__ == '__main__': + ffi.build() diff --git a/lib/model/nms/make.sh b/lib/model/nms/make.sh new file mode 100644 index 0000000..07c8f3e --- /dev/null +++ b/lib/model/nms/make.sh @@ -0,0 +1,10 @@ +#!/usr/bin/env bash + +# CUDA_PATH=/usr/local/cuda/ + +cd src +echo "Compiling stnm kernels by nvcc..." +nvcc -c -o nms_cuda_kernel.cu.o nms_cuda_kernel.cu -x cu -Xcompiler -fPIC -arch=sm_52 + +cd ../ +python build.py diff --git a/lib/model/nms/nms_cpu.py b/lib/model/nms/nms_cpu.py new file mode 100644 index 0000000..795641d --- /dev/null +++ b/lib/model/nms/nms_cpu.py @@ -0,0 +1,36 @@ +from __future__ import absolute_import + +import numpy as np +import torch + +def nms_cpu(dets, thresh): + dets = dets.numpy() + x1 = dets[:, 0] + y1 = dets[:, 1] + x2 = dets[:, 2] + y2 = dets[:, 3] + scores = dets[:, 4] + + areas = (x2 - x1 + 1) * (y2 - y1 + 1) + order = scores.argsort()[::-1] + + keep = [] + while order.size > 0: + i = order.item(0) + keep.append(i) + xx1 = np.maximum(x1[i], x1[order[1:]]) + yy1 = np.maximum(y1[i], y1[order[1:]]) + xx2 = np.maximum(x2[i], x2[order[1:]]) + yy2 = np.maximum(y2[i], y2[order[1:]]) + + w = np.maximum(0.0, xx2 - xx1 + 1) + h = np.maximum(0.0, yy2 - yy1 + 1) + inter = w * h + ovr = inter / (areas[i] + areas[order[1:]] - inter) + + inds = np.where(ovr <= thresh)[0] + order = order[inds + 1] + + return torch.IntTensor(keep) + + diff --git a/lib/model/nms/nms_gpu.py b/lib/model/nms/nms_gpu.py new file mode 100644 index 0000000..4134c9d --- /dev/null +++ b/lib/model/nms/nms_gpu.py @@ -0,0 +1,12 @@ +from __future__ import absolute_import +import torch +import numpy as np +from ._ext import nms +import pdb + +def nms_gpu(dets, thresh): + keep = dets.new(dets.size(0), 1).zero_().int() + num_out = dets.new(1).zero_().int() + nms.nms_cuda(keep, dets, num_out, thresh) + keep = keep[:num_out[0]] + return keep diff --git a/lib/model/nms/nms_kernel.cu b/lib/model/nms/nms_kernel.cu new file mode 100644 index 0000000..038a590 --- /dev/null +++ b/lib/model/nms/nms_kernel.cu @@ -0,0 +1,144 @@ +// ------------------------------------------------------------------ +// Faster R-CNN +// Copyright (c) 2015 Microsoft +// Licensed under The MIT License [see fast-rcnn/LICENSE for details] +// Written by Shaoqing Ren +// ------------------------------------------------------------------ + +#include "gpu_nms.hpp" +#include +#include + +#define CUDA_CHECK(condition) \ + /* Code block avoids redefinition of cudaError_t error */ \ + do { \ + cudaError_t error = condition; \ + if (error != cudaSuccess) { \ + std::cout << cudaGetErrorString(error) << std::endl; \ + } \ + } while (0) + +#define DIVUP(m,n) ((m) / (n) + ((m) % (n) > 0)) +int const threadsPerBlock = sizeof(unsigned long long) * 8; + +__device__ inline float devIoU(float const * const a, float const * const b) { + float left = max(a[0], b[0]), right = min(a[2], b[2]); + float top = max(a[1], b[1]), bottom = min(a[3], b[3]); + float width = max(right - left + 1, 0.f), height = max(bottom - top + 1, 0.f); + float interS = width * height; + float Sa = (a[2] - a[0] + 1) * (a[3] - a[1] + 1); + float Sb = (b[2] - b[0] + 1) * (b[3] - b[1] + 1); + return interS / (Sa + Sb - interS); +} + +__global__ void nms_kernel(const int n_boxes, const float nms_overlap_thresh, + const float *dev_boxes, unsigned long long *dev_mask) { + const int row_start = blockIdx.y; + const int col_start = blockIdx.x; + + // if (row_start > col_start) return; + + const int row_size = + min(n_boxes - row_start * threadsPerBlock, threadsPerBlock); + const int col_size = + min(n_boxes - col_start * threadsPerBlock, threadsPerBlock); + + __shared__ float block_boxes[threadsPerBlock * 5]; + if (threadIdx.x < col_size) { + block_boxes[threadIdx.x * 5 + 0] = + dev_boxes[(threadsPerBlock * col_start + threadIdx.x) * 5 + 0]; + block_boxes[threadIdx.x * 5 + 1] = + dev_boxes[(threadsPerBlock * col_start + threadIdx.x) * 5 + 1]; + block_boxes[threadIdx.x * 5 + 2] = + dev_boxes[(threadsPerBlock * col_start + threadIdx.x) * 5 + 2]; + block_boxes[threadIdx.x * 5 + 3] = + dev_boxes[(threadsPerBlock * col_start + threadIdx.x) * 5 + 3]; + block_boxes[threadIdx.x * 5 + 4] = + dev_boxes[(threadsPerBlock * col_start + threadIdx.x) * 5 + 4]; + } + __syncthreads(); + + if (threadIdx.x < row_size) { + const int cur_box_idx = threadsPerBlock * row_start + threadIdx.x; + const float *cur_box = dev_boxes + cur_box_idx * 5; + int i = 0; + unsigned long long t = 0; + int start = 0; + if (row_start == col_start) { + start = threadIdx.x + 1; + } + for (i = start; i < col_size; i++) { + if (devIoU(cur_box, block_boxes + i * 5) > nms_overlap_thresh) { + t |= 1ULL << i; + } + } + const int col_blocks = DIVUP(n_boxes, threadsPerBlock); + dev_mask[cur_box_idx * col_blocks + col_start] = t; + } +} + +void _set_device(int device_id) { + int current_device; + CUDA_CHECK(cudaGetDevice(¤t_device)); + if (current_device == device_id) { + return; + } + // The call to cudaSetDevice must come before any calls to Get, which + // may perform initialization using the GPU. + CUDA_CHECK(cudaSetDevice(device_id)); +} + +void _nms(int* keep_out, int* num_out, const float* boxes_host, int boxes_num, + int boxes_dim, float nms_overlap_thresh, int device_id) { + _set_device(device_id); + + float* boxes_dev = NULL; + unsigned long long* mask_dev = NULL; + + const int col_blocks = DIVUP(boxes_num, threadsPerBlock); + + CUDA_CHECK(cudaMalloc(&boxes_dev, + boxes_num * boxes_dim * sizeof(float))); + CUDA_CHECK(cudaMemcpy(boxes_dev, + boxes_host, + boxes_num * boxes_dim * sizeof(float), + cudaMemcpyHostToDevice)); + + CUDA_CHECK(cudaMalloc(&mask_dev, + boxes_num * col_blocks * sizeof(unsigned long long))); + + dim3 blocks(DIVUP(boxes_num, threadsPerBlock), + DIVUP(boxes_num, threadsPerBlock)); + dim3 threads(threadsPerBlock); + nms_kernel<<>>(boxes_num, + nms_overlap_thresh, + boxes_dev, + mask_dev); + + std::vector mask_host(boxes_num * col_blocks); + CUDA_CHECK(cudaMemcpy(&mask_host[0], + mask_dev, + sizeof(unsigned long long) * boxes_num * col_blocks, + cudaMemcpyDeviceToHost)); + + std::vector remv(col_blocks); + memset(&remv[0], 0, sizeof(unsigned long long) * col_blocks); + + int num_to_keep = 0; + for (int i = 0; i < boxes_num; i++) { + int nblock = i / threadsPerBlock; + int inblock = i % threadsPerBlock; + + if (!(remv[nblock] & (1ULL << inblock))) { + keep_out[num_to_keep++] = i; + unsigned long long *p = &mask_host[0] + i * col_blocks; + for (int j = nblock; j < col_blocks; j++) { + remv[j] |= p[j]; + } + } + } + *num_out = num_to_keep; + + CUDA_CHECK(cudaFree(boxes_dev)); + CUDA_CHECK(cudaFree(mask_dev)); +} diff --git a/lib/model/nms/nms_wrapper.py b/lib/model/nms/nms_wrapper.py new file mode 100644 index 0000000..5ae3660 --- /dev/null +++ b/lib/model/nms/nms_wrapper.py @@ -0,0 +1,21 @@ +# -------------------------------------------------------- +# Fast R-CNN +# Copyright (c) 2015 Microsoft +# Licensed under The MIT License [see LICENSE for details] +# Written by Ross Girshick +# -------------------------------------------------------- +import torch +from model.utils.config import cfg +if torch.cuda.is_available(): + from model.nms.nms_gpu import nms_gpu +from model.nms.nms_cpu import nms_cpu + +def nms(dets, thresh, force_cpu=False): + """Dispatch to either CPU or GPU NMS implementations.""" + if dets.shape[0] == 0: + return [] + # ---numpy version--- + # original: return gpu_nms(dets, thresh, device_id=cfg.GPU_ID) + # ---pytorch version--- + + return nms_gpu(dets, thresh) if force_cpu == False else nms_cpu(dets, thresh) diff --git a/lib/model/nms/src/nms_cuda.h b/lib/model/nms/src/nms_cuda.h new file mode 100644 index 0000000..e85559a --- /dev/null +++ b/lib/model/nms/src/nms_cuda.h @@ -0,0 +1,5 @@ +// int nms_cuda(THCudaTensor *keep_out, THCudaTensor *num_out, +// THCudaTensor *boxes_host, THCudaTensor *nms_overlap_thresh); + +int nms_cuda(THCudaIntTensor *keep_out, THCudaTensor *boxes_host, + THCudaIntTensor *num_out, float nms_overlap_thresh); diff --git a/lib/model/nms/src/nms_cuda_kernel.cu b/lib/model/nms/src/nms_cuda_kernel.cu new file mode 100644 index 0000000..d572684 --- /dev/null +++ b/lib/model/nms/src/nms_cuda_kernel.cu @@ -0,0 +1,161 @@ +// ------------------------------------------------------------------ +// Faster R-CNN +// Copyright (c) 2015 Microsoft +// Licensed under The MIT License [see fast-rcnn/LICENSE for details] +// Written by Shaoqing Ren +// ------------------------------------------------------------------ + +#include +#include +#include +#include +#include "nms_cuda_kernel.h" + +#define CUDA_WARN(XXX) \ + do { if (XXX != cudaSuccess) std::cout << "CUDA Error: " << \ + cudaGetErrorString(XXX) << ", at line " << __LINE__ \ +<< std::endl; cudaDeviceSynchronize(); } while (0) + +#define CUDA_CHECK(condition) \ + /* Code block avoids redefinition of cudaError_t error */ \ + do { \ + cudaError_t error = condition; \ + if (error != cudaSuccess) { \ + std::cout << cudaGetErrorString(error) << std::endl; \ + } \ + } while (0) + +#define DIVUP(m,n) ((m) / (n) + ((m) % (n) > 0)) +int const threadsPerBlock = sizeof(unsigned long long) * 8; + +__device__ inline float devIoU(float const * const a, float const * const b) { + float left = max(a[0], b[0]), right = min(a[2], b[2]); + float top = max(a[1], b[1]), bottom = min(a[3], b[3]); + float width = max(right - left + 1, 0.f), height = max(bottom - top + 1, 0.f); + float interS = width * height; + float Sa = (a[2] - a[0] + 1) * (a[3] - a[1] + 1); + float Sb = (b[2] - b[0] + 1) * (b[3] - b[1] + 1); + return interS / (Sa + Sb - interS); +} + +__global__ void nms_kernel(int n_boxes, float nms_overlap_thresh, + float *dev_boxes, unsigned long long *dev_mask) { + const int row_start = blockIdx.y; + const int col_start = blockIdx.x; + + // if (row_start > col_start) return; + + const int row_size = + min(n_boxes - row_start * threadsPerBlock, threadsPerBlock); + const int col_size = + min(n_boxes - col_start * threadsPerBlock, threadsPerBlock); + + __shared__ float block_boxes[threadsPerBlock * 5]; + if (threadIdx.x < col_size) { + block_boxes[threadIdx.x * 5 + 0] = + dev_boxes[(threadsPerBlock * col_start + threadIdx.x) * 5 + 0]; + block_boxes[threadIdx.x * 5 + 1] = + dev_boxes[(threadsPerBlock * col_start + threadIdx.x) * 5 + 1]; + block_boxes[threadIdx.x * 5 + 2] = + dev_boxes[(threadsPerBlock * col_start + threadIdx.x) * 5 + 2]; + block_boxes[threadIdx.x * 5 + 3] = + dev_boxes[(threadsPerBlock * col_start + threadIdx.x) * 5 + 3]; + block_boxes[threadIdx.x * 5 + 4] = + dev_boxes[(threadsPerBlock * col_start + threadIdx.x) * 5 + 4]; + } + __syncthreads(); + + if (threadIdx.x < row_size) { + const int cur_box_idx = threadsPerBlock * row_start + threadIdx.x; + const float *cur_box = dev_boxes + cur_box_idx * 5; + int i = 0; + unsigned long long t = 0; + int start = 0; + if (row_start == col_start) { + start = threadIdx.x + 1; + } + for (i = start; i < col_size; i++) { + if (devIoU(cur_box, block_boxes + i * 5) > nms_overlap_thresh) { + t |= 1ULL << i; + } + } + const int col_blocks = DIVUP(n_boxes, threadsPerBlock); + dev_mask[cur_box_idx * col_blocks + col_start] = t; + } +} + +void nms_cuda_compute(int* keep_out, int *num_out, float* boxes_host, int boxes_num, + int boxes_dim, float nms_overlap_thresh) { + + float* boxes_dev = NULL; + unsigned long long* mask_dev = NULL; + + const int col_blocks = DIVUP(boxes_num, threadsPerBlock); + + CUDA_CHECK(cudaMalloc(&boxes_dev, + boxes_num * boxes_dim * sizeof(float))); + CUDA_CHECK(cudaMemcpy(boxes_dev, + boxes_host, + boxes_num * boxes_dim * sizeof(float), + cudaMemcpyHostToDevice)); + + CUDA_CHECK(cudaMalloc(&mask_dev, + boxes_num * col_blocks * sizeof(unsigned long long))); + + dim3 blocks(DIVUP(boxes_num, threadsPerBlock), + DIVUP(boxes_num, threadsPerBlock)); + dim3 threads(threadsPerBlock); + + // printf("i am at line %d\n", boxes_num); + // printf("i am at line %d\n", boxes_dim); + + nms_kernel<<>>(boxes_num, + nms_overlap_thresh, + boxes_dev, + mask_dev); + + std::vector mask_host(boxes_num * col_blocks); + CUDA_CHECK(cudaMemcpy(&mask_host[0], + mask_dev, + sizeof(unsigned long long) * boxes_num * col_blocks, + cudaMemcpyDeviceToHost)); + + std::vector remv(col_blocks); + memset(&remv[0], 0, sizeof(unsigned long long) * col_blocks); + + // we need to create a memory for keep_out on cpu + // otherwise, the following code cannot run + + int* keep_out_cpu = new int[boxes_num]; + + int num_to_keep = 0; + for (int i = 0; i < boxes_num; i++) { + int nblock = i / threadsPerBlock; + int inblock = i % threadsPerBlock; + + if (!(remv[nblock] & (1ULL << inblock))) { + // orignal: keep_out[num_to_keep++] = i; + keep_out_cpu[num_to_keep++] = i; + unsigned long long *p = &mask_host[0] + i * col_blocks; + for (int j = nblock; j < col_blocks; j++) { + remv[j] |= p[j]; + } + } + } + + // copy keep_out_cpu to keep_out on gpu + CUDA_WARN(cudaMemcpy(keep_out, keep_out_cpu, boxes_num * sizeof(int),cudaMemcpyHostToDevice)); + + // *num_out = num_to_keep; + + // original: *num_out = num_to_keep; + // copy num_to_keep to num_out on gpu + + CUDA_WARN(cudaMemcpy(num_out, &num_to_keep, 1 * sizeof(int),cudaMemcpyHostToDevice)); + + // release cuda memory + CUDA_CHECK(cudaFree(boxes_dev)); + CUDA_CHECK(cudaFree(mask_dev)); + // release cpu memory + delete []keep_out_cpu; +} diff --git a/lib/model/nms/src/nms_cuda_kernel.h b/lib/model/nms/src/nms_cuda_kernel.h new file mode 100644 index 0000000..ae6f83e --- /dev/null +++ b/lib/model/nms/src/nms_cuda_kernel.h @@ -0,0 +1,10 @@ +#ifdef __cplusplus +extern "C" { +#endif + +void nms_cuda_compute(int* keep_out, int *num_out, float* boxes_host, int boxes_num, + int boxes_dim, float nms_overlap_thresh); + +#ifdef __cplusplus +} +#endif diff --git a/lib/model/roi_align/__init__.py b/lib/model/roi_align/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/lib/model/roi_align/_ext/__init__.py b/lib/model/roi_align/_ext/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/lib/model/roi_align/_ext/roi_align/__init__.py b/lib/model/roi_align/_ext/roi_align/__init__.py new file mode 100644 index 0000000..c5b6e5d --- /dev/null +++ b/lib/model/roi_align/_ext/roi_align/__init__.py @@ -0,0 +1,15 @@ + +from torch.utils.ffi import _wrap_function +from ._roi_align import lib as _lib, ffi as _ffi + +__all__ = [] +def _import_symbols(locals): + for symbol in dir(_lib): + fn = getattr(_lib, symbol) + if callable(fn): + locals[symbol] = _wrap_function(fn, _ffi) + else: + locals[symbol] = fn + __all__.append(symbol) + +_import_symbols(locals()) diff --git a/lib/model/roi_align/build.py b/lib/model/roi_align/build.py new file mode 100644 index 0000000..79f9586 --- /dev/null +++ b/lib/model/roi_align/build.py @@ -0,0 +1,38 @@ +from __future__ import print_function +import os +import torch +from torch.utils.ffi import create_extension + +sources = ['src/roi_align.c'] +headers = ['src/roi_align.h'] +extra_objects = [] +#sources = [] +#headers = [] +defines = [] +with_cuda = False + +this_file = os.path.dirname(os.path.realpath(__file__)) +print(this_file) + +if torch.cuda.is_available(): + print('Including CUDA code.') + sources += ['src/roi_align_cuda.c'] + headers += ['src/roi_align_cuda.h'] + defines += [('WITH_CUDA', None)] + with_cuda = True + + extra_objects = ['src/roi_align_kernel.cu.o'] + extra_objects = [os.path.join(this_file, fname) for fname in extra_objects] + +ffi = create_extension( + '_ext.roi_align', + headers=headers, + sources=sources, + define_macros=defines, + relative_to=__file__, + with_cuda=with_cuda, + extra_objects=extra_objects +) + +if __name__ == '__main__': + ffi.build() diff --git a/lib/model/roi_align/functions/__init__.py b/lib/model/roi_align/functions/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/lib/model/roi_align/functions/roi_align.py b/lib/model/roi_align/functions/roi_align.py new file mode 100644 index 0000000..bf1d2e1 --- /dev/null +++ b/lib/model/roi_align/functions/roi_align.py @@ -0,0 +1,51 @@ +import torch +from torch.autograd import Function +from .._ext import roi_align + + +# TODO use save_for_backward instead +class RoIAlignFunction(Function): + def __init__(self, aligned_height, aligned_width, spatial_scale): + self.aligned_width = int(aligned_width) + self.aligned_height = int(aligned_height) + self.spatial_scale = float(spatial_scale) + self.rois = None + self.feature_size = None + + def forward(self, features, rois): + self.rois = rois + self.feature_size = features.size() + + batch_size, num_channels, data_height, data_width = features.size() + num_rois = rois.size(0) + + output = features.new(num_rois, num_channels, self.aligned_height, self.aligned_width).zero_() + if features.is_cuda: + roi_align.roi_align_forward_cuda(self.aligned_height, + self.aligned_width, + self.spatial_scale, features, + rois, output) + else: + roi_align.roi_align_forward(self.aligned_height, + self.aligned_width, + self.spatial_scale, features, + rois, output) +# raise NotImplementedError + + return output + + def backward(self, grad_output): + assert(self.feature_size is not None and grad_output.is_cuda) + + batch_size, num_channels, data_height, data_width = self.feature_size + + grad_input = self.rois.new(batch_size, num_channels, data_height, + data_width).zero_() + roi_align.roi_align_backward_cuda(self.aligned_height, + self.aligned_width, + self.spatial_scale, grad_output, + self.rois, grad_input) + + # print grad_input + + return grad_input, None diff --git a/lib/model/roi_align/make.sh b/lib/model/roi_align/make.sh new file mode 100644 index 0000000..49b80b7 --- /dev/null +++ b/lib/model/roi_align/make.sh @@ -0,0 +1,10 @@ +#!/usr/bin/env bash + +CUDA_PATH=/usr/local/cuda/ + +cd src +echo "Compiling my_lib kernels by nvcc..." +nvcc -c -o roi_align_kernel.cu.o roi_align_kernel.cu -x cu -Xcompiler -fPIC -arch=sm_52 + +cd ../ +python build.py diff --git a/lib/model/roi_align/modules/__init__.py b/lib/model/roi_align/modules/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/lib/model/roi_align/modules/roi_align.py b/lib/model/roi_align/modules/roi_align.py new file mode 100644 index 0000000..ca02e3b --- /dev/null +++ b/lib/model/roi_align/modules/roi_align.py @@ -0,0 +1,42 @@ +from torch.nn.modules.module import Module +from torch.nn.functional import avg_pool2d, max_pool2d +from ..functions.roi_align import RoIAlignFunction + + +class RoIAlign(Module): + def __init__(self, aligned_height, aligned_width, spatial_scale): + super(RoIAlign, self).__init__() + + self.aligned_width = int(aligned_width) + self.aligned_height = int(aligned_height) + self.spatial_scale = float(spatial_scale) + + def forward(self, features, rois): + return RoIAlignFunction(self.aligned_height, self.aligned_width, + self.spatial_scale)(features, rois) + +class RoIAlignAvg(Module): + def __init__(self, aligned_height, aligned_width, spatial_scale): + super(RoIAlignAvg, self).__init__() + + self.aligned_width = int(aligned_width) + self.aligned_height = int(aligned_height) + self.spatial_scale = float(spatial_scale) + + def forward(self, features, rois): + x = RoIAlignFunction(self.aligned_height+1, self.aligned_width+1, + self.spatial_scale)(features, rois) + return avg_pool2d(x, kernel_size=2, stride=1) + +class RoIAlignMax(Module): + def __init__(self, aligned_height, aligned_width, spatial_scale): + super(RoIAlignMax, self).__init__() + + self.aligned_width = int(aligned_width) + self.aligned_height = int(aligned_height) + self.spatial_scale = float(spatial_scale) + + def forward(self, features, rois): + x = RoIAlignFunction(self.aligned_height+1, self.aligned_width+1, + self.spatial_scale)(features, rois) + return max_pool2d(x, kernel_size=2, stride=1) diff --git a/lib/model/roi_align/src/roi_align.c b/lib/model/roi_align/src/roi_align.c new file mode 100644 index 0000000..a4b357a --- /dev/null +++ b/lib/model/roi_align/src/roi_align.c @@ -0,0 +1,190 @@ +#include +#include +#include + + +void ROIAlignForwardCpu(const float* bottom_data, const float spatial_scale, const int num_rois, + const int height, const int width, const int channels, + const int aligned_height, const int aligned_width, const float * bottom_rois, + float* top_data); + +void ROIAlignBackwardCpu(const float* top_diff, const float spatial_scale, const int num_rois, + const int height, const int width, const int channels, + const int aligned_height, const int aligned_width, const float * bottom_rois, + float* top_data); + +int roi_align_forward(int aligned_height, int aligned_width, float spatial_scale, + THFloatTensor * features, THFloatTensor * rois, THFloatTensor * output) +{ + //Grab the input tensor + float * data_flat = THFloatTensor_data(features); + float * rois_flat = THFloatTensor_data(rois); + + float * output_flat = THFloatTensor_data(output); + + // Number of ROIs + int num_rois = THFloatTensor_size(rois, 0); + int size_rois = THFloatTensor_size(rois, 1); + if (size_rois != 5) + { + return 0; + } + + // data height + int data_height = THFloatTensor_size(features, 2); + // data width + int data_width = THFloatTensor_size(features, 3); + // Number of channels + int num_channels = THFloatTensor_size(features, 1); + + // do ROIAlignForward + ROIAlignForwardCpu(data_flat, spatial_scale, num_rois, data_height, data_width, num_channels, + aligned_height, aligned_width, rois_flat, output_flat); + + return 1; +} + +int roi_align_backward(int aligned_height, int aligned_width, float spatial_scale, + THFloatTensor * top_grad, THFloatTensor * rois, THFloatTensor * bottom_grad) +{ + //Grab the input tensor + float * top_grad_flat = THFloatTensor_data(top_grad); + float * rois_flat = THFloatTensor_data(rois); + + float * bottom_grad_flat = THFloatTensor_data(bottom_grad); + + // Number of ROIs + int num_rois = THFloatTensor_size(rois, 0); + int size_rois = THFloatTensor_size(rois, 1); + if (size_rois != 5) + { + return 0; + } + + // batch size + // int batch_size = THFloatTensor_size(bottom_grad, 0); + // data height + int data_height = THFloatTensor_size(bottom_grad, 2); + // data width + int data_width = THFloatTensor_size(bottom_grad, 3); + // Number of channels + int num_channels = THFloatTensor_size(bottom_grad, 1); + + // do ROIAlignBackward + ROIAlignBackwardCpu(top_grad_flat, spatial_scale, num_rois, data_height, + data_width, num_channels, aligned_height, aligned_width, rois_flat, bottom_grad_flat); + + return 1; +} + +void ROIAlignForwardCpu(const float* bottom_data, const float spatial_scale, const int num_rois, + const int height, const int width, const int channels, + const int aligned_height, const int aligned_width, const float * bottom_rois, + float* top_data) +{ + const int output_size = num_rois * aligned_height * aligned_width * channels; + + int idx = 0; + for (idx = 0; idx < output_size; ++idx) + { + // (n, c, ph, pw) is an element in the aligned output + int pw = idx % aligned_width; + int ph = (idx / aligned_width) % aligned_height; + int c = (idx / aligned_width / aligned_height) % channels; + int n = idx / aligned_width / aligned_height / channels; + + float roi_batch_ind = bottom_rois[n * 5 + 0]; + float roi_start_w = bottom_rois[n * 5 + 1] * spatial_scale; + float roi_start_h = bottom_rois[n * 5 + 2] * spatial_scale; + float roi_end_w = bottom_rois[n * 5 + 3] * spatial_scale; + float roi_end_h = bottom_rois[n * 5 + 4] * spatial_scale; + + // Force malformed ROI to be 1x1 + float roi_width = fmaxf(roi_end_w - roi_start_w + 1., 0.); + float roi_height = fmaxf(roi_end_h - roi_start_h + 1., 0.); + float bin_size_h = roi_height / (aligned_height - 1.); + float bin_size_w = roi_width / (aligned_width - 1.); + + float h = (float)(ph) * bin_size_h + roi_start_h; + float w = (float)(pw) * bin_size_w + roi_start_w; + + int hstart = fminf(floor(h), height - 2); + int wstart = fminf(floor(w), width - 2); + + int img_start = roi_batch_ind * channels * height * width; + + // bilinear interpolation + if (h < 0 || h >= height || w < 0 || w >= width) + { + top_data[idx] = 0.; + } + else + { + float h_ratio = h - (float)(hstart); + float w_ratio = w - (float)(wstart); + int upleft = img_start + (c * height + hstart) * width + wstart; + int upright = upleft + 1; + int downleft = upleft + width; + int downright = downleft + 1; + + top_data[idx] = bottom_data[upleft] * (1. - h_ratio) * (1. - w_ratio) + + bottom_data[upright] * (1. - h_ratio) * w_ratio + + bottom_data[downleft] * h_ratio * (1. - w_ratio) + + bottom_data[downright] * h_ratio * w_ratio; + } + } +} + +void ROIAlignBackwardCpu(const float* top_diff, const float spatial_scale, const int num_rois, + const int height, const int width, const int channels, + const int aligned_height, const int aligned_width, const float * bottom_rois, + float* bottom_diff) +{ + const int output_size = num_rois * aligned_height * aligned_width * channels; + + int idx = 0; + for (idx = 0; idx < output_size; ++idx) + { + // (n, c, ph, pw) is an element in the aligned output + int pw = idx % aligned_width; + int ph = (idx / aligned_width) % aligned_height; + int c = (idx / aligned_width / aligned_height) % channels; + int n = idx / aligned_width / aligned_height / channels; + + float roi_batch_ind = bottom_rois[n * 5 + 0]; + float roi_start_w = bottom_rois[n * 5 + 1] * spatial_scale; + float roi_start_h = bottom_rois[n * 5 + 2] * spatial_scale; + float roi_end_w = bottom_rois[n * 5 + 3] * spatial_scale; + float roi_end_h = bottom_rois[n * 5 + 4] * spatial_scale; + + // Force malformed ROI to be 1x1 + float roi_width = fmaxf(roi_end_w - roi_start_w + 1., 0.); + float roi_height = fmaxf(roi_end_h - roi_start_h + 1., 0.); + float bin_size_h = roi_height / (aligned_height - 1.); + float bin_size_w = roi_width / (aligned_width - 1.); + + float h = (float)(ph) * bin_size_h + roi_start_h; + float w = (float)(pw) * bin_size_w + roi_start_w; + + int hstart = fminf(floor(h), height - 2); + int wstart = fminf(floor(w), width - 2); + + int img_start = roi_batch_ind * channels * height * width; + + // bilinear interpolation + if (h < 0 || h >= height || w < 0 || w >= width) + { + float h_ratio = h - (float)(hstart); + float w_ratio = w - (float)(wstart); + int upleft = img_start + (c * height + hstart) * width + wstart; + int upright = upleft + 1; + int downleft = upleft + width; + int downright = downleft + 1; + + bottom_diff[upleft] += top_diff[idx] * (1. - h_ratio) * (1. - w_ratio); + bottom_diff[upright] += top_diff[idx] * (1. - h_ratio) * w_ratio; + bottom_diff[downleft] += top_diff[idx] * h_ratio * (1. - w_ratio); + bottom_diff[downright] += top_diff[idx] * h_ratio * w_ratio; + } + } +} diff --git a/lib/model/roi_align/src/roi_align.h b/lib/model/roi_align/src/roi_align.h new file mode 100644 index 0000000..118495d --- /dev/null +++ b/lib/model/roi_align/src/roi_align.h @@ -0,0 +1,5 @@ +int roi_align_forward(int aligned_height, int aligned_width, float spatial_scale, + THFloatTensor * features, THFloatTensor * rois, THFloatTensor * output); + +int roi_align_backward(int aligned_height, int aligned_width, float spatial_scale, + THFloatTensor * top_grad, THFloatTensor * rois, THFloatTensor * bottom_grad); diff --git a/lib/model/roi_align/src/roi_align_cuda.c b/lib/model/roi_align/src/roi_align_cuda.c new file mode 100644 index 0000000..0644fc6 --- /dev/null +++ b/lib/model/roi_align/src/roi_align_cuda.c @@ -0,0 +1,76 @@ +#include +#include +#include "roi_align_kernel.h" + +extern THCState *state; + +int roi_align_forward_cuda(int aligned_height, int aligned_width, float spatial_scale, + THCudaTensor * features, THCudaTensor * rois, THCudaTensor * output) +{ + // Grab the input tensor + float * data_flat = THCudaTensor_data(state, features); + float * rois_flat = THCudaTensor_data(state, rois); + + float * output_flat = THCudaTensor_data(state, output); + + // Number of ROIs + int num_rois = THCudaTensor_size(state, rois, 0); + int size_rois = THCudaTensor_size(state, rois, 1); + if (size_rois != 5) + { + return 0; + } + + // data height + int data_height = THCudaTensor_size(state, features, 2); + // data width + int data_width = THCudaTensor_size(state, features, 3); + // Number of channels + int num_channels = THCudaTensor_size(state, features, 1); + + cudaStream_t stream = THCState_getCurrentStream(state); + + ROIAlignForwardLaucher( + data_flat, spatial_scale, num_rois, data_height, + data_width, num_channels, aligned_height, + aligned_width, rois_flat, + output_flat, stream); + + return 1; +} + +int roi_align_backward_cuda(int aligned_height, int aligned_width, float spatial_scale, + THCudaTensor * top_grad, THCudaTensor * rois, THCudaTensor * bottom_grad) +{ + // Grab the input tensor + float * top_grad_flat = THCudaTensor_data(state, top_grad); + float * rois_flat = THCudaTensor_data(state, rois); + + float * bottom_grad_flat = THCudaTensor_data(state, bottom_grad); + + // Number of ROIs + int num_rois = THCudaTensor_size(state, rois, 0); + int size_rois = THCudaTensor_size(state, rois, 1); + if (size_rois != 5) + { + return 0; + } + + // batch size + int batch_size = THCudaTensor_size(state, bottom_grad, 0); + // data height + int data_height = THCudaTensor_size(state, bottom_grad, 2); + // data width + int data_width = THCudaTensor_size(state, bottom_grad, 3); + // Number of channels + int num_channels = THCudaTensor_size(state, bottom_grad, 1); + + cudaStream_t stream = THCState_getCurrentStream(state); + ROIAlignBackwardLaucher( + top_grad_flat, spatial_scale, batch_size, num_rois, data_height, + data_width, num_channels, aligned_height, + aligned_width, rois_flat, + bottom_grad_flat, stream); + + return 1; +} diff --git a/lib/model/roi_align/src/roi_align_cuda.h b/lib/model/roi_align/src/roi_align_cuda.h new file mode 100644 index 0000000..97bd08d --- /dev/null +++ b/lib/model/roi_align/src/roi_align_cuda.h @@ -0,0 +1,5 @@ +int roi_align_forward_cuda(int aligned_height, int aligned_width, float spatial_scale, + THCudaTensor * features, THCudaTensor * rois, THCudaTensor * output); + +int roi_align_backward_cuda(int aligned_height, int aligned_width, float spatial_scale, + THCudaTensor * top_grad, THCudaTensor * rois, THCudaTensor * bottom_grad); diff --git a/lib/model/roi_align/src/roi_align_kernel.cu b/lib/model/roi_align/src/roi_align_kernel.cu new file mode 100644 index 0000000..1ddc6bc --- /dev/null +++ b/lib/model/roi_align/src/roi_align_kernel.cu @@ -0,0 +1,167 @@ +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include +#include +#include "roi_align_kernel.h" + +#define CUDA_1D_KERNEL_LOOP(i, n) \ + for (int i = blockIdx.x * blockDim.x + threadIdx.x; i < n; \ + i += blockDim.x * gridDim.x) + + + __global__ void ROIAlignForward(const int nthreads, const float* bottom_data, const float spatial_scale, const int height, const int width, + const int channels, const int aligned_height, const int aligned_width, const float* bottom_rois, float* top_data) { + CUDA_1D_KERNEL_LOOP(index, nthreads) { + // (n, c, ph, pw) is an element in the aligned output + // int n = index; + // int pw = n % aligned_width; + // n /= aligned_width; + // int ph = n % aligned_height; + // n /= aligned_height; + // int c = n % channels; + // n /= channels; + + int pw = index % aligned_width; + int ph = (index / aligned_width) % aligned_height; + int c = (index / aligned_width / aligned_height) % channels; + int n = index / aligned_width / aligned_height / channels; + + // bottom_rois += n * 5; + float roi_batch_ind = bottom_rois[n * 5 + 0]; + float roi_start_w = bottom_rois[n * 5 + 1] * spatial_scale; + float roi_start_h = bottom_rois[n * 5 + 2] * spatial_scale; + float roi_end_w = bottom_rois[n * 5 + 3] * spatial_scale; + float roi_end_h = bottom_rois[n * 5 + 4] * spatial_scale; + + // Force malformed ROIs to be 1x1 + float roi_width = fmaxf(roi_end_w - roi_start_w + 1., 0.); + float roi_height = fmaxf(roi_end_h - roi_start_h + 1., 0.); + float bin_size_h = roi_height / (aligned_height - 1.); + float bin_size_w = roi_width / (aligned_width - 1.); + + float h = (float)(ph) * bin_size_h + roi_start_h; + float w = (float)(pw) * bin_size_w + roi_start_w; + + int hstart = fminf(floor(h), height - 2); + int wstart = fminf(floor(w), width - 2); + + int img_start = roi_batch_ind * channels * height * width; + + // bilinear interpolation + if (h < 0 || h >= height || w < 0 || w >= width) { + top_data[index] = 0.; + } else { + float h_ratio = h - (float)(hstart); + float w_ratio = w - (float)(wstart); + int upleft = img_start + (c * height + hstart) * width + wstart; + int upright = upleft + 1; + int downleft = upleft + width; + int downright = downleft + 1; + + top_data[index] = bottom_data[upleft] * (1. - h_ratio) * (1. - w_ratio) + + bottom_data[upright] * (1. - h_ratio) * w_ratio + + bottom_data[downleft] * h_ratio * (1. - w_ratio) + + bottom_data[downright] * h_ratio * w_ratio; + } + } + } + + + int ROIAlignForwardLaucher(const float* bottom_data, const float spatial_scale, const int num_rois, const int height, const int width, + const int channels, const int aligned_height, const int aligned_width, const float* bottom_rois, float* top_data, cudaStream_t stream) { + const int kThreadsPerBlock = 1024; + const int output_size = num_rois * aligned_height * aligned_width * channels; + cudaError_t err; + + + ROIAlignForward<<<(output_size + kThreadsPerBlock - 1) / kThreadsPerBlock, kThreadsPerBlock, 0, stream>>>( + output_size, bottom_data, spatial_scale, height, width, channels, + aligned_height, aligned_width, bottom_rois, top_data); + + err = cudaGetLastError(); + if(cudaSuccess != err) { + fprintf( stderr, "cudaCheckError() failed : %s\n", cudaGetErrorString( err ) ); + exit( -1 ); + } + + return 1; + } + + + __global__ void ROIAlignBackward(const int nthreads, const float* top_diff, const float spatial_scale, const int height, const int width, + const int channels, const int aligned_height, const int aligned_width, float* bottom_diff, const float* bottom_rois) { + CUDA_1D_KERNEL_LOOP(index, nthreads) { + + // (n, c, ph, pw) is an element in the aligned output + int pw = index % aligned_width; + int ph = (index / aligned_width) % aligned_height; + int c = (index / aligned_width / aligned_height) % channels; + int n = index / aligned_width / aligned_height / channels; + + float roi_batch_ind = bottom_rois[n * 5 + 0]; + float roi_start_w = bottom_rois[n * 5 + 1] * spatial_scale; + float roi_start_h = bottom_rois[n * 5 + 2] * spatial_scale; + float roi_end_w = bottom_rois[n * 5 + 3] * spatial_scale; + float roi_end_h = bottom_rois[n * 5 + 4] * spatial_scale; + /* int roi_start_w = round(bottom_rois[1] * spatial_scale); */ + /* int roi_start_h = round(bottom_rois[2] * spatial_scale); */ + /* int roi_end_w = round(bottom_rois[3] * spatial_scale); */ + /* int roi_end_h = round(bottom_rois[4] * spatial_scale); */ + + // Force malformed ROIs to be 1x1 + float roi_width = fmaxf(roi_end_w - roi_start_w + 1., 0.); + float roi_height = fmaxf(roi_end_h - roi_start_h + 1., 0.); + float bin_size_h = roi_height / (aligned_height - 1.); + float bin_size_w = roi_width / (aligned_width - 1.); + + float h = (float)(ph) * bin_size_h + roi_start_h; + float w = (float)(pw) * bin_size_w + roi_start_w; + + int hstart = fminf(floor(h), height - 2); + int wstart = fminf(floor(w), width - 2); + + int img_start = roi_batch_ind * channels * height * width; + + // bilinear interpolation + if (!(h < 0 || h >= height || w < 0 || w >= width)) { + float h_ratio = h - (float)(hstart); + float w_ratio = w - (float)(wstart); + int upleft = img_start + (c * height + hstart) * width + wstart; + int upright = upleft + 1; + int downleft = upleft + width; + int downright = downleft + 1; + + atomicAdd(bottom_diff + upleft, top_diff[index] * (1. - h_ratio) * (1 - w_ratio)); + atomicAdd(bottom_diff + upright, top_diff[index] * (1. - h_ratio) * w_ratio); + atomicAdd(bottom_diff + downleft, top_diff[index] * h_ratio * (1 - w_ratio)); + atomicAdd(bottom_diff + downright, top_diff[index] * h_ratio * w_ratio); + } + } + } + + int ROIAlignBackwardLaucher(const float* top_diff, const float spatial_scale, const int batch_size, const int num_rois, const int height, const int width, + const int channels, const int aligned_height, const int aligned_width, const float* bottom_rois, float* bottom_diff, cudaStream_t stream) { + const int kThreadsPerBlock = 1024; + const int output_size = num_rois * aligned_height * aligned_width * channels; + cudaError_t err; + + ROIAlignBackward<<<(output_size + kThreadsPerBlock - 1) / kThreadsPerBlock, kThreadsPerBlock, 0, stream>>>( + output_size, top_diff, spatial_scale, height, width, channels, + aligned_height, aligned_width, bottom_diff, bottom_rois); + + err = cudaGetLastError(); + if(cudaSuccess != err) { + fprintf( stderr, "cudaCheckError() failed : %s\n", cudaGetErrorString( err ) ); + exit( -1 ); + } + + return 1; + } + + +#ifdef __cplusplus +} +#endif diff --git a/lib/model/roi_align/src/roi_align_kernel.h b/lib/model/roi_align/src/roi_align_kernel.h new file mode 100644 index 0000000..bf8f167 --- /dev/null +++ b/lib/model/roi_align/src/roi_align_kernel.h @@ -0,0 +1,34 @@ +#ifndef _ROI_ALIGN_KERNEL +#define _ROI_ALIGN_KERNEL + +#ifdef __cplusplus +extern "C" { +#endif + +__global__ void ROIAlignForward(const int nthreads, const float* bottom_data, + const float spatial_scale, const int height, const int width, + const int channels, const int aligned_height, const int aligned_width, + const float* bottom_rois, float* top_data); + +int ROIAlignForwardLaucher( + const float* bottom_data, const float spatial_scale, const int num_rois, const int height, + const int width, const int channels, const int aligned_height, + const int aligned_width, const float* bottom_rois, + float* top_data, cudaStream_t stream); + +__global__ void ROIAlignBackward(const int nthreads, const float* top_diff, + const float spatial_scale, const int height, const int width, + const int channels, const int aligned_height, const int aligned_width, + float* bottom_diff, const float* bottom_rois); + +int ROIAlignBackwardLaucher(const float* top_diff, const float spatial_scale, const int batch_size, const int num_rois, + const int height, const int width, const int channels, const int aligned_height, + const int aligned_width, const float* bottom_rois, + float* bottom_diff, cudaStream_t stream); + +#ifdef __cplusplus +} +#endif + +#endif + diff --git a/lib/model/roi_crop/__init__.py b/lib/model/roi_crop/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/lib/model/roi_crop/_ext/__init__.py b/lib/model/roi_crop/_ext/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/lib/model/roi_crop/_ext/crop_resize/__init__.py b/lib/model/roi_crop/_ext/crop_resize/__init__.py new file mode 100644 index 0000000..95ca199 --- /dev/null +++ b/lib/model/roi_crop/_ext/crop_resize/__init__.py @@ -0,0 +1,12 @@ + +from torch.utils.ffi import _wrap_function +from ._crop_resize import lib as _lib, ffi as _ffi + +__all__ = [] +def _import_symbols(locals): + for symbol in dir(_lib): + fn = getattr(_lib, symbol) + locals[symbol] = _wrap_function(fn, _ffi) + __all__.append(symbol) + +_import_symbols(locals()) diff --git a/lib/model/roi_crop/_ext/roi_crop/__init__.py b/lib/model/roi_crop/_ext/roi_crop/__init__.py new file mode 100644 index 0000000..a642351 --- /dev/null +++ b/lib/model/roi_crop/_ext/roi_crop/__init__.py @@ -0,0 +1,15 @@ + +from torch.utils.ffi import _wrap_function +from ._roi_crop import lib as _lib, ffi as _ffi + +__all__ = [] +def _import_symbols(locals): + for symbol in dir(_lib): + fn = getattr(_lib, symbol) + if callable(fn): + locals[symbol] = _wrap_function(fn, _ffi) + else: + locals[symbol] = fn + __all__.append(symbol) + +_import_symbols(locals()) diff --git a/lib/model/roi_crop/build.py b/lib/model/roi_crop/build.py new file mode 100644 index 0000000..964055a --- /dev/null +++ b/lib/model/roi_crop/build.py @@ -0,0 +1,36 @@ +from __future__ import print_function +import os +import torch +from torch.utils.ffi import create_extension + +#this_file = os.path.dirname(__file__) + +sources = ['src/roi_crop.c'] +headers = ['src/roi_crop.h'] +defines = [] +with_cuda = False + +if torch.cuda.is_available(): + print('Including CUDA code.') + sources += ['src/roi_crop_cuda.c'] + headers += ['src/roi_crop_cuda.h'] + defines += [('WITH_CUDA', None)] + with_cuda = True + +this_file = os.path.dirname(os.path.realpath(__file__)) +print(this_file) +extra_objects = ['src/roi_crop_cuda_kernel.cu.o'] +extra_objects = [os.path.join(this_file, fname) for fname in extra_objects] + +ffi = create_extension( + '_ext.roi_crop', + headers=headers, + sources=sources, + define_macros=defines, + relative_to=__file__, + with_cuda=with_cuda, + extra_objects=extra_objects +) + +if __name__ == '__main__': + ffi.build() diff --git a/lib/model/roi_crop/functions/__init__.py b/lib/model/roi_crop/functions/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/lib/model/roi_crop/functions/crop_resize.py b/lib/model/roi_crop/functions/crop_resize.py new file mode 100644 index 0000000..1916c8f --- /dev/null +++ b/lib/model/roi_crop/functions/crop_resize.py @@ -0,0 +1,37 @@ +# functions/add.py +import torch +from torch.autograd import Function +from .._ext import roi_crop +from cffi import FFI +ffi = FFI() + +class RoICropFunction(Function): + def forward(self, input1, input2): + self.input1 = input1 + self.input2 = input2 + self.device_c = ffi.new("int *") + output = torch.zeros(input2.size()[0], input1.size()[1], input2.size()[1], input2.size()[2]) + #print('decice %d' % torch.cuda.current_device()) + if input1.is_cuda: + self.device = torch.cuda.current_device() + else: + self.device = -1 + self.device_c[0] = self.device + if not input1.is_cuda: + roi_crop.BilinearSamplerBHWD_updateOutput(input1, input2, output) + else: + output = output.cuda(self.device) + roi_crop.BilinearSamplerBHWD_updateOutput_cuda(input1, input2, output) + return output + + def backward(self, grad_output): + grad_input1 = torch.zeros(self.input1.size()) + grad_input2 = torch.zeros(self.input2.size()) + #print('backward decice %d' % self.device) + if not grad_output.is_cuda: + roi_crop.BilinearSamplerBHWD_updateGradInput(self.input1, self.input2, grad_input1, grad_input2, grad_output) + else: + grad_input1 = grad_input1.cuda(self.device) + grad_input2 = grad_input2.cuda(self.device) + roi_crop.BilinearSamplerBHWD_updateGradInput_cuda(self.input1, self.input2, grad_input1, grad_input2, grad_output) + return grad_input1, grad_input2 diff --git a/lib/model/roi_crop/functions/gridgen.py b/lib/model/roi_crop/functions/gridgen.py new file mode 100644 index 0000000..5fbbed3 --- /dev/null +++ b/lib/model/roi_crop/functions/gridgen.py @@ -0,0 +1,46 @@ +# functions/add.py +import torch +from torch.autograd import Function +import numpy as np + + +class AffineGridGenFunction(Function): + def __init__(self, height, width,lr=1): + super(AffineGridGenFunction, self).__init__() + self.lr = lr + self.height, self.width = height, width + self.grid = np.zeros( [self.height, self.width, 3], dtype=np.float32) + self.grid[:,:,0] = np.expand_dims(np.repeat(np.expand_dims(np.arange(-1, 1, 2.0/(self.height)), 0), repeats = self.width, axis = 0).T, 0) + self.grid[:,:,1] = np.expand_dims(np.repeat(np.expand_dims(np.arange(-1, 1, 2.0/(self.width)), 0), repeats = self.height, axis = 0), 0) + # self.grid[:,:,0] = np.expand_dims(np.repeat(np.expand_dims(np.arange(-1, 1, 2.0/(self.height - 1)), 0), repeats = self.width, axis = 0).T, 0) + # self.grid[:,:,1] = np.expand_dims(np.repeat(np.expand_dims(np.arange(-1, 1, 2.0/(self.width - 1)), 0), repeats = self.height, axis = 0), 0) + self.grid[:,:,2] = np.ones([self.height, width]) + self.grid = torch.from_numpy(self.grid.astype(np.float32)) + #print(self.grid) + + def forward(self, input1): + self.input1 = input1 + output = input1.new(torch.Size([input1.size(0)]) + self.grid.size()).zero_() + self.batchgrid = input1.new(torch.Size([input1.size(0)]) + self.grid.size()).zero_() + for i in range(input1.size(0)): + self.batchgrid[i] = self.grid.astype(self.batchgrid[i]) + + # if input1.is_cuda: + # self.batchgrid = self.batchgrid.cuda() + # output = output.cuda() + + for i in range(input1.size(0)): + output = torch.bmm(self.batchgrid.view(-1, self.height*self.width, 3), torch.transpose(input1, 1, 2)).view(-1, self.height, self.width, 2) + + return output + + def backward(self, grad_output): + + grad_input1 = self.input1.new(self.input1.size()).zero_() + + # if grad_output.is_cuda: + # self.batchgrid = self.batchgrid.cuda() + # grad_input1 = grad_input1.cuda() + + grad_input1 = torch.baddbmm(grad_input1, torch.transpose(grad_output.view(-1, self.height*self.width, 2), 1,2), self.batchgrid.view(-1, self.height*self.width, 3)) + return grad_input1 diff --git a/lib/model/roi_crop/functions/roi_crop.py b/lib/model/roi_crop/functions/roi_crop.py new file mode 100644 index 0000000..5092f6e --- /dev/null +++ b/lib/model/roi_crop/functions/roi_crop.py @@ -0,0 +1,21 @@ +# functions/add.py +import torch +from torch.autograd import Function +from .._ext import roi_crop +import pdb + +class RoICropFunction(Function): + def forward(self, input1, input2): + self.input1 = input1.clone() + self.input2 = input2.clone() + output = input2.new(input2.size()[0], input1.size()[1], input2.size()[1], input2.size()[2]).zero_() + assert output.get_device() == input1.get_device(), "output and input1 must on the same device" + assert output.get_device() == input2.get_device(), "output and input2 must on the same device" + roi_crop.BilinearSamplerBHWD_updateOutput_cuda(input1, input2, output) + return output + + def backward(self, grad_output): + grad_input1 = self.input1.new(self.input1.size()).zero_() + grad_input2 = self.input2.new(self.input2.size()).zero_() + roi_crop.BilinearSamplerBHWD_updateGradInput_cuda(self.input1, self.input2, grad_input1, grad_input2, grad_output) + return grad_input1, grad_input2 diff --git a/lib/model/roi_crop/make.sh b/lib/model/roi_crop/make.sh new file mode 100644 index 0000000..b7d7960 --- /dev/null +++ b/lib/model/roi_crop/make.sh @@ -0,0 +1,10 @@ +#!/usr/bin/env bash + +CUDA_PATH=/usr/local/cuda/ + +cd src +echo "Compiling my_lib kernels by nvcc..." +nvcc -c -o roi_crop_cuda_kernel.cu.o roi_crop_cuda_kernel.cu -x cu -Xcompiler -fPIC -arch=sm_52 + +cd ../ +python build.py diff --git a/lib/model/roi_crop/modules/__init__.py b/lib/model/roi_crop/modules/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/lib/model/roi_crop/modules/gridgen.py b/lib/model/roi_crop/modules/gridgen.py new file mode 100644 index 0000000..e9be083 --- /dev/null +++ b/lib/model/roi_crop/modules/gridgen.py @@ -0,0 +1,414 @@ +from torch.nn.modules.module import Module +import torch +from torch.autograd import Variable +import numpy as np +from ..functions.gridgen import AffineGridGenFunction + +import pyximport +pyximport.install(setup_args={"include_dirs":np.get_include()}, + reload_support=True) + + +class _AffineGridGen(Module): + def __init__(self, height, width, lr = 1, aux_loss = False): + super(_AffineGridGen, self).__init__() + self.height, self.width = height, width + self.aux_loss = aux_loss + self.f = AffineGridGenFunction(self.height, self.width, lr=lr) + self.lr = lr + def forward(self, input): + # if not self.aux_loss: + return self.f(input) + # else: + # identity = torch.from_numpy(np.array([[1,0,0], [0,1,0]], dtype=np.float32)) + # batch_identity = torch.zeros([input.size(0), 2,3]) + # for i in range(input.size(0)): + # batch_identity[i] = identity + # batch_identity = Variable(batch_identity) + # loss = torch.mul(input - batch_identity, input - batch_identity) + # loss = torch.sum(loss,1) + # loss = torch.sum(loss,2) + + # return self.f(input), loss.view(-1,1) + +class CylinderGridGen(Module): + def __init__(self, height, width, lr = 1, aux_loss = False): + super(CylinderGridGen, self).__init__() + self.height, self.width = height, width + self.aux_loss = aux_loss + self.f = CylinderGridGenFunction(self.height, self.width, lr=lr) + self.lr = lr + def forward(self, input): + + if not self.aux_loss: + return self.f(input) + else: + return self.f(input), torch.mul(input, input).view(-1,1) + + +class AffineGridGenV2(Module): + def __init__(self, height, width, lr = 1, aux_loss = False): + super(AffineGridGenV2, self).__init__() + self.height, self.width = height, width + self.aux_loss = aux_loss + self.lr = lr + + self.grid = np.zeros( [self.height, self.width, 3], dtype=np.float32) + self.grid[:,:,0] = np.expand_dims(np.repeat(np.expand_dims(np.arange(-1, 1, 2.0/self.height), 0), repeats = self.width, axis = 0).T, 0) + self.grid[:,:,1] = np.expand_dims(np.repeat(np.expand_dims(np.arange(-1, 1, 2.0/self.width), 0), repeats = self.height, axis = 0), 0) + self.grid[:,:,2] = np.ones([self.height, width]) + self.grid = torch.from_numpy(self.grid.astype(np.float32)) + + + def forward(self, input1): + self.batchgrid = torch.zeros(torch.Size([input1.size(0)]) + self.grid.size()) + + for i in range(input1.size(0)): + self.batchgrid[i] = self.grid + self.batchgrid = Variable(self.batchgrid) + + if input1.is_cuda: + self.batchgrid = self.batchgrid.cuda() + + output = torch.bmm(self.batchgrid.view(-1, self.height*self.width, 3), torch.transpose(input1, 1, 2)).view(-1, self.height, self.width, 2) + + return output + + +class CylinderGridGenV2(Module): + def __init__(self, height, width, lr = 1): + super(CylinderGridGenV2, self).__init__() + self.height, self.width = height, width + self.lr = lr + self.grid = np.zeros( [self.height, self.width, 3], dtype=np.float32) + self.grid[:,:,0] = np.expand_dims(np.repeat(np.expand_dims(np.arange(-1, 1, 2.0/self.height), 0), repeats = self.width, axis = 0).T, 0) + self.grid[:,:,1] = np.expand_dims(np.repeat(np.expand_dims(np.arange(-1, 1, 2.0/self.width), 0), repeats = self.height, axis = 0), 0) + self.grid[:,:,2] = np.ones([self.height, width]) + self.grid = torch.from_numpy(self.grid.astype(np.float32)) + def forward(self, input): + self.batchgrid = torch.zeros(torch.Size([input.size(0)]) + self.grid.size() ) + #print(self.batchgrid.size()) + for i in range(input.size(0)): + self.batchgrid[i,:,:,:] = self.grid + self.batchgrid = Variable(self.batchgrid) + + #print(self.batchgrid.size()) + + input_u = input.view(-1,1,1,1).repeat(1,self.height, self.width,1) + #print(input_u.requires_grad, self.batchgrid) + + output0 = self.batchgrid[:,:,:,0:1] + output1 = torch.atan(torch.tan(np.pi/2.0*(self.batchgrid[:,:,:,1:2] + self.batchgrid[:,:,:,2:] * input_u[:,:,:,:]))) /(np.pi/2) + #print(output0.size(), output1.size()) + + output = torch.cat([output0, output1], 3) + return output + + +class DenseAffineGridGen(Module): + def __init__(self, height, width, lr = 1, aux_loss = False): + super(DenseAffineGridGen, self).__init__() + self.height, self.width = height, width + self.aux_loss = aux_loss + self.lr = lr + + self.grid = np.zeros( [self.height, self.width, 3], dtype=np.float32) + self.grid[:,:,0] = np.expand_dims(np.repeat(np.expand_dims(np.arange(-1, 1, 2.0/self.height), 0), repeats = self.width, axis = 0).T, 0) + self.grid[:,:,1] = np.expand_dims(np.repeat(np.expand_dims(np.arange(-1, 1, 2.0/self.width), 0), repeats = self.height, axis = 0), 0) + self.grid[:,:,2] = np.ones([self.height, width]) + self.grid = torch.from_numpy(self.grid.astype(np.float32)) + + + def forward(self, input1): + self.batchgrid = torch.zeros(torch.Size([input1.size(0)]) + self.grid.size()) + + for i in range(input1.size(0)): + self.batchgrid[i] = self.grid + + self.batchgrid = Variable(self.batchgrid) + #print self.batchgrid, input1[:,:,:,0:3] + #print self.batchgrid, input1[:,:,:,4:6] + x = torch.mul(self.batchgrid, input1[:,:,:,0:3]) + y = torch.mul(self.batchgrid, input1[:,:,:,3:6]) + + output = torch.cat([torch.sum(x,3),torch.sum(y,3)], 3) + return output + + + + +class DenseAffine3DGridGen(Module): + def __init__(self, height, width, lr = 1, aux_loss = False): + super(DenseAffine3DGridGen, self).__init__() + self.height, self.width = height, width + self.aux_loss = aux_loss + self.lr = lr + + self.grid = np.zeros( [self.height, self.width, 3], dtype=np.float32) + self.grid[:,:,0] = np.expand_dims(np.repeat(np.expand_dims(np.arange(-1, 1, 2.0/self.height), 0), repeats = self.width, axis = 0).T, 0) + self.grid[:,:,1] = np.expand_dims(np.repeat(np.expand_dims(np.arange(-1, 1, 2.0/self.width), 0), repeats = self.height, axis = 0), 0) + self.grid[:,:,2] = np.ones([self.height, width]) + self.grid = torch.from_numpy(self.grid.astype(np.float32)) + + self.theta = self.grid[:,:,0] * np.pi/2 + np.pi/2 + self.phi = self.grid[:,:,1] * np.pi + + self.x = torch.sin(self.theta) * torch.cos(self.phi) + self.y = torch.sin(self.theta) * torch.sin(self.phi) + self.z = torch.cos(self.theta) + + self.grid3d = torch.from_numpy(np.zeros( [self.height, self.width, 4], dtype=np.float32)) + + self.grid3d[:,:,0] = self.x + self.grid3d[:,:,1] = self.y + self.grid3d[:,:,2] = self.z + self.grid3d[:,:,3] = self.grid[:,:,2] + + + def forward(self, input1): + self.batchgrid3d = torch.zeros(torch.Size([input1.size(0)]) + self.grid3d.size()) + + for i in range(input1.size(0)): + self.batchgrid3d[i] = self.grid3d + + self.batchgrid3d = Variable(self.batchgrid3d) + #print(self.batchgrid3d) + + x = torch.sum(torch.mul(self.batchgrid3d, input1[:,:,:,0:4]), 3) + y = torch.sum(torch.mul(self.batchgrid3d, input1[:,:,:,4:8]), 3) + z = torch.sum(torch.mul(self.batchgrid3d, input1[:,:,:,8:]), 3) + #print(x) + r = torch.sqrt(x**2 + y**2 + z**2) + 1e-5 + + #print(r) + theta = torch.acos(z/r)/(np.pi/2) - 1 + #phi = torch.atan(y/x) + phi = torch.atan(y/(x + 1e-5)) + np.pi * x.lt(0).type(torch.FloatTensor) * (y.ge(0).type(torch.FloatTensor) - y.lt(0).type(torch.FloatTensor)) + phi = phi/np.pi + + + output = torch.cat([theta,phi], 3) + + return output + + + + + +class DenseAffine3DGridGen_rotate(Module): + def __init__(self, height, width, lr = 1, aux_loss = False): + super(DenseAffine3DGridGen_rotate, self).__init__() + self.height, self.width = height, width + self.aux_loss = aux_loss + self.lr = lr + + self.grid = np.zeros( [self.height, self.width, 3], dtype=np.float32) + self.grid[:,:,0] = np.expand_dims(np.repeat(np.expand_dims(np.arange(-1, 1, 2.0/self.height), 0), repeats = self.width, axis = 0).T, 0) + self.grid[:,:,1] = np.expand_dims(np.repeat(np.expand_dims(np.arange(-1, 1, 2.0/self.width), 0), repeats = self.height, axis = 0), 0) + self.grid[:,:,2] = np.ones([self.height, width]) + self.grid = torch.from_numpy(self.grid.astype(np.float32)) + + self.theta = self.grid[:,:,0] * np.pi/2 + np.pi/2 + self.phi = self.grid[:,:,1] * np.pi + + self.x = torch.sin(self.theta) * torch.cos(self.phi) + self.y = torch.sin(self.theta) * torch.sin(self.phi) + self.z = torch.cos(self.theta) + + self.grid3d = torch.from_numpy(np.zeros( [self.height, self.width, 4], dtype=np.float32)) + + self.grid3d[:,:,0] = self.x + self.grid3d[:,:,1] = self.y + self.grid3d[:,:,2] = self.z + self.grid3d[:,:,3] = self.grid[:,:,2] + + + def forward(self, input1, input2): + self.batchgrid3d = torch.zeros(torch.Size([input1.size(0)]) + self.grid3d.size()) + + for i in range(input1.size(0)): + self.batchgrid3d[i] = self.grid3d + + self.batchgrid3d = Variable(self.batchgrid3d) + + self.batchgrid = torch.zeros(torch.Size([input1.size(0)]) + self.grid.size()) + + for i in range(input1.size(0)): + self.batchgrid[i] = self.grid + + self.batchgrid = Variable(self.batchgrid) + + #print(self.batchgrid3d) + + x = torch.sum(torch.mul(self.batchgrid3d, input1[:,:,:,0:4]), 3) + y = torch.sum(torch.mul(self.batchgrid3d, input1[:,:,:,4:8]), 3) + z = torch.sum(torch.mul(self.batchgrid3d, input1[:,:,:,8:]), 3) + #print(x) + r = torch.sqrt(x**2 + y**2 + z**2) + 1e-5 + + #print(r) + theta = torch.acos(z/r)/(np.pi/2) - 1 + #phi = torch.atan(y/x) + phi = torch.atan(y/(x + 1e-5)) + np.pi * x.lt(0).type(torch.FloatTensor) * (y.ge(0).type(torch.FloatTensor) - y.lt(0).type(torch.FloatTensor)) + phi = phi/np.pi + + input_u = input2.view(-1,1,1,1).repeat(1,self.height, self.width,1) + + output = torch.cat([theta,phi], 3) + + output1 = torch.atan(torch.tan(np.pi/2.0*(output[:,:,:,1:2] + self.batchgrid[:,:,:,2:] * input_u[:,:,:,:]))) /(np.pi/2) + output2 = torch.cat([output[:,:,:,0:1], output1], 3) + + return output2 + + +class Depth3DGridGen(Module): + def __init__(self, height, width, lr = 1, aux_loss = False): + super(Depth3DGridGen, self).__init__() + self.height, self.width = height, width + self.aux_loss = aux_loss + self.lr = lr + + self.grid = np.zeros( [self.height, self.width, 3], dtype=np.float32) + self.grid[:,:,0] = np.expand_dims(np.repeat(np.expand_dims(np.arange(-1, 1, 2.0/self.height), 0), repeats = self.width, axis = 0).T, 0) + self.grid[:,:,1] = np.expand_dims(np.repeat(np.expand_dims(np.arange(-1, 1, 2.0/self.width), 0), repeats = self.height, axis = 0), 0) + self.grid[:,:,2] = np.ones([self.height, width]) + self.grid = torch.from_numpy(self.grid.astype(np.float32)) + + self.theta = self.grid[:,:,0] * np.pi/2 + np.pi/2 + self.phi = self.grid[:,:,1] * np.pi + + self.x = torch.sin(self.theta) * torch.cos(self.phi) + self.y = torch.sin(self.theta) * torch.sin(self.phi) + self.z = torch.cos(self.theta) + + self.grid3d = torch.from_numpy(np.zeros( [self.height, self.width, 4], dtype=np.float32)) + + self.grid3d[:,:,0] = self.x + self.grid3d[:,:,1] = self.y + self.grid3d[:,:,2] = self.z + self.grid3d[:,:,3] = self.grid[:,:,2] + + + def forward(self, depth, trans0, trans1, rotate): + self.batchgrid3d = torch.zeros(torch.Size([depth.size(0)]) + self.grid3d.size()) + + for i in range(depth.size(0)): + self.batchgrid3d[i] = self.grid3d + + self.batchgrid3d = Variable(self.batchgrid3d) + + self.batchgrid = torch.zeros(torch.Size([depth.size(0)]) + self.grid.size()) + + for i in range(depth.size(0)): + self.batchgrid[i] = self.grid + + self.batchgrid = Variable(self.batchgrid) + + x = self.batchgrid3d[:,:,:,0:1] * depth + trans0.view(-1,1,1,1).repeat(1, self.height, self.width, 1) + + y = self.batchgrid3d[:,:,:,1:2] * depth + trans1.view(-1,1,1,1).repeat(1, self.height, self.width, 1) + z = self.batchgrid3d[:,:,:,2:3] * depth + #print(x.size(), y.size(), z.size()) + r = torch.sqrt(x**2 + y**2 + z**2) + 1e-5 + + #print(r) + theta = torch.acos(z/r)/(np.pi/2) - 1 + #phi = torch.atan(y/x) + phi = torch.atan(y/(x + 1e-5)) + np.pi * x.lt(0).type(torch.FloatTensor) * (y.ge(0).type(torch.FloatTensor) - y.lt(0).type(torch.FloatTensor)) + phi = phi/np.pi + + #print(theta.size(), phi.size()) + + + input_u = rotate.view(-1,1,1,1).repeat(1,self.height, self.width,1) + + output = torch.cat([theta,phi], 3) + #print(output.size()) + + output1 = torch.atan(torch.tan(np.pi/2.0*(output[:,:,:,1:2] + self.batchgrid[:,:,:,2:] * input_u[:,:,:,:]))) /(np.pi/2) + output2 = torch.cat([output[:,:,:,0:1], output1], 3) + + return output2 + + + + + +class Depth3DGridGen_with_mask(Module): + def __init__(self, height, width, lr = 1, aux_loss = False, ray_tracing = False): + super(Depth3DGridGen_with_mask, self).__init__() + self.height, self.width = height, width + self.aux_loss = aux_loss + self.lr = lr + self.ray_tracing = ray_tracing + + self.grid = np.zeros( [self.height, self.width, 3], dtype=np.float32) + self.grid[:,:,0] = np.expand_dims(np.repeat(np.expand_dims(np.arange(-1, 1, 2.0/self.height), 0), repeats = self.width, axis = 0).T, 0) + self.grid[:,:,1] = np.expand_dims(np.repeat(np.expand_dims(np.arange(-1, 1, 2.0/self.width), 0), repeats = self.height, axis = 0), 0) + self.grid[:,:,2] = np.ones([self.height, width]) + self.grid = torch.from_numpy(self.grid.astype(np.float32)) + + self.theta = self.grid[:,:,0] * np.pi/2 + np.pi/2 + self.phi = self.grid[:,:,1] * np.pi + + self.x = torch.sin(self.theta) * torch.cos(self.phi) + self.y = torch.sin(self.theta) * torch.sin(self.phi) + self.z = torch.cos(self.theta) + + self.grid3d = torch.from_numpy(np.zeros( [self.height, self.width, 4], dtype=np.float32)) + + self.grid3d[:,:,0] = self.x + self.grid3d[:,:,1] = self.y + self.grid3d[:,:,2] = self.z + self.grid3d[:,:,3] = self.grid[:,:,2] + + + def forward(self, depth, trans0, trans1, rotate): + self.batchgrid3d = torch.zeros(torch.Size([depth.size(0)]) + self.grid3d.size()) + + for i in range(depth.size(0)): + self.batchgrid3d[i] = self.grid3d + + self.batchgrid3d = Variable(self.batchgrid3d) + + self.batchgrid = torch.zeros(torch.Size([depth.size(0)]) + self.grid.size()) + + for i in range(depth.size(0)): + self.batchgrid[i] = self.grid + + self.batchgrid = Variable(self.batchgrid) + + if depth.is_cuda: + self.batchgrid = self.batchgrid.cuda() + self.batchgrid3d = self.batchgrid3d.cuda() + + + x_ = self.batchgrid3d[:,:,:,0:1] * depth + trans0.view(-1,1,1,1).repeat(1, self.height, self.width, 1) + + y_ = self.batchgrid3d[:,:,:,1:2] * depth + trans1.view(-1,1,1,1).repeat(1, self.height, self.width, 1) + z = self.batchgrid3d[:,:,:,2:3] * depth + #print(x.size(), y.size(), z.size()) + + rotate_z = rotate.view(-1,1,1,1).repeat(1,self.height, self.width,1) * np.pi + + x = x_ * torch.cos(rotate_z) - y_ * torch.sin(rotate_z) + y = x_ * torch.sin(rotate_z) + y_ * torch.cos(rotate_z) + + + r = torch.sqrt(x**2 + y**2 + z**2) + 1e-5 + + #print(r) + theta = torch.acos(z/r)/(np.pi/2) - 1 + #phi = torch.atan(y/x) + + if depth.is_cuda: + phi = torch.atan(y/(x + 1e-5)) + np.pi * x.lt(0).type(torch.cuda.FloatTensor) * (y.ge(0).type(torch.cuda.FloatTensor) - y.lt(0).type(torch.cuda.FloatTensor)) + else: + phi = torch.atan(y/(x + 1e-5)) + np.pi * x.lt(0).type(torch.FloatTensor) * (y.ge(0).type(torch.FloatTensor) - y.lt(0).type(torch.FloatTensor)) + + + phi = phi/np.pi + + output = torch.cat([theta,phi], 3) + return output diff --git a/lib/model/roi_crop/modules/roi_crop.py b/lib/model/roi_crop/modules/roi_crop.py new file mode 100644 index 0000000..f5f1c7f --- /dev/null +++ b/lib/model/roi_crop/modules/roi_crop.py @@ -0,0 +1,8 @@ +from torch.nn.modules.module import Module +from ..functions.roi_crop import RoICropFunction + +class _RoICrop(Module): + def __init__(self, layout = 'BHWD'): + super(_RoICrop, self).__init__() + def forward(self, input1, input2): + return RoICropFunction()(input1, input2) diff --git a/lib/model/roi_crop/src/roi_crop.c b/lib/model/roi_crop/src/roi_crop.c new file mode 100644 index 0000000..d416914 --- /dev/null +++ b/lib/model/roi_crop/src/roi_crop.c @@ -0,0 +1,485 @@ +#include +#include +#include + +#define real float + +int BilinearSamplerBHWD_updateOutput(THFloatTensor *inputImages, THFloatTensor *grids, THFloatTensor *output) +{ + + int batchsize = THFloatTensor_size(inputImages, 0); + int inputImages_height = THFloatTensor_size(inputImages, 1); + int inputImages_width = THFloatTensor_size(inputImages, 2); + int output_height = THFloatTensor_size(output, 1); + int output_width = THFloatTensor_size(output, 2); + int inputImages_channels = THFloatTensor_size(inputImages, 3); + + int output_strideBatch = THFloatTensor_stride(output, 0); + int output_strideHeight = THFloatTensor_stride(output, 1); + int output_strideWidth = THFloatTensor_stride(output, 2); + + int inputImages_strideBatch = THFloatTensor_stride(inputImages, 0); + int inputImages_strideHeight = THFloatTensor_stride(inputImages, 1); + int inputImages_strideWidth = THFloatTensor_stride(inputImages, 2); + + int grids_strideBatch = THFloatTensor_stride(grids, 0); + int grids_strideHeight = THFloatTensor_stride(grids, 1); + int grids_strideWidth = THFloatTensor_stride(grids, 2); + + real *inputImages_data, *output_data, *grids_data; + inputImages_data = THFloatTensor_data(inputImages); + output_data = THFloatTensor_data(output); + grids_data = THFloatTensor_data(grids); + + int b, yOut, xOut; + + for(b=0; b < batchsize; b++) + { + for(yOut=0; yOut < output_height; yOut++) + { + for(xOut=0; xOut < output_width; xOut++) + { + //read the grid + real yf = grids_data[b*grids_strideBatch + yOut*grids_strideHeight + xOut*grids_strideWidth]; + real xf = grids_data[b*grids_strideBatch + yOut*grids_strideHeight + xOut*grids_strideWidth + 1]; + + // get the weights for interpolation + int yInTopLeft, xInTopLeft; + real yWeightTopLeft, xWeightTopLeft; + + real xcoord = (xf + 1) * (inputImages_width - 1) / 2; + xInTopLeft = floor(xcoord); + xWeightTopLeft = 1 - (xcoord - xInTopLeft); + + real ycoord = (yf + 1) * (inputImages_height - 1) / 2; + yInTopLeft = floor(ycoord); + yWeightTopLeft = 1 - (ycoord - yInTopLeft); + + + + const int outAddress = output_strideBatch * b + output_strideHeight * yOut + output_strideWidth * xOut; + const int inTopLeftAddress = inputImages_strideBatch * b + inputImages_strideHeight * yInTopLeft + inputImages_strideWidth * xInTopLeft; + const int inTopRightAddress = inTopLeftAddress + inputImages_strideWidth; + const int inBottomLeftAddress = inTopLeftAddress + inputImages_strideHeight; + const int inBottomRightAddress = inBottomLeftAddress + inputImages_strideWidth; + + real v=0; + real inTopLeft=0; + real inTopRight=0; + real inBottomLeft=0; + real inBottomRight=0; + + // we are careful with the boundaries + bool topLeftIsIn = xInTopLeft >= 0 && xInTopLeft <= inputImages_width-1 && yInTopLeft >= 0 && yInTopLeft <= inputImages_height-1; + bool topRightIsIn = xInTopLeft+1 >= 0 && xInTopLeft+1 <= inputImages_width-1 && yInTopLeft >= 0 && yInTopLeft <= inputImages_height-1; + bool bottomLeftIsIn = xInTopLeft >= 0 && xInTopLeft <= inputImages_width-1 && yInTopLeft+1 >= 0 && yInTopLeft+1 <= inputImages_height-1; + bool bottomRightIsIn = xInTopLeft+1 >= 0 && xInTopLeft+1 <= inputImages_width-1 && yInTopLeft+1 >= 0 && yInTopLeft+1 <= inputImages_height-1; + + int t; + // interpolation happens here + for(t=0; t= 0 && xInTopLeft <= inputImages_width-1 && yInTopLeft >= 0 && yInTopLeft <= inputImages_height-1; + bool topRightIsIn = xInTopLeft+1 >= 0 && xInTopLeft+1 <= inputImages_width-1 && yInTopLeft >= 0 && yInTopLeft <= inputImages_height-1; + bool bottomLeftIsIn = xInTopLeft >= 0 && xInTopLeft <= inputImages_width-1 && yInTopLeft+1 >= 0 && yInTopLeft+1 <= inputImages_height-1; + bool bottomRightIsIn = xInTopLeft+1 >= 0 && xInTopLeft+1 <= inputImages_width-1 && yInTopLeft+1 >= 0 && yInTopLeft+1 <= inputImages_height-1; + + int t; + + for(t=0; t= 0 && xInTopLeft <= inputImages_width-1 && yInTopLeft >= 0 && yInTopLeft <= inputImages_height-1; + bool topRightIsIn = xInTopLeft+1 >= 0 && xInTopLeft+1 <= inputImages_width-1 && yInTopLeft >= 0 && yInTopLeft <= inputImages_height-1; + bool bottomLeftIsIn = xInTopLeft >= 0 && xInTopLeft <= inputImages_width-1 && yInTopLeft+1 >= 0 && yInTopLeft+1 <= inputImages_height-1; + bool bottomRightIsIn = xInTopLeft+1 >= 0 && xInTopLeft+1 <= inputImages_width-1 && yInTopLeft+1 >= 0 && yInTopLeft+1 <= inputImages_height-1; + + int t; + // interpolation happens here + for(t=0; t= 0 && xInTopLeft <= inputImages_width-1 && yInTopLeft >= 0 && yInTopLeft <= inputImages_height-1; + bool topRightIsIn = xInTopLeft+1 >= 0 && xInTopLeft+1 <= inputImages_width-1 && yInTopLeft >= 0 && yInTopLeft <= inputImages_height-1; + bool bottomLeftIsIn = xInTopLeft >= 0 && xInTopLeft <= inputImages_width-1 && yInTopLeft+1 >= 0 && yInTopLeft+1 <= inputImages_height-1; + bool bottomRightIsIn = xInTopLeft+1 >= 0 && xInTopLeft+1 <= inputImages_width-1 && yInTopLeft+1 >= 0 && yInTopLeft+1 <= inputImages_height-1; + + int t; + + for(t=0; t +#include +#include +#include "roi_crop_cuda_kernel.h" + +#define real float + +// this symbol will be resolved automatically from PyTorch libs +extern THCState *state; + +// Bilinear sampling is done in BHWD (coalescing is not obvious in BDHW) +// we assume BHWD format in inputImages +// we assume BHW(YX) format on grids + +int BilinearSamplerBHWD_updateOutput_cuda(THCudaTensor *inputImages, THCudaTensor *grids, THCudaTensor *output){ +// THCState *state = getCutorchState(L); +// THCudaTensor *inputImages = (THCudaTensor *)luaT_checkudata(L, 2, "torch.CudaTensor"); +// THCudaTensor *grids = (THCudaTensor *)luaT_checkudata(L, 3, "torch.CudaTensor"); +// THCudaTensor *output = (THCudaTensor *)luaT_checkudata(L, 4, "torch.CudaTensor"); + + int success = 0; + success = BilinearSamplerBHWD_updateOutput_cuda_kernel(THCudaTensor_size(state, output, 1), + THCudaTensor_size(state, output, 3), + THCudaTensor_size(state, output, 2), + THCudaTensor_size(state, output, 0), + THCudaTensor_size(state, inputImages, 1), + THCudaTensor_size(state, inputImages, 2), + THCudaTensor_size(state, inputImages, 3), + THCudaTensor_size(state, inputImages, 0), + THCudaTensor_data(state, inputImages), + THCudaTensor_stride(state, inputImages, 0), + THCudaTensor_stride(state, inputImages, 1), + THCudaTensor_stride(state, inputImages, 2), + THCudaTensor_stride(state, inputImages, 3), + THCudaTensor_data(state, grids), + THCudaTensor_stride(state, grids, 0), + THCudaTensor_stride(state, grids, 3), + THCudaTensor_stride(state, grids, 1), + THCudaTensor_stride(state, grids, 2), + THCudaTensor_data(state, output), + THCudaTensor_stride(state, output, 0), + THCudaTensor_stride(state, output, 1), + THCudaTensor_stride(state, output, 2), + THCudaTensor_stride(state, output, 3), + THCState_getCurrentStream(state)); + + //check for errors + if (!success) { + THError("aborting"); + } + return 1; +} + +int BilinearSamplerBHWD_updateGradInput_cuda(THCudaTensor *inputImages, THCudaTensor *grids, THCudaTensor *gradInputImages, + THCudaTensor *gradGrids, THCudaTensor *gradOutput) +{ +// THCState *state = getCutorchState(L); +// THCudaTensor *inputImages = (THCudaTensor *)luaT_checkudata(L, 2, "torch.CudaTensor"); +// THCudaTensor *grids = (THCudaTensor *)luaT_checkudata(L, 3, "torch.CudaTensor"); +// THCudaTensor *gradInputImages = (THCudaTensor *)luaT_checkudata(L, 4, "torch.CudaTensor"); +// THCudaTensor *gradGrids = (THCudaTensor *)luaT_checkudata(L, 5, "torch.CudaTensor"); +// THCudaTensor *gradOutput = (THCudaTensor *)luaT_checkudata(L, 6, "torch.CudaTensor"); + + int success = 0; + success = BilinearSamplerBHWD_updateGradInput_cuda_kernel(THCudaTensor_size(state, gradOutput, 1), + THCudaTensor_size(state, gradOutput, 3), + THCudaTensor_size(state, gradOutput, 2), + THCudaTensor_size(state, gradOutput, 0), + THCudaTensor_size(state, inputImages, 1), + THCudaTensor_size(state, inputImages, 2), + THCudaTensor_size(state, inputImages, 3), + THCudaTensor_size(state, inputImages, 0), + THCudaTensor_data(state, inputImages), + THCudaTensor_stride(state, inputImages, 0), + THCudaTensor_stride(state, inputImages, 1), + THCudaTensor_stride(state, inputImages, 2), + THCudaTensor_stride(state, inputImages, 3), + THCudaTensor_data(state, grids), + THCudaTensor_stride(state, grids, 0), + THCudaTensor_stride(state, grids, 3), + THCudaTensor_stride(state, grids, 1), + THCudaTensor_stride(state, grids, 2), + THCudaTensor_data(state, gradInputImages), + THCudaTensor_stride(state, gradInputImages, 0), + THCudaTensor_stride(state, gradInputImages, 1), + THCudaTensor_stride(state, gradInputImages, 2), + THCudaTensor_stride(state, gradInputImages, 3), + THCudaTensor_data(state, gradGrids), + THCudaTensor_stride(state, gradGrids, 0), + THCudaTensor_stride(state, gradGrids, 3), + THCudaTensor_stride(state, gradGrids, 1), + THCudaTensor_stride(state, gradGrids, 2), + THCudaTensor_data(state, gradOutput), + THCudaTensor_stride(state, gradOutput, 0), + THCudaTensor_stride(state, gradOutput, 1), + THCudaTensor_stride(state, gradOutput, 2), + THCudaTensor_stride(state, gradOutput, 3), + THCState_getCurrentStream(state)); + + //check for errors + if (!success) { + THError("aborting"); + } + return 1; +} diff --git a/lib/model/roi_crop/src/roi_crop_cuda.h b/lib/model/roi_crop/src/roi_crop_cuda.h new file mode 100644 index 0000000..29085ef --- /dev/null +++ b/lib/model/roi_crop/src/roi_crop_cuda.h @@ -0,0 +1,8 @@ +// Bilinear sampling is done in BHWD (coalescing is not obvious in BDHW) +// we assume BHWD format in inputImages +// we assume BHW(YX) format on grids + +int BilinearSamplerBHWD_updateOutput_cuda(THCudaTensor *inputImages, THCudaTensor *grids, THCudaTensor *output); + +int BilinearSamplerBHWD_updateGradInput_cuda(THCudaTensor *inputImages, THCudaTensor *grids, THCudaTensor *gradInputImages, + THCudaTensor *gradGrids, THCudaTensor *gradOutput); diff --git a/lib/model/roi_crop/src/roi_crop_cuda_kernel.cu b/lib/model/roi_crop/src/roi_crop_cuda_kernel.cu new file mode 100644 index 0000000..b1c20e4 --- /dev/null +++ b/lib/model/roi_crop/src/roi_crop_cuda_kernel.cu @@ -0,0 +1,330 @@ +#include +#include +#include "roi_crop_cuda_kernel.h" + +#define real float + +// Bilinear sampling is done in BHWD (coalescing is not obvious in BDHW) +// we assume BHWD format in inputImages +// we assume BHW(YX) format on grids + +__device__ void getTopLeft(float x, int width, int& point, float& weight) +{ + /* for interpolation : + stores in point and weight : + - the x-coordinate of the pixel on the left (or y-coordinate of the upper pixel) + - the weight for interpolating + */ + + float xcoord = (x + 1) * (width - 1) / 2; + point = floor(xcoord); + weight = 1 - (xcoord - point); +} + +__device__ bool between(int value, int lowerBound, int upperBound) +{ + return (value >= lowerBound && value <= upperBound); +} + +__device__ void sumReduceShMem(volatile float s[]) +{ + /* obviously only works for 32 elements */ + /* sums up a shared memory array of 32 elements, stores it in s[0] */ + /* whole warp can then read first element (broadcasting) */ + if(threadIdx.x<16) { s[threadIdx.x] = s[threadIdx.x] + s[threadIdx.x+16]; } + if(threadIdx.x<8) { s[threadIdx.x] = s[threadIdx.x] + s[threadIdx.x+8]; } + if(threadIdx.x<4) { s[threadIdx.x] = s[threadIdx.x] + s[threadIdx.x+4]; } + if(threadIdx.x<2) { s[threadIdx.x] = s[threadIdx.x] + s[threadIdx.x+2]; } + if(threadIdx.x<1) { s[threadIdx.x] = s[threadIdx.x] + s[threadIdx.x+1]; } +} + +// CUDA: grid stride looping +#define CUDA_KERNEL_LOOP(i, n) \ + for (int i = blockIdx.x * blockDim.x + threadIdx.x; \ + i < (n); \ + i += blockDim.x * gridDim.x) + +__global__ void bilinearSamplingFromGrid(const int nthreads, float* inputImages_data, int inputImages_strideBatch, int inputImages_strideChannels, int inputImages_strideHeight, int inputImages_strideWidth, + float* grids_data, int grids_strideBatch, int grids_strideYX, int grids_strideHeight, int grids_strideWidth, + float* output_data, int output_strideBatch, int output_strideChannels, int output_strideHeight, int output_strideWidth, + int inputImages_channels, int inputImages_height, int inputImages_width, + int output_channels, int output_height, int output_width, int output_batchsize, + int roiPerImage) +{ + CUDA_KERNEL_LOOP(index, nthreads) + { + const int xOut = index % output_width; + const int yOut = (index / output_width) % output_height; + const int cOut = (index / output_width / output_height) % output_channels; + const int b = index / output_width / output_height / output_channels; + + const int width = inputImages_width; + const int height = inputImages_height; + + const int b_input = b / roiPerImage; + + float yf = grids_data[b*grids_strideBatch + yOut*grids_strideHeight + xOut*grids_strideWidth]; + float xf = grids_data[b*grids_strideBatch + yOut*grids_strideHeight + xOut*grids_strideWidth + 1]; + + int yInTopLeft, xInTopLeft; + float yWeightTopLeft, xWeightTopLeft; + getTopLeft(xf, inputImages_width, xInTopLeft, xWeightTopLeft); + getTopLeft(yf, inputImages_height, yInTopLeft, yWeightTopLeft); + + // const int outAddress = output_strideBatch * b + output_strideHeight * yOut + output_strideWidth * xOut; + const int outAddress = output_strideBatch * b + output_strideChannels * cOut + output_strideHeight * yOut + xOut; + + const int inTopLeftAddress = inputImages_strideBatch * b_input + inputImages_strideChannels * cOut + inputImages_strideHeight * yInTopLeft + xInTopLeft; + const int inTopRightAddress = inTopLeftAddress + inputImages_strideWidth; + const int inBottomLeftAddress = inTopLeftAddress + inputImages_strideHeight; + const int inBottomRightAddress = inBottomLeftAddress + inputImages_strideWidth; + + float v=0; + float inTopLeft=0; + float inTopRight=0; + float inBottomLeft=0; + float inBottomRight=0; + + bool topLeftIsIn = between(xInTopLeft, 0, width-1) && between(yInTopLeft, 0, height-1); + bool topRightIsIn = between(xInTopLeft+1, 0, width-1) && between(yInTopLeft, 0, height-1); + bool bottomLeftIsIn = between(xInTopLeft, 0, width-1) && between(yInTopLeft+1, 0, height-1); + bool bottomRightIsIn = between(xInTopLeft+1, 0, width-1) && between(yInTopLeft+1, 0, height-1); + + if (!topLeftIsIn && !topRightIsIn && !bottomLeftIsIn && !bottomRightIsIn) + continue; + + if(topLeftIsIn) inTopLeft = inputImages_data[inTopLeftAddress]; + if(topRightIsIn) inTopRight = inputImages_data[inTopRightAddress]; + if(bottomLeftIsIn) inBottomLeft = inputImages_data[inBottomLeftAddress]; + if(bottomRightIsIn) inBottomRight = inputImages_data[inBottomRightAddress]; + + v = xWeightTopLeft * yWeightTopLeft * inTopLeft + + (1 - xWeightTopLeft) * yWeightTopLeft * inTopRight + + xWeightTopLeft * (1 - yWeightTopLeft) * inBottomLeft + + (1 - xWeightTopLeft) * (1 - yWeightTopLeft) * inBottomRight; + + output_data[outAddress] = v; + } + +} + +__global__ void backwardBilinearSampling(const int nthreads, float* inputImages_data, int inputImages_strideBatch, int inputImages_strideChannels, int inputImages_strideHeight, int inputImages_strideWidth, + float* gradInputImages_data, int gradInputImages_strideBatch, int gradInputImages_strideChannels, int gradInputImages_strideHeight, int gradInputImages_strideWidth, + float* grids_data, int grids_strideBatch, int grids_strideYX, int grids_strideHeight, int grids_strideWidth, + float* gradGrids_data, int gradGrids_strideBatch, int gradGrids_strideYX, int gradGrids_strideHeight, int gradGrids_strideWidth, + float* gradOutput_data, int gradOutput_strideBatch, int gradOutput_strideChannels, int gradOutput_strideHeight, int gradOutput_strideWidth, + int inputImages_channels, int inputImages_height, int inputImages_width, + int gradOutput_channels, int gradOutput_height, int gradOutput_width, int gradOutput_batchsize, + int roiPerImage) +{ + + CUDA_KERNEL_LOOP(index, nthreads) + { + const int xOut = index % gradOutput_width; + const int yOut = (index / gradOutput_width) % gradOutput_height; + const int cOut = (index / gradOutput_width / gradOutput_height) % gradOutput_channels; + const int b = index / gradOutput_width / gradOutput_height / gradOutput_channels; + + const int b_input = b / roiPerImage; + + const int width = inputImages_width; + const int height = inputImages_height; + + float yf = grids_data[b*grids_strideBatch + yOut*grids_strideHeight + xOut*grids_strideWidth]; + float xf = grids_data[b*grids_strideBatch + yOut*grids_strideHeight + xOut*grids_strideWidth + 1]; + + int yInTopLeft, xInTopLeft; + float yWeightTopLeft, xWeightTopLeft; + getTopLeft(xf, inputImages_width, xInTopLeft, xWeightTopLeft); + getTopLeft(yf, inputImages_height, yInTopLeft, yWeightTopLeft); + + const int inTopLeftAddress = inputImages_strideBatch * b_input + inputImages_strideChannels * cOut + inputImages_strideHeight * yInTopLeft + xInTopLeft; + const int inTopRightAddress = inTopLeftAddress + inputImages_strideWidth; + const int inBottomLeftAddress = inTopLeftAddress + inputImages_strideHeight; + const int inBottomRightAddress = inBottomLeftAddress + inputImages_strideWidth; + + const int gradInputImagesTopLeftAddress = gradInputImages_strideBatch * b_input + gradInputImages_strideChannels * cOut + + gradInputImages_strideHeight * yInTopLeft + xInTopLeft; + const int gradInputImagesTopRightAddress = gradInputImagesTopLeftAddress + gradInputImages_strideWidth; + const int gradInputImagesBottomLeftAddress = gradInputImagesTopLeftAddress + gradInputImages_strideHeight; + const int gradInputImagesBottomRightAddress = gradInputImagesBottomLeftAddress + gradInputImages_strideWidth; + + const int gradOutputAddress = gradOutput_strideBatch * b + gradOutput_strideChannels * cOut + gradOutput_strideHeight * yOut + xOut; + + float topLeftDotProduct = 0; + float topRightDotProduct = 0; + float bottomLeftDotProduct = 0; + float bottomRightDotProduct = 0; + + bool topLeftIsIn = between(xInTopLeft, 0, width-1) && between(yInTopLeft, 0, height-1); + bool topRightIsIn = between(xInTopLeft+1, 0, width-1) && between(yInTopLeft, 0, height-1); + bool bottomLeftIsIn = between(xInTopLeft, 0, width-1) && between(yInTopLeft+1, 0, height-1); + bool bottomRightIsIn = between(xInTopLeft+1, 0, width-1) && between(yInTopLeft+1, 0, height-1); + + float gradOutValue = gradOutput_data[gradOutputAddress]; + // bool between(int value, int lowerBound, int upperBound) + if(topLeftIsIn) + { + float inTopLeft = inputImages_data[inTopLeftAddress]; + topLeftDotProduct += inTopLeft * gradOutValue; + atomicAdd(&gradInputImages_data[gradInputImagesTopLeftAddress], xWeightTopLeft * yWeightTopLeft * gradOutValue); + } + + if(topRightIsIn) + { + float inTopRight = inputImages_data[inTopRightAddress]; + topRightDotProduct += inTopRight * gradOutValue; + atomicAdd(&gradInputImages_data[gradInputImagesTopRightAddress], (1 - xWeightTopLeft) * yWeightTopLeft * gradOutValue); + } + + if(bottomLeftIsIn) + { + float inBottomLeft = inputImages_data[inBottomLeftAddress]; + bottomLeftDotProduct += inBottomLeft * gradOutValue; + atomicAdd(&gradInputImages_data[gradInputImagesBottomLeftAddress], xWeightTopLeft * (1 - yWeightTopLeft) * gradOutValue); + } + + if(bottomRightIsIn) + { + float inBottomRight = inputImages_data[inBottomRightAddress]; + bottomRightDotProduct += inBottomRight * gradOutValue; + atomicAdd(&gradInputImages_data[gradInputImagesBottomRightAddress], (1 - xWeightTopLeft) * (1 - yWeightTopLeft) * gradOutValue); + } + } +} + + +#ifdef __cplusplus +extern "C" { +#endif + +int BilinearSamplerBHWD_updateOutput_cuda_kernel(/*output->size[1]*/int oc, + /*output->size[3]*/int ow, + /*output->size[2]*/int oh, + /*output->size[0]*/int ob, + /*THCudaTensor_size(state, inputImages, 1)*/int ic, + /*THCudaTensor_size(state, inputImages, 2)*/int ih, + /*THCudaTensor_size(state, inputImages, 3)*/int iw, + /*THCudaTensor_size(state, inputImages, 0)*/int ib, + /*THCudaTensor *inputImages*/float *inputImages, int isb, int isc, int ish, int isw, + /*THCudaTensor *grids*/float *grids, int gsb, int gsc, int gsh, int gsw, + /*THCudaTensor *output*/float *output, int osb, int osc, int osh, int osw, + /*THCState_getCurrentStream(state)*/cudaStream_t stream) +{ + const int kThreadsPerBlock = 1024; + int output_size = ob * oh * ow * oc; + cudaError_t err; + int roiPerImage = ob / ib; + + // printf("forward pass\n"); + + bilinearSamplingFromGrid<<<(output_size + kThreadsPerBlock - 1) / kThreadsPerBlock, kThreadsPerBlock, 0, stream>>>( + output_size, + /*THCudaTensor_data(state, inputImages)*/inputImages, + /*THCudaTensor_stride(state, inputImages, 0)*/isb, + /*THCudaTensor_stride(state, inputImages, 3)*/isc, + /*THCudaTensor_stride(state, inputImages, 1)*/ish, + /*THCudaTensor_stride(state, inputImages, 2)*/isw, + /*THCudaTensor_data(state, grids)*/grids, + /*THCudaTensor_stride(state, grids, 0)*/gsb, + /*THCudaTensor_stride(state, grids, 3)*/gsc, + /*THCudaTensor_stride(state, grids, 1)*/gsh, + /*THCudaTensor_stride(state, grids, 2)*/gsw, + /*THCudaTensor_data(state, output)*/output, + /*THCudaTensor_stride(state, output, 0)*/osb, + /*THCudaTensor_stride(state, output, 3)*/osc, + /*THCudaTensor_stride(state, output, 1)*/osh, + /*THCudaTensor_stride(state, output, 2)*/osw, + /*THCudaTensor_size(state, inputImages, 3)*/ic, + /*THCudaTensor_size(state, inputImages, 1)*/ih, + /*THCudaTensor_size(state, inputImages, 2)*/iw, + /*THCudaTensor_size(state, output, 3)*/oc, + /*THCudaTensor_size(state, output, 1)*/oh, + /*THCudaTensor_size(state, output, 2)*/ow, + /*THCudaTensor_size(state, output, 0)*/ob, + /*Number of rois per image*/roiPerImage); + + // check for errors + err = cudaGetLastError(); + if (err != cudaSuccess) { + printf("error in BilinearSampler.updateOutput: %s\n", cudaGetErrorString(err)); + //THError("aborting"); + return 0; + } + return 1; +} + +int BilinearSamplerBHWD_updateGradInput_cuda_kernel(/*gradOutput->size[1]*/int goc, + /*gradOutput->size[3]*/int gow, + /*gradOutput->size[2]*/int goh, + /*gradOutput->size[0]*/int gob, + /*THCudaTensor_size(state, inputImages, 1)*/int ic, + /*THCudaTensor_size(state, inputImages, 2)*/int ih, + /*THCudaTensor_size(state, inputImages, 3)*/int iw, + /*THCudaTensor_size(state, inputImages, 0)*/int ib, + /*THCudaTensor *inputImages*/float *inputImages, int isb, int isc, int ish, int isw, + /*THCudaTensor *grids*/float *grids, int gsb, int gsc, int gsh, int gsw, + /*THCudaTensor *gradInputImages*/float *gradInputImages, int gisb, int gisc, int gish, int gisw, + /*THCudaTensor *gradGrids*/float *gradGrids, int ggsb, int ggsc, int ggsh, int ggsw, + /*THCudaTensor *gradOutput*/float *gradOutput, int gosb, int gosc, int gosh, int gosw, + /*THCState_getCurrentStream(state)*/cudaStream_t stream) +{ + + const int kThreadsPerBlock = 1024; + int output_size = gob * goh * gow * goc; + cudaError_t err; + int roiPerImage = gob / ib; + + // printf("%d %d %d %d\n", gob, goh, gow, goc); + // printf("%d %d %d %d\n", ib, ih, iw, ic); + // printf("backward pass\n"); + + backwardBilinearSampling<<<(output_size + kThreadsPerBlock - 1) / kThreadsPerBlock, kThreadsPerBlock, 0, stream>>>( + output_size, + /*THCudaTensor_data(state, inputImages)*/inputImages, + /*THCudaTensor_stride(state, inputImages, 0)*/isb, + /*THCudaTensor_stride(state, inputImages, 3)*/isc, + /*THCudaTensor_stride(state, inputImages, 1)*/ish, + /*THCudaTensor_stride(state, inputImages, 2)*/isw, + /*THCudaTensor_data(state, gradInputImages)*/gradInputImages, + /*THCudaTensor_stride(state, gradInputImages, 0)*/gisb, + /*THCudaTensor_stride(state, gradInputImages, 3)*/gisc, + /*THCudaTensor_stride(state, gradInputImages, 1)*/gish, + /*THCudaTensor_stride(state, gradInputImages, 2)*/gisw, + /*THCudaTensor_data(state, grids)*/grids, + /*THCudaTensor_stride(state, grids, 0)*/gsb, + /*THCudaTensor_stride(state, grids, 3)*/gsc, + /*THCudaTensor_stride(state, grids, 1)*/gsh, + /*THCudaTensor_stride(state, grids, 2)*/gsw, + /*THCudaTensor_data(state, gradGrids)*/gradGrids, + /*THCudaTensor_stride(state, gradGrids, 0)*/ggsb, + /*THCudaTensor_stride(state, gradGrids, 3)*/ggsc, + /*THCudaTensor_stride(state, gradGrids, 1)*/ggsh, + /*THCudaTensor_stride(state, gradGrids, 2)*/ggsw, + /*THCudaTensor_data(state, gradOutput)*/gradOutput, + /*THCudaTensor_stride(state, gradOutput, 0)*/gosb, + /*THCudaTensor_stride(state, gradOutput, 3)*/gosc, + /*THCudaTensor_stride(state, gradOutput, 1)*/gosh, + /*THCudaTensor_stride(state, gradOutput, 2)*/gosw, + /*THCudaTensor_size(state, inputImages, 3)*/ic, + /*THCudaTensor_size(state, inputImages, 1)*/ih, + /*THCudaTensor_size(state, inputImages, 2)*/iw, + /*THCudaTensor_size(state, gradOutput, 3)*/goc, + /*THCudaTensor_size(state, gradOutput, 1)*/goh, + /*THCudaTensor_size(state, gradOutput, 2)*/gow, + /*THCudaTensor_size(state, gradOutput, 0)*/gob, + /*Number of rois per image*/roiPerImage); + + // check for errors + err = cudaGetLastError(); + if (err != cudaSuccess) { + printf("error in BilinearSampler.updateGradInput: %s\n", cudaGetErrorString(err)); + //THError("aborting"); + return 0; + } + return 1; +} + +#ifdef __cplusplus +} +#endif diff --git a/lib/model/roi_crop/src/roi_crop_cuda_kernel.h b/lib/model/roi_crop/src/roi_crop_cuda_kernel.h new file mode 100644 index 0000000..5c06c07 --- /dev/null +++ b/lib/model/roi_crop/src/roi_crop_cuda_kernel.h @@ -0,0 +1,37 @@ +#ifdef __cplusplus +extern "C" { +#endif + + +int BilinearSamplerBHWD_updateOutput_cuda_kernel(/*output->size[3]*/int oc, + /*output->size[2]*/int ow, + /*output->size[1]*/int oh, + /*output->size[0]*/int ob, + /*THCudaTensor_size(state, inputImages, 3)*/int ic, + /*THCudaTensor_size(state, inputImages, 1)*/int ih, + /*THCudaTensor_size(state, inputImages, 2)*/int iw, + /*THCudaTensor_size(state, inputImages, 0)*/int ib, + /*THCudaTensor *inputImages*/float *inputImages, int isb, int isc, int ish, int isw, + /*THCudaTensor *grids*/float *grids, int gsb, int gsc, int gsh, int gsw, + /*THCudaTensor *output*/float *output, int osb, int osc, int osh, int osw, + /*THCState_getCurrentStream(state)*/cudaStream_t stream); + +int BilinearSamplerBHWD_updateGradInput_cuda_kernel(/*gradOutput->size[3]*/int goc, + /*gradOutput->size[2]*/int gow, + /*gradOutput->size[1]*/int goh, + /*gradOutput->size[0]*/int gob, + /*THCudaTensor_size(state, inputImages, 3)*/int ic, + /*THCudaTensor_size(state, inputImages, 1)*/int ih, + /*THCudaTensor_size(state, inputImages, 2)*/int iw, + /*THCudaTensor_size(state, inputImages, 0)*/int ib, + /*THCudaTensor *inputImages*/float *inputImages, int isb, int isc, int ish, int isw, + /*THCudaTensor *grids*/float *grids, int gsb, int gsc, int gsh, int gsw, + /*THCudaTensor *gradInputImages*/float *gradInputImages, int gisb, int gisc, int gish, int gisw, + /*THCudaTensor *gradGrids*/float *gradGrids, int ggsb, int ggsc, int ggsh, int ggsw, + /*THCudaTensor *gradOutput*/float *gradOutput, int gosb, int gosc, int gosh, int gosw, + /*THCState_getCurrentStream(state)*/cudaStream_t stream); + + +#ifdef __cplusplus +} +#endif diff --git a/lib/model/roi_layers/__init__.py b/lib/model/roi_layers/__init__.py new file mode 100644 index 0000000..dbd59b5 --- /dev/null +++ b/lib/model/roi_layers/__init__.py @@ -0,0 +1,9 @@ +# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. +import torch +from .nms import nms +from .roi_align import ROIAlign +from .roi_align import roi_align +from .roi_pool import ROIPool +from .roi_pool import roi_pool + +__all__ = ["nms", "roi_align", "ROIAlign", "roi_pool", "ROIPool"] diff --git a/lib/model/roi_layers/nms.py b/lib/model/roi_layers/nms.py new file mode 100644 index 0000000..c0de3f3 --- /dev/null +++ b/lib/model/roi_layers/nms.py @@ -0,0 +1,7 @@ +# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. +# from ._utils import _C +from model import _C + +nms = _C.nms +# nms.__doc__ = """ +# This function performs Non-maximum suppresion""" diff --git a/lib/model/roi_layers/roi_align.py b/lib/model/roi_layers/roi_align.py new file mode 100644 index 0000000..10a4487 --- /dev/null +++ b/lib/model/roi_layers/roi_align.py @@ -0,0 +1,67 @@ +# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. +import torch +from torch import nn +from torch.autograd import Function +from torch.autograd.function import once_differentiable +from torch.nn.modules.utils import _pair + +from model import _C + +import pdb + +class _ROIAlign(Function): + @staticmethod + def forward(ctx, input, roi, output_size, spatial_scale, sampling_ratio): + ctx.save_for_backward(roi) + ctx.output_size = _pair(output_size) + ctx.spatial_scale = spatial_scale + ctx.sampling_ratio = sampling_ratio + ctx.input_shape = input.size() + output = _C.roi_align_forward(input, roi, spatial_scale, output_size[0], output_size[1], sampling_ratio) + return output + + @staticmethod + @once_differentiable + def backward(ctx, grad_output): + rois, = ctx.saved_tensors + output_size = ctx.output_size + spatial_scale = ctx.spatial_scale + sampling_ratio = ctx.sampling_ratio + bs, ch, h, w = ctx.input_shape + grad_input = _C.roi_align_backward( + grad_output, + rois, + spatial_scale, + output_size[0], + output_size[1], + bs, + ch, + h, + w, + sampling_ratio, + ) + return grad_input, None, None, None, None + + +roi_align = _ROIAlign.apply + + +class ROIAlign(nn.Module): + def __init__(self, output_size, spatial_scale, sampling_ratio): + super(ROIAlign, self).__init__() + self.output_size = output_size + self.spatial_scale = spatial_scale + self.sampling_ratio = sampling_ratio + + def forward(self, input, rois): + return roi_align( + input, rois, self.output_size, self.spatial_scale, self.sampling_ratio + ) + + def __repr__(self): + tmpstr = self.__class__.__name__ + "(" + tmpstr += "output_size=" + str(self.output_size) + tmpstr += ", spatial_scale=" + str(self.spatial_scale) + tmpstr += ", sampling_ratio=" + str(self.sampling_ratio) + tmpstr += ")" + return tmpstr diff --git a/lib/model/roi_layers/roi_pool.py b/lib/model/roi_layers/roi_pool.py new file mode 100644 index 0000000..e9e6e10 --- /dev/null +++ b/lib/model/roi_layers/roi_pool.py @@ -0,0 +1,63 @@ +# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. +import torch +from torch import nn +from torch.autograd import Function +from torch.autograd.function import once_differentiable +from torch.nn.modules.utils import _pair + +from model import _C + + +class _ROIPool(Function): + @staticmethod + def forward(ctx, input, roi, output_size, spatial_scale): + ctx.output_size = _pair(output_size) + ctx.spatial_scale = spatial_scale + ctx.input_shape = input.size() + output, argmax = _C.roi_pool_forward( + input, roi, spatial_scale, output_size[0], output_size[1] + ) + ctx.save_for_backward(input, roi, argmax) + return output + + @staticmethod + @once_differentiable + def backward(ctx, grad_output): + input, rois, argmax = ctx.saved_tensors + output_size = ctx.output_size + spatial_scale = ctx.spatial_scale + bs, ch, h, w = ctx.input_shape + grad_input = _C.roi_pool_backward( + grad_output, + input, + rois, + argmax, + spatial_scale, + output_size[0], + output_size[1], + bs, + ch, + h, + w, + ) + return grad_input, None, None, None + + +roi_pool = _ROIPool.apply + + +class ROIPool(nn.Module): + def __init__(self, output_size, spatial_scale): + super(ROIPool, self).__init__() + self.output_size = output_size + self.spatial_scale = spatial_scale + + def forward(self, input, rois): + return roi_pool(input, rois, self.output_size, self.spatial_scale) + + def __repr__(self): + tmpstr = self.__class__.__name__ + "(" + tmpstr += "output_size=" + str(self.output_size) + tmpstr += ", spatial_scale=" + str(self.spatial_scale) + tmpstr += ")" + return tmpstr diff --git a/lib/model/roi_pooling/__init__.py b/lib/model/roi_pooling/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/lib/model/roi_pooling/_ext/__init__.py b/lib/model/roi_pooling/_ext/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/lib/model/roi_pooling/_ext/roi_pooling/__init__.py b/lib/model/roi_pooling/_ext/roi_pooling/__init__.py new file mode 100644 index 0000000..d900ec5 --- /dev/null +++ b/lib/model/roi_pooling/_ext/roi_pooling/__init__.py @@ -0,0 +1,15 @@ + +from torch.utils.ffi import _wrap_function +from ._roi_pooling import lib as _lib, ffi as _ffi + +__all__ = [] +def _import_symbols(locals): + for symbol in dir(_lib): + fn = getattr(_lib, symbol) + if callable(fn): + locals[symbol] = _wrap_function(fn, _ffi) + else: + locals[symbol] = fn + __all__.append(symbol) + +_import_symbols(locals()) diff --git a/lib/model/roi_pooling/build.py b/lib/model/roi_pooling/build.py new file mode 100644 index 0000000..9401bff --- /dev/null +++ b/lib/model/roi_pooling/build.py @@ -0,0 +1,36 @@ +from __future__ import print_function +import os +import torch +from torch.utils.ffi import create_extension + + +sources = ['src/roi_pooling.c'] +headers = ['src/roi_pooling.h'] +extra_objects = [] +defines = [] +with_cuda = False + +this_file = os.path.dirname(os.path.realpath(__file__)) +print(this_file) + +if torch.cuda.is_available(): + print('Including CUDA code.') + sources += ['src/roi_pooling_cuda.c'] + headers += ['src/roi_pooling_cuda.h'] + defines += [('WITH_CUDA', None)] + with_cuda = True + extra_objects = ['src/roi_pooling.cu.o'] + extra_objects = [os.path.join(this_file, fname) for fname in extra_objects] + +ffi = create_extension( + '_ext.roi_pooling', + headers=headers, + sources=sources, + define_macros=defines, + relative_to=__file__, + with_cuda=with_cuda, + extra_objects=extra_objects +) + +if __name__ == '__main__': + ffi.build() diff --git a/lib/model/roi_pooling/functions/__init__.py b/lib/model/roi_pooling/functions/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/lib/model/roi_pooling/functions/roi_pool.py b/lib/model/roi_pooling/functions/roi_pool.py new file mode 100644 index 0000000..b7d22ab --- /dev/null +++ b/lib/model/roi_pooling/functions/roi_pool.py @@ -0,0 +1,38 @@ +import torch +from torch.autograd import Function +from .._ext import roi_pooling +import pdb + +class RoIPoolFunction(Function): + def __init__(ctx, pooled_height, pooled_width, spatial_scale): + ctx.pooled_width = pooled_width + ctx.pooled_height = pooled_height + ctx.spatial_scale = spatial_scale + ctx.feature_size = None + + def forward(ctx, features, rois): + ctx.feature_size = features.size() + batch_size, num_channels, data_height, data_width = ctx.feature_size + num_rois = rois.size(0) + output = features.new(num_rois, num_channels, ctx.pooled_height, ctx.pooled_width).zero_() + ctx.argmax = features.new(num_rois, num_channels, ctx.pooled_height, ctx.pooled_width).zero_().int() + ctx.rois = rois + if not features.is_cuda: + _features = features.permute(0, 2, 3, 1) + roi_pooling.roi_pooling_forward(ctx.pooled_height, ctx.pooled_width, ctx.spatial_scale, + _features, rois, output) + else: + roi_pooling.roi_pooling_forward_cuda(ctx.pooled_height, ctx.pooled_width, ctx.spatial_scale, + features, rois, output, ctx.argmax) + + return output + + def backward(ctx, grad_output): + assert(ctx.feature_size is not None and grad_output.is_cuda) + batch_size, num_channels, data_height, data_width = ctx.feature_size + grad_input = grad_output.new(batch_size, num_channels, data_height, data_width).zero_() + + roi_pooling.roi_pooling_backward_cuda(ctx.pooled_height, ctx.pooled_width, ctx.spatial_scale, + grad_output, ctx.rois, grad_input, ctx.argmax) + + return grad_input, None diff --git a/lib/model/roi_pooling/modules/__init__.py b/lib/model/roi_pooling/modules/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/lib/model/roi_pooling/modules/roi_pool.py b/lib/model/roi_pooling/modules/roi_pool.py new file mode 100644 index 0000000..516c16f --- /dev/null +++ b/lib/model/roi_pooling/modules/roi_pool.py @@ -0,0 +1,14 @@ +from torch.nn.modules.module import Module +from ..functions.roi_pool import RoIPoolFunction + + +class _RoIPooling(Module): + def __init__(self, pooled_height, pooled_width, spatial_scale): + super(_RoIPooling, self).__init__() + + self.pooled_width = int(pooled_width) + self.pooled_height = int(pooled_height) + self.spatial_scale = float(spatial_scale) + + def forward(self, features, rois): + return RoIPoolFunction(self.pooled_height, self.pooled_width, self.spatial_scale)(features, rois) diff --git a/lib/model/roi_pooling/src/roi_pooling.c b/lib/model/roi_pooling/src/roi_pooling.c new file mode 100644 index 0000000..47a754d --- /dev/null +++ b/lib/model/roi_pooling/src/roi_pooling.c @@ -0,0 +1,104 @@ +#include +#include + +int roi_pooling_forward(int pooled_height, int pooled_width, float spatial_scale, + THFloatTensor * features, THFloatTensor * rois, THFloatTensor * output) +{ + // Grab the input tensor + float * data_flat = THFloatTensor_data(features); + float * rois_flat = THFloatTensor_data(rois); + + float * output_flat = THFloatTensor_data(output); + + // Number of ROIs + int num_rois = THFloatTensor_size(rois, 0); + int size_rois = THFloatTensor_size(rois, 1); + // batch size + int batch_size = THFloatTensor_size(features, 0); + if(batch_size != 1) + { + return 0; + } + // data height + int data_height = THFloatTensor_size(features, 1); + // data width + int data_width = THFloatTensor_size(features, 2); + // Number of channels + int num_channels = THFloatTensor_size(features, 3); + + // Set all element of the output tensor to -inf. + THFloatStorage_fill(THFloatTensor_storage(output), -1); + + // For each ROI R = [batch_index x1 y1 x2 y2]: max pool over R + int index_roi = 0; + int index_output = 0; + int n; + for (n = 0; n < num_rois; ++n) + { + int roi_batch_ind = rois_flat[index_roi + 0]; + int roi_start_w = round(rois_flat[index_roi + 1] * spatial_scale); + int roi_start_h = round(rois_flat[index_roi + 2] * spatial_scale); + int roi_end_w = round(rois_flat[index_roi + 3] * spatial_scale); + int roi_end_h = round(rois_flat[index_roi + 4] * spatial_scale); + // CHECK_GE(roi_batch_ind, 0); + // CHECK_LT(roi_batch_ind, batch_size); + + int roi_height = fmaxf(roi_end_h - roi_start_h + 1, 1); + int roi_width = fmaxf(roi_end_w - roi_start_w + 1, 1); + float bin_size_h = (float)(roi_height) / (float)(pooled_height); + float bin_size_w = (float)(roi_width) / (float)(pooled_width); + + int index_data = roi_batch_ind * data_height * data_width * num_channels; + const int output_area = pooled_width * pooled_height; + + int c, ph, pw; + for (ph = 0; ph < pooled_height; ++ph) + { + for (pw = 0; pw < pooled_width; ++pw) + { + int hstart = (floor((float)(ph) * bin_size_h)); + int wstart = (floor((float)(pw) * bin_size_w)); + int hend = (ceil((float)(ph + 1) * bin_size_h)); + int wend = (ceil((float)(pw + 1) * bin_size_w)); + + hstart = fminf(fmaxf(hstart + roi_start_h, 0), data_height); + hend = fminf(fmaxf(hend + roi_start_h, 0), data_height); + wstart = fminf(fmaxf(wstart + roi_start_w, 0), data_width); + wend = fminf(fmaxf(wend + roi_start_w, 0), data_width); + + const int pool_index = index_output + (ph * pooled_width + pw); + int is_empty = (hend <= hstart) || (wend <= wstart); + if (is_empty) + { + for (c = 0; c < num_channels * output_area; c += output_area) + { + output_flat[pool_index + c] = 0; + } + } + else + { + int h, w, c; + for (h = hstart; h < hend; ++h) + { + for (w = wstart; w < wend; ++w) + { + for (c = 0; c < num_channels; ++c) + { + const int index = (h * data_width + w) * num_channels + c; + if (data_flat[index_data + index] > output_flat[pool_index + c * output_area]) + { + output_flat[pool_index + c * output_area] = data_flat[index_data + index]; + } + } + } + } + } + } + } + + // Increment ROI index + index_roi += size_rois; + index_output += pooled_height * pooled_width * num_channels; + } + return 1; +} \ No newline at end of file diff --git a/lib/model/roi_pooling/src/roi_pooling.h b/lib/model/roi_pooling/src/roi_pooling.h new file mode 100644 index 0000000..06052de --- /dev/null +++ b/lib/model/roi_pooling/src/roi_pooling.h @@ -0,0 +1,2 @@ +int roi_pooling_forward(int pooled_height, int pooled_width, float spatial_scale, + THFloatTensor * features, THFloatTensor * rois, THFloatTensor * output); \ No newline at end of file diff --git a/lib/model/roi_pooling/src/roi_pooling_cuda.c b/lib/model/roi_pooling/src/roi_pooling_cuda.c new file mode 100644 index 0000000..32eb3f7 --- /dev/null +++ b/lib/model/roi_pooling/src/roi_pooling_cuda.c @@ -0,0 +1,88 @@ +#include +#include +#include "roi_pooling_kernel.h" + +extern THCState *state; + +int roi_pooling_forward_cuda(int pooled_height, int pooled_width, float spatial_scale, + THCudaTensor * features, THCudaTensor * rois, THCudaTensor * output, THCudaIntTensor * argmax) +{ + // Grab the input tensor + float * data_flat = THCudaTensor_data(state, features); + float * rois_flat = THCudaTensor_data(state, rois); + + float * output_flat = THCudaTensor_data(state, output); + int * argmax_flat = THCudaIntTensor_data(state, argmax); + + // Number of ROIs + int num_rois = THCudaTensor_size(state, rois, 0); + int size_rois = THCudaTensor_size(state, rois, 1); + if (size_rois != 5) + { + return 0; + } + + // batch size + // int batch_size = THCudaTensor_size(state, features, 0); + // if (batch_size != 1) + // { + // return 0; + // } + // data height + int data_height = THCudaTensor_size(state, features, 2); + // data width + int data_width = THCudaTensor_size(state, features, 3); + // Number of channels + int num_channels = THCudaTensor_size(state, features, 1); + + cudaStream_t stream = THCState_getCurrentStream(state); + + ROIPoolForwardLaucher( + data_flat, spatial_scale, num_rois, data_height, + data_width, num_channels, pooled_height, + pooled_width, rois_flat, + output_flat, argmax_flat, stream); + + return 1; +} + +int roi_pooling_backward_cuda(int pooled_height, int pooled_width, float spatial_scale, + THCudaTensor * top_grad, THCudaTensor * rois, THCudaTensor * bottom_grad, THCudaIntTensor * argmax) +{ + // Grab the input tensor + float * top_grad_flat = THCudaTensor_data(state, top_grad); + float * rois_flat = THCudaTensor_data(state, rois); + + float * bottom_grad_flat = THCudaTensor_data(state, bottom_grad); + int * argmax_flat = THCudaIntTensor_data(state, argmax); + + // Number of ROIs + int num_rois = THCudaTensor_size(state, rois, 0); + int size_rois = THCudaTensor_size(state, rois, 1); + if (size_rois != 5) + { + return 0; + } + + // batch size + int batch_size = THCudaTensor_size(state, bottom_grad, 0); + // if (batch_size != 1) + // { + // return 0; + // } + // data height + int data_height = THCudaTensor_size(state, bottom_grad, 2); + // data width + int data_width = THCudaTensor_size(state, bottom_grad, 3); + // Number of channels + int num_channels = THCudaTensor_size(state, bottom_grad, 1); + + cudaStream_t stream = THCState_getCurrentStream(state); + ROIPoolBackwardLaucher( + top_grad_flat, spatial_scale, batch_size, num_rois, data_height, + data_width, num_channels, pooled_height, + pooled_width, rois_flat, + bottom_grad_flat, argmax_flat, stream); + + return 1; +} diff --git a/lib/model/roi_pooling/src/roi_pooling_cuda.h b/lib/model/roi_pooling/src/roi_pooling_cuda.h new file mode 100644 index 0000000..c08881e --- /dev/null +++ b/lib/model/roi_pooling/src/roi_pooling_cuda.h @@ -0,0 +1,5 @@ +int roi_pooling_forward_cuda(int pooled_height, int pooled_width, float spatial_scale, + THCudaTensor * features, THCudaTensor * rois, THCudaTensor * output, THCudaIntTensor * argmax); + +int roi_pooling_backward_cuda(int pooled_height, int pooled_width, float spatial_scale, + THCudaTensor * top_grad, THCudaTensor * rois, THCudaTensor * bottom_grad, THCudaIntTensor * argmax); \ No newline at end of file diff --git a/lib/model/roi_pooling/src/roi_pooling_kernel.cu b/lib/model/roi_pooling/src/roi_pooling_kernel.cu new file mode 100644 index 0000000..813bc5d --- /dev/null +++ b/lib/model/roi_pooling/src/roi_pooling_kernel.cu @@ -0,0 +1,239 @@ +// #ifdef __cplusplus +// extern "C" { +// #endif + +#include +#include +#include +#include +#include "roi_pooling_kernel.h" + + +#define DIVUP(m, n) ((m) / (m) + ((m) % (n) > 0)) + +#define CUDA_1D_KERNEL_LOOP(i, n) \ + for (int i = blockIdx.x * blockDim.x + threadIdx.x; i < n; \ + i += blockDim.x * gridDim.x) + +// CUDA: grid stride looping +#define CUDA_KERNEL_LOOP(i, n) \ + for (int i = blockIdx.x * blockDim.x + threadIdx.x; \ + i < (n); \ + i += blockDim.x * gridDim.x) + +__global__ void ROIPoolForward(const int nthreads, const float* bottom_data, + const float spatial_scale, const int height, const int width, + const int channels, const int pooled_height, const int pooled_width, + const float* bottom_rois, float* top_data, int* argmax_data) +{ + CUDA_KERNEL_LOOP(index, nthreads) + { + // (n, c, ph, pw) is an element in the pooled output + // int n = index; + // int pw = n % pooled_width; + // n /= pooled_width; + // int ph = n % pooled_height; + // n /= pooled_height; + // int c = n % channels; + // n /= channels; + int pw = index % pooled_width; + int ph = (index / pooled_width) % pooled_height; + int c = (index / pooled_width / pooled_height) % channels; + int n = index / pooled_width / pooled_height / channels; + + // bottom_rois += n * 5; + int roi_batch_ind = bottom_rois[n * 5 + 0]; + int roi_start_w = round(bottom_rois[n * 5 + 1] * spatial_scale); + int roi_start_h = round(bottom_rois[n * 5 + 2] * spatial_scale); + int roi_end_w = round(bottom_rois[n * 5 + 3] * spatial_scale); + int roi_end_h = round(bottom_rois[n * 5 + 4] * spatial_scale); + + // Force malformed ROIs to be 1x1 + int roi_width = fmaxf(roi_end_w - roi_start_w + 1, 1); + int roi_height = fmaxf(roi_end_h - roi_start_h + 1, 1); + float bin_size_h = (float)(roi_height) / (float)(pooled_height); + float bin_size_w = (float)(roi_width) / (float)(pooled_width); + + int hstart = (int)(floor((float)(ph) * bin_size_h)); + int wstart = (int)(floor((float)(pw) * bin_size_w)); + int hend = (int)(ceil((float)(ph + 1) * bin_size_h)); + int wend = (int)(ceil((float)(pw + 1) * bin_size_w)); + + // Add roi offsets and clip to input boundaries + hstart = fminf(fmaxf(hstart + roi_start_h, 0), height); + hend = fminf(fmaxf(hend + roi_start_h, 0), height); + wstart = fminf(fmaxf(wstart + roi_start_w, 0), width); + wend = fminf(fmaxf(wend + roi_start_w, 0), width); + bool is_empty = (hend <= hstart) || (wend <= wstart); + + // Define an empty pooling region to be zero + float maxval = is_empty ? 0 : -FLT_MAX; + // If nothing is pooled, argmax = -1 causes nothing to be backprop'd + int maxidx = -1; + // bottom_data += roi_batch_ind * channels * height * width; + + int bottom_data_batch_offset = roi_batch_ind * channels * height * width; + int bottom_data_offset = bottom_data_batch_offset + c * height * width; + + for (int h = hstart; h < hend; ++h) { + for (int w = wstart; w < wend; ++w) { + // int bottom_index = (h * width + w) * channels + c; + // int bottom_index = (c * height + h) * width + w; + int bottom_index = h * width + w; + if (bottom_data[bottom_data_offset + bottom_index] > maxval) { + maxval = bottom_data[bottom_data_offset + bottom_index]; + maxidx = bottom_data_offset + bottom_index; + } + } + } + top_data[index] = maxval; + if (argmax_data != NULL) + argmax_data[index] = maxidx; + } +} + +int ROIPoolForwardLaucher( + const float* bottom_data, const float spatial_scale, const int num_rois, const int height, + const int width, const int channels, const int pooled_height, + const int pooled_width, const float* bottom_rois, + float* top_data, int* argmax_data, cudaStream_t stream) +{ + const int kThreadsPerBlock = 1024; + int output_size = num_rois * pooled_height * pooled_width * channels; + cudaError_t err; + + ROIPoolForward<<<(output_size + kThreadsPerBlock - 1) / kThreadsPerBlock, kThreadsPerBlock, 0, stream>>>( + output_size, bottom_data, spatial_scale, height, width, channels, pooled_height, + pooled_width, bottom_rois, top_data, argmax_data); + + // dim3 blocks(DIVUP(output_size, kThreadsPerBlock), + // DIVUP(output_size, kThreadsPerBlock)); + // dim3 threads(kThreadsPerBlock); + // + // ROIPoolForward<<>>( + // output_size, bottom_data, spatial_scale, height, width, channels, pooled_height, + // pooled_width, bottom_rois, top_data, argmax_data); + + err = cudaGetLastError(); + if(cudaSuccess != err) + { + fprintf( stderr, "cudaCheckError() failed : %s\n", cudaGetErrorString( err ) ); + exit( -1 ); + } + + return 1; +} + + +__global__ void ROIPoolBackward(const int nthreads, const float* top_diff, + const int* argmax_data, const int num_rois, const float spatial_scale, + const int height, const int width, const int channels, + const int pooled_height, const int pooled_width, float* bottom_diff, + const float* bottom_rois) { + CUDA_1D_KERNEL_LOOP(index, nthreads) + { + + // (n, c, ph, pw) is an element in the pooled output + int n = index; + int w = n % width; + n /= width; + int h = n % height; + n /= height; + int c = n % channels; + n /= channels; + + float gradient = 0; + // Accumulate gradient over all ROIs that pooled this element + for (int roi_n = 0; roi_n < num_rois; ++roi_n) + { + const float* offset_bottom_rois = bottom_rois + roi_n * 5; + int roi_batch_ind = offset_bottom_rois[0]; + // Skip if ROI's batch index doesn't match n + if (n != roi_batch_ind) { + continue; + } + + int roi_start_w = round(offset_bottom_rois[1] * spatial_scale); + int roi_start_h = round(offset_bottom_rois[2] * spatial_scale); + int roi_end_w = round(offset_bottom_rois[3] * spatial_scale); + int roi_end_h = round(offset_bottom_rois[4] * spatial_scale); + + // Skip if ROI doesn't include (h, w) + const bool in_roi = (w >= roi_start_w && w <= roi_end_w && + h >= roi_start_h && h <= roi_end_h); + if (!in_roi) { + continue; + } + + int offset = roi_n * pooled_height * pooled_width * channels; + const float* offset_top_diff = top_diff + offset; + const int* offset_argmax_data = argmax_data + offset; + + // Compute feasible set of pooled units that could have pooled + // this bottom unit + + // Force malformed ROIs to be 1x1 + int roi_width = fmaxf(roi_end_w - roi_start_w + 1, 1); + int roi_height = fmaxf(roi_end_h - roi_start_h + 1, 1); + + float bin_size_h = (float)(roi_height) / (float)(pooled_height); + float bin_size_w = (float)(roi_width) / (float)(pooled_width); + + int phstart = floor((float)(h - roi_start_h) / bin_size_h); + int phend = ceil((float)(h - roi_start_h + 1) / bin_size_h); + int pwstart = floor((float)(w - roi_start_w) / bin_size_w); + int pwend = ceil((float)(w - roi_start_w + 1) / bin_size_w); + + phstart = fminf(fmaxf(phstart, 0), pooled_height); + phend = fminf(fmaxf(phend, 0), pooled_height); + pwstart = fminf(fmaxf(pwstart, 0), pooled_width); + pwend = fminf(fmaxf(pwend, 0), pooled_width); + + for (int ph = phstart; ph < phend; ++ph) { + for (int pw = pwstart; pw < pwend; ++pw) { + if (offset_argmax_data[(c * pooled_height + ph) * pooled_width + pw] == index) + { + gradient += offset_top_diff[(c * pooled_height + ph) * pooled_width + pw]; + } + } + } + } + bottom_diff[index] = gradient; + } +} + +int ROIPoolBackwardLaucher(const float* top_diff, const float spatial_scale, const int batch_size, const int num_rois, + const int height, const int width, const int channels, const int pooled_height, + const int pooled_width, const float* bottom_rois, + float* bottom_diff, const int* argmax_data, cudaStream_t stream) +{ + const int kThreadsPerBlock = 1024; + int output_size = batch_size * height * width * channels; + cudaError_t err; + + ROIPoolBackward<<<(output_size + kThreadsPerBlock - 1) / kThreadsPerBlock, kThreadsPerBlock, 0, stream>>>( + output_size, top_diff, argmax_data, num_rois, spatial_scale, height, width, channels, pooled_height, + pooled_width, bottom_diff, bottom_rois); + + // dim3 blocks(DIVUP(output_size, kThreadsPerBlock), + // DIVUP(output_size, kThreadsPerBlock)); + // dim3 threads(kThreadsPerBlock); + // + // ROIPoolBackward<<>>( + // output_size, top_diff, argmax_data, num_rois, spatial_scale, height, width, channels, pooled_height, + // pooled_width, bottom_diff, bottom_rois); + + err = cudaGetLastError(); + if(cudaSuccess != err) + { + fprintf( stderr, "cudaCheckError() failed : %s\n", cudaGetErrorString( err ) ); + exit( -1 ); + } + + return 1; +} + + +// #ifdef __cplusplus +// } +// #endif diff --git a/lib/model/roi_pooling/src/roi_pooling_kernel.h b/lib/model/roi_pooling/src/roi_pooling_kernel.h new file mode 100644 index 0000000..f6e68eb --- /dev/null +++ b/lib/model/roi_pooling/src/roi_pooling_kernel.h @@ -0,0 +1,25 @@ +#ifndef _ROI_POOLING_KERNEL +#define _ROI_POOLING_KERNEL + +#ifdef __cplusplus +extern "C" { +#endif + +int ROIPoolForwardLaucher( + const float* bottom_data, const float spatial_scale, const int num_rois, const int height, + const int width, const int channels, const int pooled_height, + const int pooled_width, const float* bottom_rois, + float* top_data, int* argmax_data, cudaStream_t stream); + + +int ROIPoolBackwardLaucher(const float* top_diff, const float spatial_scale, const int batch_size, const int num_rois, + const int height, const int width, const int channels, const int pooled_height, + const int pooled_width, const float* bottom_rois, + float* bottom_diff, const int* argmax_data, cudaStream_t stream); + +#ifdef __cplusplus +} +#endif + +#endif + diff --git a/lib/model/rpn/__init__.py b/lib/model/rpn/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/lib/model/rpn/anchor_target_layer.py b/lib/model/rpn/anchor_target_layer.py new file mode 100644 index 0000000..6355b65 --- /dev/null +++ b/lib/model/rpn/anchor_target_layer.py @@ -0,0 +1,219 @@ +from __future__ import absolute_import +# -------------------------------------------------------- +# Faster R-CNN +# Copyright (c) 2015 Microsoft +# Licensed under The MIT License [see LICENSE for details] +# Written by Ross Girshick and Sean Bell +# -------------------------------------------------------- +# -------------------------------------------------------- +# Reorganized and modified by Jianwei Yang and Jiasen Lu +# -------------------------------------------------------- + +import torch +import torch.nn as nn +import numpy as np +import numpy.random as npr + +from model.utils.config import cfg +from .generate_anchors import generate_anchors +from .bbox_transform import clip_boxes, bbox_overlaps_batch, bbox_transform_batch + +import pdb + +DEBUG = False + +try: + long # Python 2 +except NameError: + long = int # Python 3 + + +class _AnchorTargetLayer(nn.Module): + """ + Assign anchors to ground-truth targets. Produces anchor classification + labels and bounding-box regression targets. + """ + def __init__(self, feat_stride, scales, ratios): + super(_AnchorTargetLayer, self).__init__() + + self._feat_stride = feat_stride + self._scales = scales + anchor_scales = scales + self._anchors = torch.from_numpy(generate_anchors(scales=np.array(anchor_scales), ratios=np.array(ratios))).float() + self._num_anchors = self._anchors.size(0) + + # allow boxes to sit over the edge by a small amount + self._allowed_border = 0 # default is 0 + + def forward(self, input): + # Algorithm: + # + # for each (H, W) location i + # generate 9 anchor boxes centered on cell i + # apply predicted bbox deltas at cell i to each of the 9 anchors + # filter out-of-image anchors + + rpn_cls_score = input[0] + gt_boxes = input[1] + im_info = input[2] + num_boxes = input[3] + + # map of shape (..., H, W) + height, width = rpn_cls_score.size(2), rpn_cls_score.size(3) + + batch_size = gt_boxes.size(0) + + feat_height, feat_width = rpn_cls_score.size(2), rpn_cls_score.size(3) + shift_x = np.arange(0, feat_width) * self._feat_stride + shift_y = np.arange(0, feat_height) * self._feat_stride + shift_x, shift_y = np.meshgrid(shift_x, shift_y) + shifts = torch.from_numpy(np.vstack((shift_x.ravel(), shift_y.ravel(), + shift_x.ravel(), shift_y.ravel())).transpose()) + shifts = shifts.contiguous().type_as(rpn_cls_score).float() + + A = self._num_anchors + K = shifts.size(0) + + self._anchors = self._anchors.type_as(gt_boxes) # move to specific gpu. + all_anchors = self._anchors.view(1, A, 4) + shifts.view(K, 1, 4) + all_anchors = all_anchors.view(K * A, 4) + + total_anchors = int(K * A) + + keep = ((all_anchors[:, 0] >= -self._allowed_border) & + (all_anchors[:, 1] >= -self._allowed_border) & + (all_anchors[:, 2] < long(im_info[0][1]) + self._allowed_border) & + (all_anchors[:, 3] < long(im_info[0][0]) + self._allowed_border)) + + inds_inside = torch.nonzero(keep).view(-1) + + # keep only inside anchors + anchors = all_anchors[inds_inside, :] + + # label: 1 is positive, 0 is negative, -1 is dont care + labels = gt_boxes.new(batch_size, inds_inside.size(0)).fill_(-1) + bbox_inside_weights = gt_boxes.new(batch_size, inds_inside.size(0)).zero_() + bbox_outside_weights = gt_boxes.new(batch_size, inds_inside.size(0)).zero_() + + overlaps = bbox_overlaps_batch(anchors, gt_boxes) + + max_overlaps, argmax_overlaps = torch.max(overlaps, 2) + gt_max_overlaps, _ = torch.max(overlaps, 1) + + if not cfg.TRAIN.RPN_CLOBBER_POSITIVES: + labels[max_overlaps < cfg.TRAIN.RPN_NEGATIVE_OVERLAP] = 0 + + gt_max_overlaps[gt_max_overlaps==0] = 1e-5 + keep = torch.sum(overlaps.eq(gt_max_overlaps.view(batch_size,1,-1).expand_as(overlaps)), 2) + + if torch.sum(keep) > 0: + labels[keep>0] = 1 + + # fg label: above threshold IOU + labels[max_overlaps >= cfg.TRAIN.RPN_POSITIVE_OVERLAP] = 1 + + if cfg.TRAIN.RPN_CLOBBER_POSITIVES: + labels[max_overlaps < cfg.TRAIN.RPN_NEGATIVE_OVERLAP] = 0 + + num_fg = int(cfg.TRAIN.RPN_FG_FRACTION * cfg.TRAIN.RPN_BATCHSIZE) + + sum_fg = torch.sum((labels == 1).int(), 1) + sum_bg = torch.sum((labels == 0).int(), 1) + + for i in range(batch_size): + # subsample positive labels if we have too many + if sum_fg[i] > num_fg: + fg_inds = torch.nonzero(labels[i] == 1).view(-1) + # torch.randperm seems has a bug on multi-gpu setting that cause the segfault. + # See https://github.com/pytorch/pytorch/issues/1868 for more details. + # use numpy instead. + #rand_num = torch.randperm(fg_inds.size(0)).type_as(gt_boxes).long() + rand_num = torch.from_numpy(np.random.permutation(fg_inds.size(0))).type_as(gt_boxes).long() + disable_inds = fg_inds[rand_num[:fg_inds.size(0)-num_fg]] + labels[i][disable_inds] = -1 + + # num_bg = cfg.TRAIN.RPN_BATCHSIZE - sum_fg[i] + num_bg = cfg.TRAIN.RPN_BATCHSIZE - torch.sum((labels == 1).int(), 1)[i] + + # subsample negative labels if we have too many + if sum_bg[i] > num_bg: + bg_inds = torch.nonzero(labels[i] == 0).view(-1) + #rand_num = torch.randperm(bg_inds.size(0)).type_as(gt_boxes).long() + + rand_num = torch.from_numpy(np.random.permutation(bg_inds.size(0))).type_as(gt_boxes).long() + disable_inds = bg_inds[rand_num[:bg_inds.size(0)-num_bg]] + labels[i][disable_inds] = -1 + + offset = torch.arange(0, batch_size)*gt_boxes.size(1) + + argmax_overlaps = argmax_overlaps + offset.view(batch_size, 1).type_as(argmax_overlaps) + bbox_targets = _compute_targets_batch(anchors, gt_boxes.view(-1,5)[argmax_overlaps.view(-1), :].view(batch_size, -1, 5)) + + # use a single value instead of 4 values for easy index. + bbox_inside_weights[labels==1] = cfg.TRAIN.RPN_BBOX_INSIDE_WEIGHTS[0] + + if cfg.TRAIN.RPN_POSITIVE_WEIGHT < 0: + num_examples = torch.sum(labels[i] >= 0) + positive_weights = 1.0 / num_examples.item() + negative_weights = 1.0 / num_examples.item() + else: + assert ((cfg.TRAIN.RPN_POSITIVE_WEIGHT > 0) & + (cfg.TRAIN.RPN_POSITIVE_WEIGHT < 1)) + + bbox_outside_weights[labels == 1] = positive_weights + bbox_outside_weights[labels == 0] = negative_weights + + labels = _unmap(labels, total_anchors, inds_inside, batch_size, fill=-1) + bbox_targets = _unmap(bbox_targets, total_anchors, inds_inside, batch_size, fill=0) + bbox_inside_weights = _unmap(bbox_inside_weights, total_anchors, inds_inside, batch_size, fill=0) + bbox_outside_weights = _unmap(bbox_outside_weights, total_anchors, inds_inside, batch_size, fill=0) + + outputs = [] + + labels = labels.view(batch_size, height, width, A).permute(0,3,1,2).contiguous() + labels = labels.view(batch_size, 1, A * height, width) + outputs.append(labels) + + bbox_targets = bbox_targets.view(batch_size, height, width, A*4).permute(0,3,1,2).contiguous() + outputs.append(bbox_targets) + + anchors_count = bbox_inside_weights.size(1) + bbox_inside_weights = bbox_inside_weights.view(batch_size,anchors_count,1).expand(batch_size, anchors_count, 4) + + bbox_inside_weights = bbox_inside_weights.contiguous().view(batch_size, height, width, 4*A)\ + .permute(0,3,1,2).contiguous() + + outputs.append(bbox_inside_weights) + + bbox_outside_weights = bbox_outside_weights.view(batch_size,anchors_count,1).expand(batch_size, anchors_count, 4) + bbox_outside_weights = bbox_outside_weights.contiguous().view(batch_size, height, width, 4*A)\ + .permute(0,3,1,2).contiguous() + outputs.append(bbox_outside_weights) + + return outputs + + def backward(self, top, propagate_down, bottom): + """This layer does not propagate gradients.""" + pass + + def reshape(self, bottom, top): + """Reshaping happens during the call to forward.""" + pass + +def _unmap(data, count, inds, batch_size, fill=0): + """ Unmap a subset of item (data) back to the original set of items (of + size count) """ + + if data.dim() == 2: + ret = torch.Tensor(batch_size, count).fill_(fill).type_as(data) + ret[:, inds] = data + else: + ret = torch.Tensor(batch_size, count, data.size(2)).fill_(fill).type_as(data) + ret[:, inds,:] = data + return ret + + +def _compute_targets_batch(ex_rois, gt_rois): + """Compute bounding-box regression targets for an image.""" + + return bbox_transform_batch(ex_rois, gt_rois[:, :, :4]) diff --git a/lib/model/rpn/bbox_transform.py b/lib/model/rpn/bbox_transform.py new file mode 100644 index 0000000..450de0f --- /dev/null +++ b/lib/model/rpn/bbox_transform.py @@ -0,0 +1,257 @@ +# -------------------------------------------------------- +# Fast R-CNN +# Copyright (c) 2015 Microsoft +# Licensed under The MIT License [see LICENSE for details] +# Written by Ross Girshick +# -------------------------------------------------------- +# -------------------------------------------------------- +# Reorganized and modified by Jianwei Yang and Jiasen Lu +# -------------------------------------------------------- + +import torch +import numpy as np +import pdb + +def bbox_transform(ex_rois, gt_rois): + ex_widths = ex_rois[:, 2] - ex_rois[:, 0] + 1.0 + ex_heights = ex_rois[:, 3] - ex_rois[:, 1] + 1.0 + ex_ctr_x = ex_rois[:, 0] + 0.5 * ex_widths + ex_ctr_y = ex_rois[:, 1] + 0.5 * ex_heights + + gt_widths = gt_rois[:, 2] - gt_rois[:, 0] + 1.0 + gt_heights = gt_rois[:, 3] - gt_rois[:, 1] + 1.0 + gt_ctr_x = gt_rois[:, 0] + 0.5 * gt_widths + gt_ctr_y = gt_rois[:, 1] + 0.5 * gt_heights + + targets_dx = (gt_ctr_x - ex_ctr_x) / ex_widths + targets_dy = (gt_ctr_y - ex_ctr_y) / ex_heights + targets_dw = torch.log(gt_widths / ex_widths) + targets_dh = torch.log(gt_heights / ex_heights) + + targets = torch.stack( + (targets_dx, targets_dy, targets_dw, targets_dh),1) + + return targets + +def bbox_transform_batch(ex_rois, gt_rois): + + if ex_rois.dim() == 2: + ex_widths = ex_rois[:, 2] - ex_rois[:, 0] + 1.0 + ex_heights = ex_rois[:, 3] - ex_rois[:, 1] + 1.0 + ex_ctr_x = ex_rois[:, 0] + 0.5 * ex_widths + ex_ctr_y = ex_rois[:, 1] + 0.5 * ex_heights + + gt_widths = gt_rois[:, :, 2] - gt_rois[:, :, 0] + 1.0 + gt_heights = gt_rois[:, :, 3] - gt_rois[:, :, 1] + 1.0 + gt_ctr_x = gt_rois[:, :, 0] + 0.5 * gt_widths + gt_ctr_y = gt_rois[:, :, 1] + 0.5 * gt_heights + + targets_dx = (gt_ctr_x - ex_ctr_x.view(1,-1).expand_as(gt_ctr_x)) / ex_widths + targets_dy = (gt_ctr_y - ex_ctr_y.view(1,-1).expand_as(gt_ctr_y)) / ex_heights + targets_dw = torch.log(gt_widths / ex_widths.view(1,-1).expand_as(gt_widths)) + targets_dh = torch.log(gt_heights / ex_heights.view(1,-1).expand_as(gt_heights)) + + elif ex_rois.dim() == 3: + ex_widths = ex_rois[:, :, 2] - ex_rois[:, :, 0] + 1.0 + ex_heights = ex_rois[:,:, 3] - ex_rois[:,:, 1] + 1.0 + ex_ctr_x = ex_rois[:, :, 0] + 0.5 * ex_widths + ex_ctr_y = ex_rois[:, :, 1] + 0.5 * ex_heights + + gt_widths = gt_rois[:, :, 2] - gt_rois[:, :, 0] + 1.0 + gt_heights = gt_rois[:, :, 3] - gt_rois[:, :, 1] + 1.0 + gt_ctr_x = gt_rois[:, :, 0] + 0.5 * gt_widths + gt_ctr_y = gt_rois[:, :, 1] + 0.5 * gt_heights + + targets_dx = (gt_ctr_x - ex_ctr_x) / ex_widths + targets_dy = (gt_ctr_y - ex_ctr_y) / ex_heights + targets_dw = torch.log(gt_widths / ex_widths) + targets_dh = torch.log(gt_heights / ex_heights) + else: + raise ValueError('ex_roi input dimension is not correct.') + + targets = torch.stack( + (targets_dx, targets_dy, targets_dw, targets_dh),2) + + return targets + +def bbox_transform_inv(boxes, deltas, batch_size): + widths = boxes[:, :, 2] - boxes[:, :, 0] + 1.0 + heights = boxes[:, :, 3] - boxes[:, :, 1] + 1.0 + ctr_x = boxes[:, :, 0] + 0.5 * widths + ctr_y = boxes[:, :, 1] + 0.5 * heights + + dx = deltas[:, :, 0::4] + dy = deltas[:, :, 1::4] + dw = deltas[:, :, 2::4] + dh = deltas[:, :, 3::4] + + pred_ctr_x = dx * widths.unsqueeze(2) + ctr_x.unsqueeze(2) + pred_ctr_y = dy * heights.unsqueeze(2) + ctr_y.unsqueeze(2) + pred_w = torch.exp(dw) * widths.unsqueeze(2) + pred_h = torch.exp(dh) * heights.unsqueeze(2) + + pred_boxes = deltas.clone() + # x1 + pred_boxes[:, :, 0::4] = pred_ctr_x - 0.5 * pred_w + # y1 + pred_boxes[:, :, 1::4] = pred_ctr_y - 0.5 * pred_h + # x2 + pred_boxes[:, :, 2::4] = pred_ctr_x + 0.5 * pred_w + # y2 + pred_boxes[:, :, 3::4] = pred_ctr_y + 0.5 * pred_h + + return pred_boxes + +def clip_boxes_batch(boxes, im_shape, batch_size): + """ + Clip boxes to image boundaries. + """ + num_rois = boxes.size(1) + + boxes[boxes < 0] = 0 + # batch_x = (im_shape[:,0]-1).view(batch_size, 1).expand(batch_size, num_rois) + # batch_y = (im_shape[:,1]-1).view(batch_size, 1).expand(batch_size, num_rois) + + batch_x = im_shape[:, 1] - 1 + batch_y = im_shape[:, 0] - 1 + + boxes[:,:,0][boxes[:,:,0] > batch_x] = batch_x + boxes[:,:,1][boxes[:,:,1] > batch_y] = batch_y + boxes[:,:,2][boxes[:,:,2] > batch_x] = batch_x + boxes[:,:,3][boxes[:,:,3] > batch_y] = batch_y + + return boxes + +def clip_boxes(boxes, im_shape, batch_size): + + for i in range(batch_size): + boxes[i,:,0::4].clamp_(0, im_shape[i, 1]-1) + boxes[i,:,1::4].clamp_(0, im_shape[i, 0]-1) + boxes[i,:,2::4].clamp_(0, im_shape[i, 1]-1) + boxes[i,:,3::4].clamp_(0, im_shape[i, 0]-1) + + return boxes + + +def bbox_overlaps(anchors, gt_boxes): + """ + anchors: (N, 4) ndarray of float + gt_boxes: (K, 4) ndarray of float + + overlaps: (N, K) ndarray of overlap between boxes and query_boxes + """ + N = anchors.size(0) + K = gt_boxes.size(0) + + gt_boxes_area = ((gt_boxes[:,2] - gt_boxes[:,0] + 1) * + (gt_boxes[:,3] - gt_boxes[:,1] + 1)).view(1, K) + + anchors_area = ((anchors[:,2] - anchors[:,0] + 1) * + (anchors[:,3] - anchors[:,1] + 1)).view(N, 1) + + boxes = anchors.view(N, 1, 4).expand(N, K, 4) + query_boxes = gt_boxes.view(1, K, 4).expand(N, K, 4) + + iw = (torch.min(boxes[:,:,2], query_boxes[:,:,2]) - + torch.max(boxes[:,:,0], query_boxes[:,:,0]) + 1) + iw[iw < 0] = 0 + + ih = (torch.min(boxes[:,:,3], query_boxes[:,:,3]) - + torch.max(boxes[:,:,1], query_boxes[:,:,1]) + 1) + ih[ih < 0] = 0 + + ua = anchors_area + gt_boxes_area - (iw * ih) + overlaps = iw * ih / ua + + return overlaps + +def bbox_overlaps_batch(anchors, gt_boxes): + """ + anchors: (N, 4) ndarray of float + gt_boxes: (b, K, 5) ndarray of float + + overlaps: (N, K) ndarray of overlap between boxes and query_boxes + """ + batch_size = gt_boxes.size(0) + + + if anchors.dim() == 2: + + N = anchors.size(0) + K = gt_boxes.size(1) + + anchors = anchors.view(1, N, 4).expand(batch_size, N, 4).contiguous() + gt_boxes = gt_boxes[:,:,:4].contiguous() + + + gt_boxes_x = (gt_boxes[:,:,2] - gt_boxes[:,:,0] + 1) + gt_boxes_y = (gt_boxes[:,:,3] - gt_boxes[:,:,1] + 1) + gt_boxes_area = (gt_boxes_x * gt_boxes_y).view(batch_size, 1, K) + + anchors_boxes_x = (anchors[:,:,2] - anchors[:,:,0] + 1) + anchors_boxes_y = (anchors[:,:,3] - anchors[:,:,1] + 1) + anchors_area = (anchors_boxes_x * anchors_boxes_y).view(batch_size, N, 1) + + gt_area_zero = (gt_boxes_x == 1) & (gt_boxes_y == 1) + anchors_area_zero = (anchors_boxes_x == 1) & (anchors_boxes_y == 1) + + boxes = anchors.view(batch_size, N, 1, 4).expand(batch_size, N, K, 4) + query_boxes = gt_boxes.view(batch_size, 1, K, 4).expand(batch_size, N, K, 4) + + iw = (torch.min(boxes[:,:,:,2], query_boxes[:,:,:,2]) - + torch.max(boxes[:,:,:,0], query_boxes[:,:,:,0]) + 1) + iw[iw < 0] = 0 + + ih = (torch.min(boxes[:,:,:,3], query_boxes[:,:,:,3]) - + torch.max(boxes[:,:,:,1], query_boxes[:,:,:,1]) + 1) + ih[ih < 0] = 0 + ua = anchors_area + gt_boxes_area - (iw * ih) + overlaps = iw * ih / ua + + # mask the overlap here. + overlaps.masked_fill_(gt_area_zero.view(batch_size, 1, K).expand(batch_size, N, K), 0) + overlaps.masked_fill_(anchors_area_zero.view(batch_size, N, 1).expand(batch_size, N, K), -1) + + elif anchors.dim() == 3: + N = anchors.size(1) + K = gt_boxes.size(1) + + if anchors.size(2) == 4: + anchors = anchors[:,:,:4].contiguous() + else: + anchors = anchors[:,:,1:5].contiguous() + + gt_boxes = gt_boxes[:,:,:4].contiguous() + + gt_boxes_x = (gt_boxes[:,:,2] - gt_boxes[:,:,0] + 1) + gt_boxes_y = (gt_boxes[:,:,3] - gt_boxes[:,:,1] + 1) + gt_boxes_area = (gt_boxes_x * gt_boxes_y).view(batch_size, 1, K) + + anchors_boxes_x = (anchors[:,:,2] - anchors[:,:,0] + 1) + anchors_boxes_y = (anchors[:,:,3] - anchors[:,:,1] + 1) + anchors_area = (anchors_boxes_x * anchors_boxes_y).view(batch_size, N, 1) + + gt_area_zero = (gt_boxes_x == 1) & (gt_boxes_y == 1) + anchors_area_zero = (anchors_boxes_x == 1) & (anchors_boxes_y == 1) + + boxes = anchors.view(batch_size, N, 1, 4).expand(batch_size, N, K, 4) + query_boxes = gt_boxes.view(batch_size, 1, K, 4).expand(batch_size, N, K, 4) + + iw = (torch.min(boxes[:,:,:,2], query_boxes[:,:,:,2]) - + torch.max(boxes[:,:,:,0], query_boxes[:,:,:,0]) + 1) + iw[iw < 0] = 0 + + ih = (torch.min(boxes[:,:,:,3], query_boxes[:,:,:,3]) - + torch.max(boxes[:,:,:,1], query_boxes[:,:,:,1]) + 1) + ih[ih < 0] = 0 + ua = anchors_area + gt_boxes_area - (iw * ih) + + overlaps = iw * ih / ua + + # mask the overlap here. + overlaps.masked_fill_(gt_area_zero.view(batch_size, 1, K).expand(batch_size, N, K), 0) + overlaps.masked_fill_(anchors_area_zero.view(batch_size, N, 1).expand(batch_size, N, K), -1) + else: + raise ValueError('anchors input dimension is not correct.') + + return overlaps diff --git a/lib/model/rpn/generate_anchors.py b/lib/model/rpn/generate_anchors.py new file mode 100644 index 0000000..4d0a22b --- /dev/null +++ b/lib/model/rpn/generate_anchors.py @@ -0,0 +1,113 @@ +from __future__ import print_function +# -------------------------------------------------------- +# Faster R-CNN +# Copyright (c) 2015 Microsoft +# Licensed under The MIT License [see LICENSE for details] +# Written by Ross Girshick and Sean Bell +# -------------------------------------------------------- + +import numpy as np +import pdb + +# Verify that we compute the same anchors as Shaoqing's matlab implementation: +# +# >> load output/rpn_cachedir/faster_rcnn_VOC2007_ZF_stage1_rpn/anchors.mat +# >> anchors +# +# anchors = +# +# -83 -39 100 56 +# -175 -87 192 104 +# -359 -183 376 200 +# -55 -55 72 72 +# -119 -119 136 136 +# -247 -247 264 264 +# -35 -79 52 96 +# -79 -167 96 184 +# -167 -343 184 360 + +#array([[ -83., -39., 100., 56.], +# [-175., -87., 192., 104.], +# [-359., -183., 376., 200.], +# [ -55., -55., 72., 72.], +# [-119., -119., 136., 136.], +# [-247., -247., 264., 264.], +# [ -35., -79., 52., 96.], +# [ -79., -167., 96., 184.], +# [-167., -343., 184., 360.]]) + +try: + xrange # Python 2 +except NameError: + xrange = range # Python 3 + + +def generate_anchors(base_size=16, ratios=[0.5, 1, 2], + scales=2**np.arange(3, 6)): + """ + Generate anchor (reference) windows by enumerating aspect ratios X + scales wrt a reference (0, 0, 15, 15) window. + """ + + base_anchor = np.array([1, 1, base_size, base_size]) - 1 + ratio_anchors = _ratio_enum(base_anchor, ratios) + anchors = np.vstack([_scale_enum(ratio_anchors[i, :], scales) + for i in xrange(ratio_anchors.shape[0])]) + return anchors + +def _whctrs(anchor): + """ + Return width, height, x center, and y center for an anchor (window). + """ + + w = anchor[2] - anchor[0] + 1 + h = anchor[3] - anchor[1] + 1 + x_ctr = anchor[0] + 0.5 * (w - 1) + y_ctr = anchor[1] + 0.5 * (h - 1) + return w, h, x_ctr, y_ctr + +def _mkanchors(ws, hs, x_ctr, y_ctr): + """ + Given a vector of widths (ws) and heights (hs) around a center + (x_ctr, y_ctr), output a set of anchors (windows). + """ + + ws = ws[:, np.newaxis] + hs = hs[:, np.newaxis] + anchors = np.hstack((x_ctr - 0.5 * (ws - 1), + y_ctr - 0.5 * (hs - 1), + x_ctr + 0.5 * (ws - 1), + y_ctr + 0.5 * (hs - 1))) + return anchors + +def _ratio_enum(anchor, ratios): + """ + Enumerate a set of anchors for each aspect ratio wrt an anchor. + """ + + w, h, x_ctr, y_ctr = _whctrs(anchor) + size = w * h + size_ratios = size / ratios + ws = np.round(np.sqrt(size_ratios)) + hs = np.round(ws * ratios) + anchors = _mkanchors(ws, hs, x_ctr, y_ctr) + return anchors + +def _scale_enum(anchor, scales): + """ + Enumerate a set of anchors for each scale wrt an anchor. + """ + + w, h, x_ctr, y_ctr = _whctrs(anchor) + ws = w * scales + hs = h * scales + anchors = _mkanchors(ws, hs, x_ctr, y_ctr) + return anchors + +if __name__ == '__main__': + import time + t = time.time() + a = generate_anchors() + print(time.time() - t) + print(a) + from IPython import embed; embed() diff --git a/lib/model/rpn/proposal_layer.py b/lib/model/rpn/proposal_layer.py new file mode 100644 index 0000000..9c787da --- /dev/null +++ b/lib/model/rpn/proposal_layer.py @@ -0,0 +1,175 @@ +from __future__ import absolute_import +# -------------------------------------------------------- +# Faster R-CNN +# Copyright (c) 2015 Microsoft +# Licensed under The MIT License [see LICENSE for details] +# Written by Ross Girshick and Sean Bell +# -------------------------------------------------------- +# -------------------------------------------------------- +# Reorganized and modified by Jianwei Yang and Jiasen Lu +# -------------------------------------------------------- + +import torch +import torch.nn as nn +import numpy as np +import math +import yaml +from model.utils.config import cfg +from .generate_anchors import generate_anchors +from .bbox_transform import bbox_transform_inv, clip_boxes, clip_boxes_batch +# from model.nms.nms_wrapper import nms +from model.roi_layers import nms +import pdb + +DEBUG = False + +class _ProposalLayer(nn.Module): + """ + Outputs object detection proposals by applying estimated bounding-box + transformations to a set of regular boxes (called "anchors"). + """ + + def __init__(self, feat_stride, scales, ratios): + super(_ProposalLayer, self).__init__() + + self._feat_stride = feat_stride + self._anchors = torch.from_numpy(generate_anchors(scales=np.array(scales), + ratios=np.array(ratios))).float() + self._num_anchors = self._anchors.size(0) + + # rois blob: holds R regions of interest, each is a 5-tuple + # (n, x1, y1, x2, y2) specifying an image batch index n and a + # rectangle (x1, y1, x2, y2) + # top[0].reshape(1, 5) + # + # # scores blob: holds scores for R regions of interest + # if len(top) > 1: + # top[1].reshape(1, 1, 1, 1) + + def forward(self, input): + + # Algorithm: + # + # for each (H, W) location i + # generate A anchor boxes centered on cell i + # apply predicted bbox deltas at cell i to each of the A anchors + # clip predicted boxes to image + # remove predicted boxes with either height or width < threshold + # sort all (proposal, score) pairs by score from highest to lowest + # take top pre_nms_topN proposals before NMS + # apply NMS with threshold 0.7 to remaining proposals + # take after_nms_topN proposals after NMS + # return the top proposals (-> RoIs top, scores top) + + + # the first set of _num_anchors channels are bg probs + # the second set are the fg probs + scores = input[0][:, self._num_anchors:, :, :] + bbox_deltas = input[1] + im_info = input[2] + cfg_key = input[3] + + pre_nms_topN = cfg[cfg_key].RPN_PRE_NMS_TOP_N + post_nms_topN = cfg[cfg_key].RPN_POST_NMS_TOP_N + nms_thresh = cfg[cfg_key].RPN_NMS_THRESH + min_size = cfg[cfg_key].RPN_MIN_SIZE + + batch_size = bbox_deltas.size(0) + + feat_height, feat_width = scores.size(2), scores.size(3) + shift_x = np.arange(0, feat_width) * self._feat_stride + shift_y = np.arange(0, feat_height) * self._feat_stride + shift_x, shift_y = np.meshgrid(shift_x, shift_y) + shifts = torch.from_numpy(np.vstack((shift_x.ravel(), shift_y.ravel(), + shift_x.ravel(), shift_y.ravel())).transpose()) + shifts = shifts.contiguous().type_as(scores).float() + + A = self._num_anchors + K = shifts.size(0) + + self._anchors = self._anchors.type_as(scores) + # anchors = self._anchors.view(1, A, 4) + shifts.view(1, K, 4).permute(1, 0, 2).contiguous() + anchors = self._anchors.view(1, A, 4) + shifts.view(K, 1, 4) + anchors = anchors.view(1, K * A, 4).expand(batch_size, K * A, 4) + + # Transpose and reshape predicted bbox transformations to get them + # into the same order as the anchors: + + bbox_deltas = bbox_deltas.permute(0, 2, 3, 1).contiguous() + bbox_deltas = bbox_deltas.view(batch_size, -1, 4) + + # Same story for the scores: + scores = scores.permute(0, 2, 3, 1).contiguous() + scores = scores.view(batch_size, -1) + + # Convert anchors into proposals via bbox transformations + proposals = bbox_transform_inv(anchors, bbox_deltas, batch_size) + + # 2. clip predicted boxes to image + proposals = clip_boxes(proposals, im_info, batch_size) + # proposals = clip_boxes_batch(proposals, im_info, batch_size) + + # assign the score to 0 if it's non keep. + # keep = self._filter_boxes(proposals, min_size * im_info[:, 2]) + + # trim keep index to make it euqal over batch + # keep_idx = torch.cat(tuple(keep_idx), 0) + + # scores_keep = scores.view(-1)[keep_idx].view(batch_size, trim_size) + # proposals_keep = proposals.view(-1, 4)[keep_idx, :].contiguous().view(batch_size, trim_size, 4) + + # _, order = torch.sort(scores_keep, 1, True) + + scores_keep = scores + proposals_keep = proposals + _, order = torch.sort(scores_keep, 1, True) + + output = scores.new(batch_size, post_nms_topN, 5).zero_() + for i in range(batch_size): + # # 3. remove predicted boxes with either height or width < threshold + # # (NOTE: convert min_size to input image scale stored in im_info[2]) + proposals_single = proposals_keep[i] + scores_single = scores_keep[i] + + # # 4. sort all (proposal, score) pairs by score from highest to lowest + # # 5. take top pre_nms_topN (e.g. 6000) + order_single = order[i] + + if pre_nms_topN > 0 and pre_nms_topN < scores_keep.numel(): + order_single = order_single[:pre_nms_topN] + + proposals_single = proposals_single[order_single, :] + scores_single = scores_single[order_single].view(-1,1) + + # 6. apply nms (e.g. threshold = 0.7) + # 7. take after_nms_topN (e.g. 300) + # 8. return the top proposals (-> RoIs top) + keep_idx_i = nms(proposals_single, scores_single.squeeze(1), nms_thresh) + keep_idx_i = keep_idx_i.long().view(-1) + + if post_nms_topN > 0: + keep_idx_i = keep_idx_i[:post_nms_topN] + proposals_single = proposals_single[keep_idx_i, :] + scores_single = scores_single[keep_idx_i, :] + + # padding 0 at the end. + num_proposal = proposals_single.size(0) + output[i,:,0] = i + output[i,:num_proposal,1:] = proposals_single + + return output + + def backward(self, top, propagate_down, bottom): + """This layer does not propagate gradients.""" + pass + + def reshape(self, bottom, top): + """Reshaping happens during the call to forward.""" + pass + + def _filter_boxes(self, boxes, min_size): + """Remove all boxes with any side smaller than min_size.""" + ws = boxes[:, :, 2] - boxes[:, :, 0] + 1 + hs = boxes[:, :, 3] - boxes[:, :, 1] + 1 + keep = ((ws >= min_size.view(-1,1).expand_as(ws)) & (hs >= min_size.view(-1,1).expand_as(hs))) + return keep diff --git a/lib/model/rpn/proposal_target_layer_cascade.py b/lib/model/rpn/proposal_target_layer_cascade.py new file mode 100644 index 0000000..eb8b577 --- /dev/null +++ b/lib/model/rpn/proposal_target_layer_cascade.py @@ -0,0 +1,214 @@ +from __future__ import absolute_import +# -------------------------------------------------------- +# Faster R-CNN +# Copyright (c) 2015 Microsoft +# Licensed under The MIT License [see LICENSE for details] +# Written by Ross Girshick and Sean Bell +# -------------------------------------------------------- +# -------------------------------------------------------- +# Reorganized and modified by Jianwei Yang and Jiasen Lu +# -------------------------------------------------------- + +import torch +import torch.nn as nn +import numpy as np +import numpy.random as npr +from ..utils.config import cfg +from .bbox_transform import bbox_overlaps_batch, bbox_transform_batch +import pdb + +class _ProposalTargetLayer(nn.Module): + """ + Assign object detection proposals to ground-truth targets. Produces proposal + classification labels and bounding-box regression targets. + """ + + def __init__(self, nclasses): + super(_ProposalTargetLayer, self).__init__() + self._num_classes = nclasses + self.BBOX_NORMALIZE_MEANS = torch.FloatTensor(cfg.TRAIN.BBOX_NORMALIZE_MEANS) + self.BBOX_NORMALIZE_STDS = torch.FloatTensor(cfg.TRAIN.BBOX_NORMALIZE_STDS) + self.BBOX_INSIDE_WEIGHTS = torch.FloatTensor(cfg.TRAIN.BBOX_INSIDE_WEIGHTS) + + def forward(self, all_rois, gt_boxes, num_boxes): + + self.BBOX_NORMALIZE_MEANS = self.BBOX_NORMALIZE_MEANS.type_as(gt_boxes) + self.BBOX_NORMALIZE_STDS = self.BBOX_NORMALIZE_STDS.type_as(gt_boxes) + self.BBOX_INSIDE_WEIGHTS = self.BBOX_INSIDE_WEIGHTS.type_as(gt_boxes) + + gt_boxes_append = gt_boxes.new(gt_boxes.size()).zero_() + gt_boxes_append[:,:,1:5] = gt_boxes[:,:,:4] + + + # Include ground-truth boxes in the set of candidate rois + all_rois = torch.cat([all_rois, gt_boxes_append], 1) + + num_images = 1 + rois_per_image = int(cfg.TRAIN.BATCH_SIZE / num_images) + fg_rois_per_image = int(np.round(cfg.TRAIN.FG_FRACTION * rois_per_image)) + fg_rois_per_image = 1 if fg_rois_per_image == 0 else fg_rois_per_image + + labels, rois, bbox_targets, bbox_inside_weights = self._sample_rois_pytorch( + all_rois, gt_boxes, fg_rois_per_image, + rois_per_image, self._num_classes) + + bbox_outside_weights = (bbox_inside_weights > 0).float() + + return rois, labels, bbox_targets, bbox_inside_weights, bbox_outside_weights + + def backward(self, top, propagate_down, bottom): + """This layer does not propagate gradients.""" + pass + + def reshape(self, bottom, top): + """Reshaping happens during the call to forward.""" + pass + + def _get_bbox_regression_labels_pytorch(self, bbox_target_data, labels_batch, num_classes): + """Bounding-box regression targets (bbox_target_data) are stored in a + compact form b x N x (class, tx, ty, tw, th) + + This function expands those targets into the 4-of-4*K representation used + by the network (i.e. only one class has non-zero targets). + + Returns: + bbox_target (ndarray): b x N x 4K blob of regression targets + bbox_inside_weights (ndarray): b x N x 4K blob of loss weights + """ + batch_size = labels_batch.size(0) + rois_per_image = labels_batch.size(1) + clss = labels_batch + bbox_targets = bbox_target_data.new(batch_size, rois_per_image, 4).zero_() + bbox_inside_weights = bbox_target_data.new(bbox_targets.size()).zero_() + + for b in range(batch_size): + # assert clss[b].sum() > 0 + if clss[b].sum() == 0: + continue + inds = torch.nonzero(clss[b] > 0).view(-1) + for i in range(inds.numel()): + ind = inds[i] + bbox_targets[b, ind, :] = bbox_target_data[b, ind, :] + bbox_inside_weights[b, ind, :] = self.BBOX_INSIDE_WEIGHTS + + return bbox_targets, bbox_inside_weights + + + def _compute_targets_pytorch(self, ex_rois, gt_rois): + """Compute bounding-box regression targets for an image.""" + + assert ex_rois.size(1) == gt_rois.size(1) + assert ex_rois.size(2) == 4 + assert gt_rois.size(2) == 4 + + batch_size = ex_rois.size(0) + rois_per_image = ex_rois.size(1) + + targets = bbox_transform_batch(ex_rois, gt_rois) + + if cfg.TRAIN.BBOX_NORMALIZE_TARGETS_PRECOMPUTED: + # Optionally normalize targets by a precomputed mean and stdev + targets = ((targets - self.BBOX_NORMALIZE_MEANS.expand_as(targets)) + / self.BBOX_NORMALIZE_STDS.expand_as(targets)) + + return targets + + + def _sample_rois_pytorch(self, all_rois, gt_boxes, fg_rois_per_image, rois_per_image, num_classes): + """Generate a random sample of RoIs comprising foreground and background + examples. + """ + # overlaps: (rois x gt_boxes) + + overlaps = bbox_overlaps_batch(all_rois, gt_boxes) + + max_overlaps, gt_assignment = torch.max(overlaps, 2) + + batch_size = overlaps.size(0) + num_proposal = overlaps.size(1) + num_boxes_per_img = overlaps.size(2) + + offset = torch.arange(0, batch_size)*gt_boxes.size(1) + offset = offset.view(-1, 1).type_as(gt_assignment) + gt_assignment + + # changed indexing way for pytorch 1.0 + labels = gt_boxes[:,:,4].contiguous().view(-1)[(offset.view(-1),)].view(batch_size, -1) + + labels_batch = labels.new(batch_size, rois_per_image).zero_() + rois_batch = all_rois.new(batch_size, rois_per_image, 5).zero_() + gt_rois_batch = all_rois.new(batch_size, rois_per_image, 5).zero_() + # Guard against the case when an image has fewer than max_fg_rois_per_image + # foreground RoIs + for i in range(batch_size): + + fg_inds = torch.nonzero(max_overlaps[i] >= cfg.TRAIN.FG_THRESH).view(-1) + fg_num_rois = fg_inds.numel() + + # Select background RoIs as those within [BG_THRESH_LO, BG_THRESH_HI) + bg_inds = torch.nonzero((max_overlaps[i] < cfg.TRAIN.BG_THRESH_HI) & + (max_overlaps[i] >= cfg.TRAIN.BG_THRESH_LO)).view(-1) + bg_num_rois = bg_inds.numel() + + if fg_num_rois > 0 and bg_num_rois > 0: + # sampling fg + fg_rois_per_this_image = min(fg_rois_per_image, fg_num_rois) + + # torch.randperm seems has a bug on multi-gpu setting that cause the segfault. + # See https://github.com/pytorch/pytorch/issues/1868 for more details. + # use numpy instead. + #rand_num = torch.randperm(fg_num_rois).long().cuda() + rand_num = torch.from_numpy(np.random.permutation(fg_num_rois)).type_as(gt_boxes).long() + fg_inds = fg_inds[rand_num[:fg_rois_per_this_image]] + + # sampling bg + bg_rois_per_this_image = rois_per_image - fg_rois_per_this_image + + # Seems torch.rand has a bug, it will generate very large number and make an error. + # We use numpy rand instead. + #rand_num = (torch.rand(bg_rois_per_this_image) * bg_num_rois).long().cuda() + rand_num = np.floor(np.random.rand(bg_rois_per_this_image) * bg_num_rois) + rand_num = torch.from_numpy(rand_num).type_as(gt_boxes).long() + bg_inds = bg_inds[rand_num] + + elif fg_num_rois > 0 and bg_num_rois == 0: + # sampling fg + #rand_num = torch.floor(torch.rand(rois_per_image) * fg_num_rois).long().cuda() + rand_num = np.floor(np.random.rand(rois_per_image) * fg_num_rois) + rand_num = torch.from_numpy(rand_num).type_as(gt_boxes).long() + fg_inds = fg_inds[rand_num] + fg_rois_per_this_image = rois_per_image + bg_rois_per_this_image = 0 + elif bg_num_rois > 0 and fg_num_rois == 0: + # sampling bg + #rand_num = torch.floor(torch.rand(rois_per_image) * bg_num_rois).long().cuda() + rand_num = np.floor(np.random.rand(rois_per_image) * bg_num_rois) + rand_num = torch.from_numpy(rand_num).type_as(gt_boxes).long() + + bg_inds = bg_inds[rand_num] + bg_rois_per_this_image = rois_per_image + fg_rois_per_this_image = 0 + else: + raise ValueError("bg_num_rois = 0 and fg_num_rois = 0, this should not happen!") + + # The indices that we're selecting (both fg and bg) + keep_inds = torch.cat([fg_inds, bg_inds], 0) + + # Select sampled values from various arrays: + labels_batch[i].copy_(labels[i][keep_inds]) + + # Clamp labels for the background RoIs to 0 + if fg_rois_per_this_image < rois_per_image: + labels_batch[i][fg_rois_per_this_image:] = 0 + + rois_batch[i] = all_rois[i][keep_inds] + rois_batch[i,:,0] = i + + gt_rois_batch[i] = gt_boxes[i][gt_assignment[i][keep_inds]] + + bbox_target_data = self._compute_targets_pytorch( + rois_batch[:,:,1:5], gt_rois_batch[:,:,:4]) + + bbox_targets, bbox_inside_weights = \ + self._get_bbox_regression_labels_pytorch(bbox_target_data, labels_batch, num_classes) + + return labels_batch, rois_batch, bbox_targets, bbox_inside_weights diff --git a/lib/model/rpn/rpn.py b/lib/model/rpn/rpn.py new file mode 100644 index 0000000..a94ff90 --- /dev/null +++ b/lib/model/rpn/rpn.py @@ -0,0 +1,121 @@ +from __future__ import absolute_import +import torch +import torch.nn as nn +import torch.nn.functional as F +from torch.autograd import Variable + +from model.utils.config import cfg +from .proposal_layer import _ProposalLayer +from .anchor_target_layer import _AnchorTargetLayer +from model.utils.net_utils import _smooth_l1_loss + +import numpy as np +import math +import pdb +import time + +class _RPN(nn.Module): + """ region proposal network """ + def __init__(self, din): + super(_RPN, self).__init__() + + self.din = din # get depth of input feature map, e.g., 512 + self.anchor_scales = cfg.ANCHOR_SCALES + self.anchor_ratios = cfg.ANCHOR_RATIOS + self.feat_stride = cfg.FEAT_STRIDE[0] + + # define the convrelu layers processing input feature map + # self.mix_Conv = nn.Sequential( + # nn.Conv2d(self.din, 512, 3, 1, 1, bias=True), + # nn.BatchNorm2d(512), + # nn.ReLU(inplace=True) + # ) + self.RPN_Conv = nn.Conv2d(self.din, 512, 3, 1, 1, bias=True) + + # define bg/fg classifcation score layer + self.nc_score_out = len(self.anchor_scales) * len(self.anchor_ratios) * 2 # 2(bg/fg) * 9 (anchors) + self.RPN_cls_score = nn.Conv2d(512, self.nc_score_out, 1, 1, 0) + + # define anchor box offset prediction layer + self.nc_bbox_out = len(self.anchor_scales) * len(self.anchor_ratios) * 4 # 4(coords) * 9 (anchors) + + self.RPN_bbox_pred = nn.Conv2d(512, self.nc_bbox_out, 1, 1, 0) + + # define proposal layer + self.RPN_proposal = _ProposalLayer(self.feat_stride, self.anchor_scales, self.anchor_ratios) + + # define anchor target layer + self.RPN_anchor_target = _AnchorTargetLayer(self.feat_stride, self.anchor_scales, self.anchor_ratios) + + self.rpn_loss_cls = 0 + self.rpn_loss_box = 0 + + @staticmethod + def reshape(x, d): + input_shape = x.size() + x = x.view( + input_shape[0], + int(d), + int(float(input_shape[1] * input_shape[2]) / float(d)), + input_shape[3] + ) + return x + + def forward(self, base_feat, im_info, gt_boxes, num_boxes): + + batch_size = base_feat.size(0) + + # return feature map after convrelu layer + rpn_conv1 = F.relu(self.RPN_Conv(base_feat), inplace=True) + # get rpn classification score + + rpn_cls_score = self.RPN_cls_score(rpn_conv1) + + rpn_cls_score_reshape = self.reshape(rpn_cls_score, 2) + + rpn_cls_prob_reshape = F.softmax(rpn_cls_score_reshape, 1) + rpn_cls_prob = self.reshape(rpn_cls_prob_reshape, self.nc_score_out) + + + # get rpn offsets to the anchor boxes + rpn_bbox_pred = self.RPN_bbox_pred(rpn_conv1) + + # proposal layer + cfg_key = 'TRAIN' if self.training else 'TEST' + + rois = self.RPN_proposal((rpn_cls_prob.data, rpn_bbox_pred.data, + im_info, cfg_key)) + + self.rpn_loss_cls = 0 + self.rpn_loss_box = 0 + + + # generating training labels and build the rpn loss + if self.training: + assert gt_boxes is not None + + rpn_data = self.RPN_anchor_target((rpn_cls_score.data, gt_boxes, im_info, num_boxes)) + + # compute classification loss + rpn_cls_score = rpn_cls_score_reshape.permute(0, 2, 3, 1).contiguous().view(batch_size, -1, 2) + + rpn_label = rpn_data[0].view(batch_size, -1) + + rpn_keep = Variable(rpn_label.view(-1).ne(-1).nonzero().view(-1)) + + rpn_cls_score = torch.index_select(rpn_cls_score.view(-1,2), 0, rpn_keep) + rpn_label = torch.index_select(rpn_label.view(-1), 0, rpn_keep.data) + rpn_label = Variable(rpn_label.long()) + self.rpn_loss_cls = F.cross_entropy(rpn_cls_score, rpn_label) + fg_cnt = torch.sum(rpn_label.data.ne(0)) + + rpn_bbox_targets, rpn_bbox_inside_weights, rpn_bbox_outside_weights = rpn_data[1:] + + # compute bbox regression loss + rpn_bbox_inside_weights = Variable(rpn_bbox_inside_weights) + rpn_bbox_outside_weights = Variable(rpn_bbox_outside_weights) + rpn_bbox_targets = Variable(rpn_bbox_targets) + + self.rpn_loss_box = _smooth_l1_loss(rpn_bbox_pred, rpn_bbox_targets, rpn_bbox_inside_weights, + rpn_bbox_outside_weights, sigma=3, dim=[1,2,3]) + return rois, self.rpn_loss_cls, self.rpn_loss_box diff --git a/lib/model/utils/.gitignore b/lib/model/utils/.gitignore new file mode 100644 index 0000000..15a165d --- /dev/null +++ b/lib/model/utils/.gitignore @@ -0,0 +1,3 @@ +*.c +*.cpp +*.so diff --git a/lib/model/utils/__init__.py b/lib/model/utils/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/lib/model/utils/bbox.pyx b/lib/model/utils/bbox.pyx new file mode 100644 index 0000000..7a1bc89 --- /dev/null +++ b/lib/model/utils/bbox.pyx @@ -0,0 +1,105 @@ +# -------------------------------------------------------- +# Fast R-CNN +# Copyright (c) 2015 Microsoft +# Licensed under The MIT License [see LICENSE for details] +# Written by Sergey Karayev +# -------------------------------------------------------- + +cimport cython +import numpy as np +cimport numpy as np + +DTYPE = np.float +ctypedef np.float_t DTYPE_t + +def bbox_overlaps(np.ndarray[DTYPE_t, ndim=2] boxes, + np.ndarray[DTYPE_t, ndim=2] query_boxes): + return bbox_overlaps_c(boxes, query_boxes) + +cdef np.ndarray[DTYPE_t, ndim=2] bbox_overlaps_c( + np.ndarray[DTYPE_t, ndim=2] boxes, + np.ndarray[DTYPE_t, ndim=2] query_boxes): + """ + Parameters + ---------- + boxes: (N, 4) ndarray of float + query_boxes: (K, 4) ndarray of float + Returns + ------- + overlaps: (N, K) ndarray of overlap between boxes and query_boxes + """ + cdef unsigned int N = boxes.shape[0] + cdef unsigned int K = query_boxes.shape[0] + cdef np.ndarray[DTYPE_t, ndim=2] overlaps = np.zeros((N, K), dtype=DTYPE) + cdef DTYPE_t iw, ih, box_area + cdef DTYPE_t ua + cdef unsigned int k, n + for k in range(K): + box_area = ( + (query_boxes[k, 2] - query_boxes[k, 0] + 1) * + (query_boxes[k, 3] - query_boxes[k, 1] + 1) + ) + for n in range(N): + iw = ( + min(boxes[n, 2], query_boxes[k, 2]) - + max(boxes[n, 0], query_boxes[k, 0]) + 1 + ) + if iw > 0: + ih = ( + min(boxes[n, 3], query_boxes[k, 3]) - + max(boxes[n, 1], query_boxes[k, 1]) + 1 + ) + if ih > 0: + ua = float( + (boxes[n, 2] - boxes[n, 0] + 1) * + (boxes[n, 3] - boxes[n, 1] + 1) + + box_area - iw * ih + ) + overlaps[n, k] = iw * ih / ua + return overlaps + + +def bbox_intersections( + np.ndarray[DTYPE_t, ndim=2] boxes, + np.ndarray[DTYPE_t, ndim=2] query_boxes): + return bbox_intersections_c(boxes, query_boxes) + + +cdef np.ndarray[DTYPE_t, ndim=2] bbox_intersections_c( + np.ndarray[DTYPE_t, ndim=2] boxes, + np.ndarray[DTYPE_t, ndim=2] query_boxes): + """ + For each query box compute the intersection ratio covered by boxes + ---------- + Parameters + ---------- + boxes: (N, 4) ndarray of float + query_boxes: (K, 4) ndarray of float + Returns + ------- + overlaps: (N, K) ndarray of intersec between boxes and query_boxes + """ + cdef unsigned int N = boxes.shape[0] + cdef unsigned int K = query_boxes.shape[0] + cdef np.ndarray[DTYPE_t, ndim=2] intersec = np.zeros((N, K), dtype=DTYPE) + cdef DTYPE_t iw, ih, box_area + cdef DTYPE_t ua + cdef unsigned int k, n + for k in range(K): + box_area = ( + (query_boxes[k, 2] - query_boxes[k, 0] + 1) * + (query_boxes[k, 3] - query_boxes[k, 1] + 1) + ) + for n in range(N): + iw = ( + min(boxes[n, 2], query_boxes[k, 2]) - + max(boxes[n, 0], query_boxes[k, 0]) + 1 + ) + if iw > 0: + ih = ( + min(boxes[n, 3], query_boxes[k, 3]) - + max(boxes[n, 1], query_boxes[k, 1]) + 1 + ) + if ih > 0: + intersec[n, k] = iw * ih / box_area + return intersec \ No newline at end of file diff --git a/lib/model/utils/blob.py b/lib/model/utils/blob.py new file mode 100644 index 0000000..175360e --- /dev/null +++ b/lib/model/utils/blob.py @@ -0,0 +1,101 @@ +# -------------------------------------------------------- +# Fast R-CNN +# Copyright (c) 2015 Microsoft +# Licensed under The MIT License [see LICENSE for details] +# Written by Ross Girshick +# -------------------------------------------------------- + +"""Blob helper functions.""" + +import numpy as np +# from scipy.misc import imread, imresize +import cv2 + +try: + xrange # Python 2 +except NameError: + xrange = range # Python 3 + + +def im_list_to_blob(ims): + """Convert a list of images into a network input. + + Assumes images are already prepared (means subtracted, BGR order, ...). + """ + max_shape = np.array([im.shape for im in ims]).max(axis=0) + num_images = len(ims) + blob = np.zeros((num_images, max_shape[0], max_shape[1], 3), + dtype=np.float32) + for i in xrange(num_images): + im = ims[i] + blob[i, 0:im.shape[0], 0:im.shape[1], :] = im + + return blob + +def prep_im_for_blob(im, pixel_means, target_size, max_size): + """Mean subtract and scale an image for use in a blob.""" + + im = im.astype(np.float32, copy=False) + # changed to use pytorch models + im /= 255. # Convert range to [0,1] + # normalization for pytroch pretrained models. + # https://pytorch.org/docs/stable/torchvision/models.html + pixel_means = [0.485, 0.456, 0.406] + pixel_stdens = [0.229, 0.224, 0.225] + + # normalize manual + im -= pixel_means # Minus mean + im /= pixel_stdens # divide by stddev + + + # im = im[:, :, ::-1] + im_shape = im.shape + im_size_min = np.min(im_shape[0:2]) + im_size_max = np.max(im_shape[0:2]) + im_scale = float(target_size) / float(im_size_min) + # Prevent the biggest axis from being more than MAX_SIZE + # if np.round(im_scale * im_size_max) > max_size: + # im_scale = float(max_size) / float(im_size_max) + # im = imresize(im, im_scale) + im = cv2.resize(im, None, None, fx=im_scale, fy=im_scale, + interpolation=cv2.INTER_LINEAR) + # im = cv2.resize(im,(256, 256), + # interpolation=cv2.INTER_LINEAR) + + return im, im_scale + +def crop(image, purpose, size): + + h, w, c = image.shape + + # add_h = int(purpose[4]-purpose[2])/5 + # add_w = int(purpose[3]-purpose[1])/5 + + # purpose[2] = int(purpose[2])-add_h if (int(purpose[2])-add_h >0) else 0 + # purpose[4] = int(purpose[4])+add_h if (int(purpose[4])+add_h 0) else 0 + # purpose[3] = int(purpose[3])+add_w if (int(purpose[3])+add_w 0) +__C.TRAIN.FG_FRACTION = 0.25 + +# Overlap threshold for a ROI to be considered foreground (if >= FG_THRESH) +__C.TRAIN.FG_THRESH = 0.5 + +# Overlap threshold for a ROI to be considered background (class = 0 if +# overlap in [LO, HI)) +__C.TRAIN.BG_THRESH_HI = 0.5 +__C.TRAIN.BG_THRESH_LO = 0.1 + +# Use horizontally-flipped images during training? +__C.TRAIN.USE_FLIPPED = True + +# Train bounding-box regressors +__C.TRAIN.BBOX_REG = True + +# Overlap required between a ROI and ground-truth box in order for that ROI to +# be used as a bounding-box regression training example +__C.TRAIN.BBOX_THRESH = 0.5 + +# Iterations between snapshots +__C.TRAIN.SNAPSHOT_ITERS = 5000 + +# solver.prototxt specifies the snapshot path prefix, this adds an optional +# infix to yield the path: [_]_iters_XYZ.caffemodel +__C.TRAIN.SNAPSHOT_PREFIX = 'res101_faster_rcnn' +# __C.TRAIN.SNAPSHOT_INFIX = '' + +# Use a prefetch thread in roi_data_layer.layer +# So far I haven't found this useful; likely more engineering work is required +# __C.TRAIN.USE_PREFETCH = False + +# Normalize the targets (subtract empirical mean, divide by empirical stddev) +__C.TRAIN.BBOX_NORMALIZE_TARGETS = True +# Deprecated (inside weights) +__C.TRAIN.BBOX_INSIDE_WEIGHTS = (1.0, 1.0, 1.0, 1.0) +# Normalize the targets using "precomputed" (or made up) means and stdevs +# (BBOX_NORMALIZE_TARGETS must also be True) +__C.TRAIN.BBOX_NORMALIZE_TARGETS_PRECOMPUTED = True +__C.TRAIN.BBOX_NORMALIZE_MEANS = (0.0, 0.0, 0.0, 0.0) +__C.TRAIN.BBOX_NORMALIZE_STDS = (0.1, 0.1, 0.2, 0.2) + +# Train using these proposals +__C.TRAIN.PROPOSAL_METHOD = 'gt' + +# Make minibatches from images that have similar aspect ratios (i.e. both +# tall and thin or both short and wide) in order to avoid wasting computation +# on zero-padding. + +# Use RPN to detect objects +__C.TRAIN.HAS_RPN = True +# IOU >= thresh: positive example +__C.TRAIN.RPN_POSITIVE_OVERLAP = 0.7 +# IOU < thresh: negative example +__C.TRAIN.RPN_NEGATIVE_OVERLAP = 0.3 +# If an anchor statisfied by positive and negative conditions set to negative +__C.TRAIN.RPN_CLOBBER_POSITIVES = False +# Max number of foreground examples +__C.TRAIN.RPN_FG_FRACTION = 0.5 +# Total number of examples +__C.TRAIN.RPN_BATCHSIZE = 256 +# NMS threshold used on RPN proposals +__C.TRAIN.RPN_NMS_THRESH = 0.7 +# Number of top scoring boxes to keep before apply NMS to RPN proposals +__C.TRAIN.RPN_PRE_NMS_TOP_N = 12000 +# Number of top scoring boxes to keep after applying NMS to RPN proposals +__C.TRAIN.RPN_POST_NMS_TOP_N = 2000 +# Proposal height and width both need to be greater than RPN_MIN_SIZE (at orig image scale) +__C.TRAIN.RPN_MIN_SIZE = 8 +# Deprecated (outside weights) +__C.TRAIN.RPN_BBOX_INSIDE_WEIGHTS = (1.0, 1.0, 1.0, 1.0) +# Give the positive RPN examples weight of p * 1 / {num positives} +# and give negatives a weight of (1 - p) +# Set to -1.0 to use uniform example weighting +__C.TRAIN.RPN_POSITIVE_WEIGHT = -1.0 +# Whether to use all ground truth bounding boxes for training, +# For COCO, setting USE_ALL_GT to False will exclude boxes that are flagged as ''iscrowd'' +__C.TRAIN.USE_ALL_GT = True + +# Whether to tune the batch normalization parameters during training +__C.TRAIN.BN_TRAIN = False + +# +# Testing options +# +__C.TEST = edict() + +# Scale to use during testing (can NOT list multiple scales) +# The scale is the pixel size of an image's shortest side +__C.TEST.SCALES = (600,) + +# Max pixel size of the longest side of a scaled input image +__C.TEST.MAX_SIZE = 1000 + +# Overlap threshold used for non-maximum suppression (suppress boxes with +# IoU >= this threshold) +__C.TEST.NMS = 0.3 + +# Experimental: treat the (K+1) units in the cls_score layer as linear +# predictors (trained, eg, with one-vs-rest SVMs). +__C.TEST.SVM = False + +# Test using bounding-box regressors +__C.TEST.BBOX_REG = True + +# Propose boxes +__C.TEST.HAS_RPN = False + +# Test using these proposals +__C.TEST.PROPOSAL_METHOD = 'gt' + +## NMS threshold used on RPN proposals +__C.TEST.RPN_NMS_THRESH = 0.7 +## Number of top scoring boxes to keep before apply NMS to RPN proposals +__C.TEST.RPN_PRE_NMS_TOP_N = 6000 + +## Number of top scoring boxes to keep after applying NMS to RPN proposals +__C.TEST.RPN_POST_NMS_TOP_N = 300 + +# Proposal height and width both need to be greater than RPN_MIN_SIZE (at orig image scale) +__C.TEST.RPN_MIN_SIZE = 16 + +# Testing mode, default to be 'nms', 'top' is slower but better +# See report for details +__C.TEST.MODE = 'nms' + +# Only useful when TEST.MODE is 'top', specifies the number of top proposals to select +__C.TEST.RPN_TOP_N = 5000 + +# +# ResNet options +# + +__C.RESNET = edict() + +# Option to set if max-pooling is appended after crop_and_resize. +# if true, the region will be resized to a square of 2xPOOLING_SIZE, +# then 2x2 max-pooling is applied; otherwise the region will be directly +# resized to a square of POOLING_SIZE +__C.RESNET.MAX_POOL = False + +# Number of fixed blocks during training, by default the first of all 4 blocks is fixed +# Range: 0 (none) to 3 (all) +__C.RESNET.FIXED_BLOCKS = 2 + +# +# MobileNet options +# + +__C.MOBILENET = edict() + +# Whether to regularize the depth-wise filters during training +__C.MOBILENET.REGU_DEPTH = False + +# Number of fixed layers during training, by default the first of all 14 layers is fixed +# Range: 0 (none) to 12 (all) +__C.MOBILENET.FIXED_LAYERS = 5 + +# Weight decay for the mobilenet weights +__C.MOBILENET.WEIGHT_DECAY = 0.00004 + +# Depth multiplier +__C.MOBILENET.DEPTH_MULTIPLIER = 1. + +# +# MISC +# + +__C.train_categories = [1] +__C.test_categories = [1] + +# The mapping from image coordinates to feature map coordinates might cause +# some boxes that are distinct in image space to become identical in feature +# coordinates. If DEDUP_BOXES > 0, then DEDUP_BOXES is used as the scale factor +# for identifying duplicate boxes. +# 1/16 is correct for {Alex,Caffe}Net, VGG_CNN_M_1024, and VGG16 +__C.DEDUP_BOXES = 1. / 16. + +# Pixel mean values (BGR order) as a (1, 1, 3) array +# We use the same pixel mean for all networks even though it's not exactly what +# they were trained with +__C.PIXEL_MEANS = np.array([[[102.9801, 115.9465, 122.7717]]]) + +# For reproducibility +__C.RNG_SEED = 3 + +# A small number that's used many times +__C.EPS = 1e-14 + +# Root directory of project +__C.ROOT_DIR = osp.abspath(osp.join(osp.dirname(__file__), '..', '..', '..')) + +# Data directory +# __C.DATA_DIR = osp.abspath(osp.join(__C.ROOT_DIR, '../data')) +__C.DATA_DIR = osp.abspath("../data") + +# Name (or path to) the matlab executable +__C.MATLAB = 'matlab' + +# Place outputs under an experiments directory +__C.EXP_DIR = 'default' + +# Use GPU implementation of non-maximum suppression +__C.USE_GPU_NMS = True + +# Default GPU device id +__C.GPU_ID = 0 + +__C.POOLING_MODE = 'crop' + +# Size of the pooled region after RoI pooling +__C.POOLING_SIZE = 7 + +# Maximal number of gt rois in an image during Training +__C.MAX_NUM_GT_BOXES = 20 + +# Anchor scales for RPN +__C.ANCHOR_SCALES = [8,16,32] + +# Anchor ratios for RPN +__C.ANCHOR_RATIOS = [0.5,1,2] +# __C.ANCHOR_RATIOS = [0.33,0.5,1,2,3] + +# Feature stride for RPN +__C.FEAT_STRIDE = [16, ] + +__C.CUDA = False + +__C.CROP_RESIZE_WITH_MAX_POOL = True + +import pdb +def get_output_dir(imdb, weights_filename): + """Return the directory where experimental artifacts are placed. + If the directory does not exist, it is created. + + A canonical path is built using the name from an imdb and a network + (if not None). + """ + outdir = osp.abspath(osp.join(__C.ROOT_DIR, 'output', __C.EXP_DIR, imdb.name)) + if weights_filename is None: + weights_filename = 'default' + outdir = osp.join(outdir, weights_filename) + if not os.path.exists(outdir): + os.makedirs(outdir) + return outdir + + +def get_output_tb_dir(imdb, weights_filename): + """Return the directory where tensorflow summaries are placed. + If the directory does not exist, it is created. + + A canonical path is built using the name from an imdb and a network + (if not None). + """ + outdir = osp.abspath(osp.join(__C.ROOT_DIR, 'tensorboard', __C.EXP_DIR, imdb.name)) + if weights_filename is None: + weights_filename = 'default' + outdir = osp.join(outdir, weights_filename) + if not os.path.exists(outdir): + os.makedirs(outdir) + return outdir + + +def _merge_a_into_b(a, b): + """Merge config dictionary a into config dictionary b, clobbering the + options in b whenever they are also specified in a. + """ + if type(a) is not edict: + return + + for k, v in a.items(): + # a must specify keys that are in b + if k not in b: + raise KeyError('{} is not a valid config key'.format(k)) + + # the types must match, too + old_type = type(b[k]) + if old_type is not type(v): + if isinstance(b[k], np.ndarray): + v = np.array(v, dtype=b[k].dtype) + else: + raise ValueError(('Type mismatch ({} vs. {}) ' + 'for config key: {}').format(type(b[k]), + type(v), k)) + + # recursively merge dicts + if type(v) is edict: + try: + _merge_a_into_b(a[k], b[k]) + except: + print(('Error under config key: {}'.format(k))) + raise + else: + b[k] = v + + +def cfg_from_file(filename): + """Load a config file and merge it into the default options.""" + import yaml + with open(filename, 'r') as f: + yaml_cfg = edict(yaml.load(f)) + + _merge_a_into_b(yaml_cfg, __C) + + +def cfg_from_list(cfg_list): + """Set config keys via list (e.g., from command line).""" + from ast import literal_eval + assert len(cfg_list) % 2 == 0 + for k, v in zip(cfg_list[0::2], cfg_list[1::2]): + key_list = k.split('.') + d = __C + for subkey in key_list[:-1]: + assert subkey in d + d = d[subkey] + subkey = key_list[-1] + assert subkey in d + try: + value = literal_eval(v) + except: + # handle the case when v is a string literal + value = v + assert type(value) == type(d[subkey]), \ + 'type {} does not match original type {}'.format( + type(value), type(d[subkey])) + d[subkey] = value diff --git a/lib/model/utils/logger.py b/lib/model/utils/logger.py new file mode 100644 index 0000000..1cb034a --- /dev/null +++ b/lib/model/utils/logger.py @@ -0,0 +1,71 @@ +# Code referenced from https://gist.github.com/gyglim/1f8dfb1b5c82627ae3efcfbbadb9f514 +import tensorflow as tf +import numpy as np +import scipy.misc +try: + from StringIO import StringIO # Python 2.7 +except ImportError: + from io import BytesIO # Python 3.x + + +class Logger(object): + + def __init__(self, log_dir): + """Create a summary writer logging to log_dir.""" + self.writer = tf.summary.FileWriter(log_dir) + + def scalar_summary(self, tag, value, step): + """Log a scalar variable.""" + summary = tf.Summary(value=[tf.Summary.Value(tag=tag, simple_value=value)]) + self.writer.add_summary(summary, step) + + def image_summary(self, tag, images, step): + """Log a list of images.""" + + img_summaries = [] + for i, img in enumerate(images): + # Write the image to a string + try: + s = StringIO() + except: + s = BytesIO() + scipy.misc.toimage(img).save(s, format="png") + + # Create an Image object + img_sum = tf.Summary.Image(encoded_image_string=s.getvalue(), + height=img.shape[0], + width=img.shape[1]) + # Create a Summary value + img_summaries.append(tf.Summary.Value(tag='%s/%d' % (tag, i), image=img_sum)) + + # Create and write Summary + summary = tf.Summary(value=img_summaries) + self.writer.add_summary(summary, step) + + def histo_summary(self, tag, values, step, bins=1000): + """Log a histogram of the tensor of values.""" + + # Create a histogram using numpy + counts, bin_edges = np.histogram(values, bins=bins) + + # Fill the fields of the histogram proto + hist = tf.HistogramProto() + hist.min = float(np.min(values)) + hist.max = float(np.max(values)) + hist.num = int(np.prod(values.shape)) + hist.sum = float(np.sum(values)) + hist.sum_squares = float(np.sum(values**2)) + + # Drop the start of the first bin + bin_edges = bin_edges[1:] + + # Add bin edges and counts + for edge in bin_edges: + hist.bucket_limit.append(edge) + for c in counts: + hist.bucket.append(c) + + # Create and write Summary + summary = tf.Summary(value=[tf.Summary.Value(tag=tag, histo=hist)]) + self.writer.add_summary(summary, step) + self.writer.flush() diff --git a/lib/model/utils/net_utils.py b/lib/model/utils/net_utils.py new file mode 100644 index 0000000..082dbe2 --- /dev/null +++ b/lib/model/utils/net_utils.py @@ -0,0 +1,276 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F +from torch.autograd import Variable +import numpy as np +import torchvision.models as models +from model.utils.config import cfg +import cv2 +import pdb +import random + +def save_net(fname, net): + import h5py + h5f = h5py.File(fname, mode='w') + for k, v in net.state_dict().items(): + h5f.create_dataset(k, data=v.cpu().numpy()) + +def load_net(fname, net): + import h5py + h5f = h5py.File(fname, mode='r') + for k, v in net.state_dict().items(): + param = torch.from_numpy(np.asarray(h5f[k])) + v.copy_(param) + +def weights_normal_init(model, dev=0.01): + if isinstance(model, list): + for m in model: + weights_normal_init(m, dev) + else: + for m in model.modules(): + if isinstance(m, nn.Conv2d): + m.weight.data.normal_(0.0, dev) + elif isinstance(m, nn.Linear): + m.weight.data.normal_(0.0, dev) + + +def clip_gradient(model, clip_norm): + """Computes a gradient clipping coefficient based on gradient norm.""" + totalnorm = 0 + for p in model.parameters(): + if p.requires_grad: + modulenorm = p.grad.data.norm() + totalnorm += modulenorm ** 2 + totalnorm = torch.sqrt(totalnorm).item() + norm = (clip_norm / max(totalnorm, clip_norm)) + for p in model.parameters(): + if p.requires_grad: + p.grad.mul_(norm) + +def vis_detections(im, class_name, dets, thresh=0.5): + """Visual debugging of detections.""" + for i in range(np.minimum(10, dets.shape[0])): + bbox = tuple(int(np.round(x)) for x in dets[i, :4]) + score = dets[i, -1] + if score > 0.8: + cv2.rectangle(im, bbox[0:2], bbox[2:4], (0, 110, 255), 5) + + text = '%.3f' % (score) + + (text_width, text_height) = cv2.getTextSize(text, cv2.FONT_HERSHEY_TRIPLEX, fontScale=1.2, thickness=2)[0] + + cv2.rectangle(im, (bbox[0], bbox[1] ), (bbox[0]+text_width, bbox[1] + text_height), (0, 255, 251), -1) + + cv2.putText(im,text , (bbox[0], bbox[1]+text_height), cv2.FONT_HERSHEY_TRIPLEX, 1.2, (0, 0, 0), thickness=2) + return im + +def adjust_learning_rate(optimizer, decay=0.1): + """Sets the learning rate to the initial LR decayed by 0.5 every 20 epochs""" + for param_group in optimizer.param_groups: + param_group['lr'] = decay * param_group['lr'] + +def save_checkpoint(state, filename): + torch.save(state, filename) + +def _smooth_l1_loss(bbox_pred, bbox_targets, bbox_inside_weights, bbox_outside_weights, sigma=1.0, dim=[1]): + + sigma_2 = sigma ** 2 + box_diff = bbox_pred - bbox_targets + in_box_diff = bbox_inside_weights * box_diff + abs_in_box_diff = torch.abs(in_box_diff) + smoothL1_sign = (abs_in_box_diff < 1. / sigma_2).detach().float() + in_loss_box = torch.pow(in_box_diff, 2) * (sigma_2 / 2.) * smoothL1_sign \ + + (abs_in_box_diff - (0.5 / sigma_2)) * (1. - smoothL1_sign) + out_loss_box = bbox_outside_weights * in_loss_box + loss_box = out_loss_box + for i in sorted(dim, reverse=True): + loss_box = loss_box.sum(i) + loss_box = loss_box.mean() + return loss_box + +def _crop_pool_layer(bottom, rois, max_pool=True): + # code modified from + # https://github.com/ruotianluo/pytorch-faster-rcnn + # implement it using stn + # box to affine + # input (x1,y1,x2,y2) + """ + [ x2-x1 x1 + x2 - W + 1 ] + [ ----- 0 --------------- ] + [ W - 1 W - 1 ] + [ ] + [ y2-y1 y1 + y2 - H + 1 ] + [ 0 ----- --------------- ] + [ H - 1 H - 1 ] + """ + rois = rois.detach() + batch_size = bottom.size(0) + D = bottom.size(1) + H = bottom.size(2) + W = bottom.size(3) + roi_per_batch = rois.size(0) / batch_size + x1 = rois[:, 1::4] / 16.0 + y1 = rois[:, 2::4] / 16.0 + x2 = rois[:, 3::4] / 16.0 + y2 = rois[:, 4::4] / 16.0 + + height = bottom.size(2) + width = bottom.size(3) + + # affine theta + zero = Variable(rois.data.new(rois.size(0), 1).zero_()) + theta = torch.cat([\ + (x2 - x1) / (width - 1), + zero, + (x1 + x2 - width + 1) / (width - 1), + zero, + (y2 - y1) / (height - 1), + (y1 + y2 - height + 1) / (height - 1)], 1).view(-1, 2, 3) + + if max_pool: + pre_pool_size = cfg.POOLING_SIZE * 2 + grid = F.affine_grid(theta, torch.Size((rois.size(0), 1, pre_pool_size, pre_pool_size))) + bottom = bottom.view(1, batch_size, D, H, W).contiguous().expand(roi_per_batch, batch_size, D, H, W)\ + .contiguous().view(-1, D, H, W) + crops = F.grid_sample(bottom, grid) + crops = F.max_pool2d(crops, 2, 2) + else: + grid = F.affine_grid(theta, torch.Size((rois.size(0), 1, cfg.POOLING_SIZE, cfg.POOLING_SIZE))) + bottom = bottom.view(1, batch_size, D, H, W).contiguous().expand(roi_per_batch, batch_size, D, H, W)\ + .contiguous().view(-1, D, H, W) + crops = F.grid_sample(bottom, grid) + + return crops, grid + +def _affine_grid_gen(rois, input_size, grid_size): + + rois = rois.detach() + x1 = rois[:, 1::4] / 16.0 + y1 = rois[:, 2::4] / 16.0 + x2 = rois[:, 3::4] / 16.0 + y2 = rois[:, 4::4] / 16.0 + + height = input_size[0] + width = input_size[1] + + zero = Variable(rois.data.new(rois.size(0), 1).zero_()) + theta = torch.cat([\ + (x2 - x1) / (width - 1), + zero, + (x1 + x2 - width + 1) / (width - 1), + zero, + (y2 - y1) / (height - 1), + (y1 + y2 - height + 1) / (height - 1)], 1).view(-1, 2, 3) + + grid = F.affine_grid(theta, torch.Size((rois.size(0), 1, grid_size, grid_size))) + + return grid + +def _affine_theta(rois, input_size): + + rois = rois.detach() + x1 = rois[:, 1::4] / 16.0 + y1 = rois[:, 2::4] / 16.0 + x2 = rois[:, 3::4] / 16.0 + y2 = rois[:, 4::4] / 16.0 + + height = input_size[0] + width = input_size[1] + + zero = Variable(rois.data.new(rois.size(0), 1).zero_()) + + # theta = torch.cat([\ + # (x2 - x1) / (width - 1), + # zero, + # (x1 + x2 - width + 1) / (width - 1), + # zero, + # (y2 - y1) / (height - 1), + # (y1 + y2 - height + 1) / (height - 1)], 1).view(-1, 2, 3) + + theta = torch.cat([\ + (y2 - y1) / (height - 1), + zero, + (y1 + y2 - height + 1) / (height - 1), + zero, + (x2 - x1) / (width - 1), + (x1 + x2 - width + 1) / (width - 1)], 1).view(-1, 2, 3) + + return theta + +class SpatialAttention(nn.Module): + def __init__(self, kernel_size=7): + super(SpatialAttention, self).__init__() + + assert kernel_size in (3, 7), 'kernel size must be 3 or 7' + padding = 3 if kernel_size == 7 else 1 + + self.conv1 = nn.Conv2d(2, 1, kernel_size, padding=padding, bias=False) + self.sigmoid = nn.Sigmoid() + + def forward(self, x): + avg_out = torch.mean(x, dim=1, keepdim=True) + max_out, _ = torch.max(x, dim=1, keepdim=True) + x = torch.cat([avg_out, max_out], dim=1) + x = self.conv1(x) + return self.sigmoid(x) + +class Flatten(nn.Module): + def forward(self, x): + return x.view(x.size(0), -1) + +class ChannelGate(nn.Module): + def __init__(self, gate_channels, reduction_ratio=16, pool_types=['avg', 'max']): + super(ChannelGate, self).__init__() + self.gate_channels = gate_channels + self.mlp = nn.Sequential( + Flatten(), + nn.Linear(gate_channels, gate_channels // reduction_ratio), + nn.ReLU(), + nn.Linear(gate_channels // reduction_ratio, gate_channels) + ) + self.pool_types = pool_types + def forward(self, x): + channel_att_sum = None + for pool_type in self.pool_types: + if pool_type=='avg': + avg_pool = F.avg_pool2d( x, (x.size(2), x.size(3)), stride=(x.size(2), x.size(3))) + channel_att_raw = self.mlp( avg_pool ) + elif pool_type=='max': + max_pool = F.max_pool2d( x, (x.size(2), x.size(3)), stride=(x.size(2), x.size(3))) + channel_att_raw = self.mlp( max_pool ) + elif pool_type=='lp': + lp_pool = F.lp_pool2d( x, 2, (x.size(2), x.size(3)), stride=(x.size(2), x.size(3))) + channel_att_raw = self.mlp( lp_pool ) + elif pool_type=='lse': + # LSE pool only + lse_pool = logsumexp_2d(x) + channel_att_raw = self.mlp( lse_pool ) + + if channel_att_sum is None: + channel_att_sum = channel_att_raw + else: + channel_att_sum = channel_att_sum + channel_att_raw + + scale = torch.sigmoid( channel_att_sum ).unsqueeze(2).unsqueeze(3) + return scale + +class GroupNorm(nn.Module): + def __init__(self, num_features, num_groups=32, eps=1e-5): + super(GroupNorm, self).__init__() + self.weight = nn.Parameter(torch.ones(1,num_features,1,1)) + self.bias = nn.Parameter(torch.zeros(1,num_features,1,1)) + self.num_groups = num_groups + self.eps = eps + + def forward(self, x): + N,C,H,W = x.size() + G = self.num_groups + assert C % G == 0 + + x = x.view(N,G,-1) + mean = x.mean(-1, keepdim=True) + var = x.var(-1, keepdim=True) + + x = (x-mean) / (var+self.eps).sqrt() + x = x.view(N,C,H,W) + return x * self.weight + self.bias diff --git a/lib/roi_data_layer/__init__.py b/lib/roi_data_layer/__init__.py new file mode 100644 index 0000000..7ba6a65 --- /dev/null +++ b/lib/roi_data_layer/__init__.py @@ -0,0 +1,6 @@ +# -------------------------------------------------------- +# Fast R-CNN +# Copyright (c) 2015 Microsoft +# Licensed under The MIT License [see LICENSE for details] +# Written by Ross Girshick +# -------------------------------------------------------- diff --git a/lib/roi_data_layer/minibatch.py b/lib/roi_data_layer/minibatch.py new file mode 100644 index 0000000..6b62fcb --- /dev/null +++ b/lib/roi_data_layer/minibatch.py @@ -0,0 +1,87 @@ +# -------------------------------------------------------- +# Fast R-CNN +# Copyright (c) 2015 Microsoft +# Licensed under The MIT License [see LICENSE for details] +# Written by Ross Girshick and Xinlei Chen +# -------------------------------------------------------- + +"""Compute minibatch blobs for training a Fast R-CNN network.""" +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +import numpy as np +import cv2 +import numpy.random as npr +from scipy.misc import imread +from model.utils.config import cfg +from model.utils.blob import prep_im_for_blob, im_list_to_blob +import pdb +def get_minibatch(roidb, num_classes): + """Given a roidb, construct a minibatch sampled from it.""" + num_images = len(roidb) + # Sample random scales to use for each image in this batch + random_scale_inds = npr.randint(0, high=len(cfg.TRAIN.SCALES), + size=num_images) + assert(cfg.TRAIN.BATCH_SIZE % num_images == 0), \ + 'num_images ({}) must divide BATCH_SIZE ({})'. \ + format(num_images, cfg.TRAIN.BATCH_SIZE) + + # Get the input image blob, formatted for caffe + im_blob, im_scales = _get_image_blob(roidb, random_scale_inds) + + blobs = {'data': im_blob} + + assert len(im_scales) == 1, "Single batch only" + assert len(roidb) == 1, "Single batch only" + + # gt boxes: (x1, y1, x2, y2, cls) + if cfg.TRAIN.USE_ALL_GT: + # Include all ground truth boxes + gt_inds = np.where(roidb[0]['gt_classes'] != 0)[0] + else: + # For the COCO ground truth boxes, exclude the ones that are ''iscrowd'' + gt_inds = np.where((roidb[0]['gt_classes'] != 0) & np.all(roidb[0]['gt_overlaps'].toarray() > -1.0, axis=1))[0] + gt_boxes = np.empty((len(gt_inds), 5), dtype=np.float32) + gt_boxes[:, 0:4] = roidb[0]['boxes'][gt_inds, :] * im_scales[0] + gt_boxes[:, 4] = roidb[0]['gt_classes'][gt_inds] + blobs['gt_boxes'] = gt_boxes + blobs['im_info'] = np.array( + [[im_blob.shape[1], im_blob.shape[2], im_scales[0]]], + dtype=np.float32) + + blobs['img_id'] = roidb[0]['img_id'] + + return blobs + +def _get_image_blob(roidb, scale_inds): + """Builds an input blob from the images in the roidb at the specified + scales. + """ + num_images = len(roidb) + + processed_ims = [] + im_scales = [] + for i in range(num_images): + #im = cv2.imread(roidb[i]['image']) + im = imread(roidb[i]['image']) + + if len(im.shape) == 2: + im = im[:,:,np.newaxis] + im = np.concatenate((im,im,im), axis=2) + # flip the channel, since the original one using cv2 + # rgb -> bgr + # im = im[:,:,::-1] + + if roidb[i]['flipped']: + im = im[:, ::-1, :] + target_size = cfg.TRAIN.SCALES[scale_inds[i]] + im, im_scale = prep_im_for_blob(im, cfg.PIXEL_MEANS, target_size, + cfg.TRAIN.MAX_SIZE) + im_scales.append(im_scale) + processed_ims.append(im) + + # Create a blob to hold the input images + blob = im_list_to_blob(processed_ims) + + return blob, im_scales diff --git a/lib/roi_data_layer/roibatchLoader.py b/lib/roi_data_layer/roibatchLoader.py new file mode 100644 index 0000000..d20c098 --- /dev/null +++ b/lib/roi_data_layer/roibatchLoader.py @@ -0,0 +1,387 @@ + +"""The data layer used during training to train a Fast R-CNN network. +""" + +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +import torch.utils.data as data +from PIL import Image +import torch +from collections import Counter + +from scipy.misc import imread +from model.utils.config import cfg +from roi_data_layer.minibatch import get_minibatch, get_minibatch +from model.utils.blob import prep_im_for_blob, im_list_to_blob, crop +from model.rpn.bbox_transform import bbox_transform_inv, clip_boxes + +import numpy as np +import cv2 +import random +import time +import pdb +import pickle + +class roibatchLoader(data.Dataset): + def __init__(self, roidb, ratio_list, ratio_index, query, batch_size, num_classes, training=True, normalize=None, seen=True): + self._roidb = roidb + self._query = query + self._num_classes = num_classes + # we make the height of image consistent to trim_height, trim_width + self.trim_height = cfg.TRAIN.TRIM_HEIGHT + self.trim_width = cfg.TRAIN.TRIM_WIDTH + self.max_num_box = cfg.MAX_NUM_GT_BOXES + self.training = training + self.normalize = normalize + self.ratio_list = ratio_list + self.query_position = 0 + # rajath + self.coco_sketchy_map = pickle.load(open("../data/coco_sketchy_map.pkl", "rb")) + self.sketchy_classes = np.array([int(class_idx) for class_idx in self.coco_sketchy_map if len(self.coco_sketchy_map[class_idx]["sketchy"]) > 0]).astype(np.uint8) + + if training: + self.ratio_index = ratio_index + else: + self.cat_list = ratio_index[1] + self.ratio_index = ratio_index[0] + + self.batch_size = batch_size + self.data_size = len(self.ratio_list) + + # given the ratio_list, we want to make the ratio same for each batch. + self.ratio_list_batch = torch.Tensor(self.data_size).zero_() + num_batch = int(np.ceil(len(ratio_index) / batch_size)) + if self.training: + for i in range(num_batch): + left_idx = i*batch_size + right_idx = min((i+1)*batch_size-1, self.data_size-1) + + if ratio_list[right_idx] < 1: + # for ratio < 1, we preserve the leftmost in each batch. + target_ratio = ratio_list[left_idx] + elif ratio_list[left_idx] > 1: + # for ratio > 1, we preserve the rightmost in each batch. + target_ratio = ratio_list[right_idx] + else: + # for ratio cross 1, we make it to be 1. + target_ratio = 1 + + self.ratio_list_batch[left_idx:(right_idx+1)] = target_ratio + + self._cat_ids = [ + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 27, 28, 31, 32, 33, 34, 35, 36, + 37, 38, 39, 40, 41, 42, 43, 44, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, 59, 60, 61, 62, 63, 64, 65, 67, 70, + 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + 82, 84, 85, 86, 87, 88, 89, 90 + ] + self._classes = { + ind + 1: cat_id for ind, cat_id in enumerate(self._cat_ids) + } + self._classes_inv = { + value: key for key, value in self._classes.items() + } + + self.filter(seen) + self.probability() + + + def __getitem__(self, index): + index_ratio = int(self.ratio_index[index]) + + # get the anchor index for current sample index + # here we set the anchor index to the last one + # sample in this group + minibatch_db = [self._roidb[index_ratio]] + + blobs = get_minibatch(minibatch_db , self._num_classes) + + # rajath + blobs['gt_boxes'] = [x for x in blobs['gt_boxes'] if x[-1] in self.list_ind] + # blobs['gt_boxes'] = [x for x in blobs['gt_boxes'] if int(x[-1]) in self.sketchy_classes] + blobs['gt_boxes'] = np.array(blobs['gt_boxes']) + + + if self.training: + # Random choice query catgory + catgory = blobs['gt_boxes'][:,-1] + + cand = np.unique(catgory).astype(np.uint8) + # cand = np.intersect1d(cand, self.sketchy_classes) + # print ("index:", index, "\nindex_ratio:", index_ratio, "\ncatgory:", catgory, "\ncand:", cand, "\nsketchy_classes:", self.sketchy_classes) + if len(cand) == 1: + choice = cand[0] + + else: + p = [] + for i in cand: + p.append(self.show_time[i]) + p = np.array(p) + p /= p.sum() + choice = np.random.choice(cand,1,p=p)[0] + + # Delete useless gt_boxes + blobs['gt_boxes'][:,-1] = np.where(blobs['gt_boxes'][:,-1]==choice,1,0) + # Get query image + query = self.load_query(choice) + else: + query = self.load_query(index, minibatch_db[0]['img_id']) + + data = torch.from_numpy(blobs['data']) + query = torch.from_numpy(query) + query = query.permute(0, 3, 1, 2).contiguous().squeeze(0) + im_info = torch.from_numpy(blobs['im_info']) + + # we need to random shuffle the bounding box. + data_height, data_width = data.size(1), data.size(2) + if self.training: + np.random.shuffle(blobs['gt_boxes']) + gt_boxes = torch.from_numpy(blobs['gt_boxes']) + + ######################################################## + # padding the input image to fixed size for each group # + ######################################################## + + # NOTE1: need to cope with the case where a group cover both conditions. (done) + # NOTE2: need to consider the situation for the tail samples. (no worry) + # NOTE3: need to implement a parallel data loader. (no worry) + # get the index range + + # if the image need to crop, crop to the target size. + ratio = self.ratio_list_batch[index] + + if self._roidb[index_ratio]['need_crop']: + if ratio < 1: + # this means that data_width << data_height, we need to crop the + # data_height + min_y = int(torch.min(gt_boxes[:,1])) + max_y = int(torch.max(gt_boxes[:,3])) + trim_size = int(np.floor(data_width / ratio)) + if trim_size > data_height: + trim_size = data_height + box_region = max_y - min_y + 1 + if min_y == 0: + y_s = 0 + else: + if (box_region-trim_size) < 0: + y_s_min = max(max_y-trim_size, 0) + y_s_max = min(min_y, data_height-trim_size) + if y_s_min == y_s_max: + y_s = y_s_min + else: + y_s = np.random.choice(range(y_s_min, y_s_max)) + else: + y_s_add = int((box_region-trim_size)/2) + if y_s_add == 0: + y_s = min_y + else: + y_s = np.random.choice(range(min_y, min_y+y_s_add)) + # crop the image + data = data[:, y_s:(y_s + trim_size), :, :] + + # shift y coordiante of gt_boxes + gt_boxes[:, 1] = gt_boxes[:, 1] - float(y_s) + gt_boxes[:, 3] = gt_boxes[:, 3] - float(y_s) + + # update gt bounding box according the trip + gt_boxes[:, 1].clamp_(0, trim_size - 1) + gt_boxes[:, 3].clamp_(0, trim_size - 1) + + else: + # this means that data_width >> data_height, we need to crop the + # data_width + min_x = int(torch.min(gt_boxes[:,0])) + max_x = int(torch.max(gt_boxes[:,2])) + trim_size = int(np.ceil(data_height * ratio)) + if trim_size > data_width: + trim_size = data_width + box_region = max_x - min_x + 1 + if min_x == 0: + x_s = 0 + else: + if (box_region-trim_size) < 0: + x_s_min = max(max_x-trim_size, 0) + x_s_max = min(min_x, data_width-trim_size) + if x_s_min == x_s_max: + x_s = x_s_min + else: + x_s = np.random.choice(range(x_s_min, x_s_max)) + else: + x_s_add = int((box_region-trim_size)/2) + if x_s_add == 0: + x_s = min_x + else: + x_s = np.random.choice(range(min_x, min_x+x_s_add)) + # crop the image + data = data[:, :, x_s:(x_s + trim_size), :] + + # shift x coordiante of gt_boxes + gt_boxes[:, 0] = gt_boxes[:, 0] - float(x_s) + gt_boxes[:, 2] = gt_boxes[:, 2] - float(x_s) + # update gt bounding box according the trip + gt_boxes[:, 0].clamp_(0, trim_size - 1) + gt_boxes[:, 2].clamp_(0, trim_size - 1) + + # based on the ratio, padding the image. + if ratio < 1: + # this means that data_width < data_height + trim_size = int(np.floor(data_width / ratio)) + + padding_data = torch.FloatTensor(int(np.ceil(data_width / ratio)), \ + data_width, 3).zero_() + + padding_data[:data_height, :, :] = data[0] + # update im_info + im_info[0, 0] = padding_data.size(0) + # print("height %d %d \n" %(index, anchor_idx)) + elif ratio > 1: + # this means that data_width > data_height + # if the image need to crop. + padding_data = torch.FloatTensor(data_height, \ + int(np.ceil(data_height * ratio)), 3).zero_() + padding_data[:, :data_width, :] = data[0] + im_info[0, 1] = padding_data.size(1) + else: + trim_size = min(data_height, data_width) + padding_data = torch.FloatTensor(trim_size, trim_size, 3).zero_() + padding_data = data[0][:trim_size, :trim_size, :] + # gt_boxes.clamp_(0, trim_size) + gt_boxes[:, :4].clamp_(0, trim_size) + im_info[0, 0] = trim_size + im_info[0, 1] = trim_size + + + # check the bounding box: + not_keep = (gt_boxes[:,0] == gt_boxes[:,2]) | (gt_boxes[:,1] == gt_boxes[:,3]) + # not_keep = (gt_boxes[:,2] - gt_boxes[:,0]) < 10 + # print(not_keep) + # not_keep = (gt_boxes[:,2] - gt_boxes[:,0]) < torch.FloatTensor([10]) | (gt_boxes[:,3] - gt_boxes[:,1]) < torch.FloatTensor([10]) + + keep = torch.nonzero(not_keep == 0).view(-1) + + gt_boxes_padding = torch.FloatTensor(self.max_num_box, gt_boxes.size(1)).zero_() + if keep.numel() != 0 : + gt_boxes = gt_boxes[keep] + num_boxes = min(gt_boxes.size(0), self.max_num_box) + gt_boxes_padding[:num_boxes,:] = gt_boxes[:num_boxes] + else: + num_boxes = 0 + + # permute trim_data to adapt to downstream processing + padding_data = padding_data.permute(2, 0, 1).contiguous() + im_info = im_info.view(3) + + return padding_data, query, im_info, gt_boxes_padding, num_boxes + else: + data = data.permute(0, 3, 1, 2).contiguous().view(3, data_height, data_width) + im_info = im_info.view(3) + + # gt_boxes = torch.FloatTensor([1,1,1,1,1]) + gt_boxes = torch.from_numpy(blobs['gt_boxes']) + choice = self.cat_list[index] + + return data, query, im_info, gt_boxes, choice + + def load_query(self, choice, id=0): + + if self.training: + # Random choice query catgory image + all_data = self._query[choice] + data = random.choice(all_data) + else: + # Take out the purpose category for testing + catgory = self.cat_list[choice] + # list all the candidate image + all_data = self._query[catgory] + + # Use image_id to determine the random seed + # The list l is candidate sequence, which random by image_id + random.seed(id) + l = list(range(len(all_data))) + + random.shuffle(l) + # print ("l:", l) + # choose the candidate sequence and take out the data information + # position=l[self.query_position%len(l)] + position = l[0] + data = all_data[position] + + # Get image + path = data['image_path'] + im = imread(path) + + + if len(im.shape) == 2: + im = im[:,:,np.newaxis] + im = np.concatenate((im,im,im), axis=2) + + im = crop(im, data['boxes'], cfg.TRAIN.query_size) + # flip the channel, since the original one using cv2 + # rgb -> bgr + # im = im[:,:,::-1] + if random.randint(0,99)/100 > 0.5 and self.training: + im = im[:, ::-1, :] + + + im, im_scale = prep_im_for_blob(im, cfg.PIXEL_MEANS, cfg.TRAIN.query_size, + cfg.TRAIN.MAX_SIZE) + + query = im_list_to_blob([im]) + + return query + + def __len__(self): + return len(self.ratio_index) + + def filter(self, seen): + if seen==1: + self.list = cfg.train_categories + # Group number to class + if len(self.list)==1: + self.list = [self._classes[cat] for cat in range(1,81) if cat%4 != self.list[0]] + else: + self.list = [self._classes[cat] for cat in cfg.train_categories] + + elif seen==2: + self.list = cfg.test_categories + # Group number to class + if len(self.list)==1: + self.list = [self._classes[cat] for cat in range(1,81) if cat%4 == self.list[0]] + else: + self.list = [self._classes[cat] for cat in cfg.test_categories] + + elif seen==3: + self.list = cfg.train_categories + cfg.test_categories + # Group number to class + if len(self.list)==2: + self.list = [self._classes[cat] for cat in range(1,81)] + else: + self.list = [self._classes[cat] for cat in cfg.train_categories + cfg.test_categories] + + self.list_ind = [self._classes_inv[x] for x in self.list] + # self.list_ind = self.sketchy_classes + + def probability(self): + show_time = {} + for i in self.list_ind: + show_time[i] = 0 + for roi in self._roidb: + result = Counter(roi['gt_classes']) + for t in result: + if t in self.list_ind: + show_time[t] += result[t] + + for i in self.list_ind: + show_time[i] = 1/show_time[i] + + sum_prob = sum(show_time.values()) + + for i in self.list_ind: + show_time[i] = show_time[i]/sum_prob + + self.show_time = show_time diff --git a/lib/roi_data_layer/roidb.py b/lib/roi_data_layer/roidb.py new file mode 100644 index 0000000..42ba681 --- /dev/null +++ b/lib/roi_data_layer/roidb.py @@ -0,0 +1,188 @@ +"""Transform a roidb into a trainable roidb by adding a bunch of metadata.""" +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +import datasets +import numpy as np +from model.utils.config import cfg +from datasets.factory2 import get_imdb +import PIL +import pdb + +def prepare_roidb(imdb): + """Enrich the imdb's roidb by adding some derived quantities that + are useful for training. This function precomputes the maximum + overlap, taken over ground-truth boxes, between each ROI and + each ground-truth box. The class with maximum overlap is also + recorded. + """ + + roidb = imdb.roidb + if not (imdb.name.startswith('coco')): + sizes = [PIL.Image.open(imdb.image_path_at(i)).size + for i in range(imdb.num_images)] + + for i in range(len(imdb.image_index)): + roidb[i]['img_id'] = imdb.image_id_at(i) + roidb[i]['image'] = imdb.image_path_at(i) + if not (imdb.name.startswith('coco')): + roidb[i]['width'] = sizes[i][0] + roidb[i]['height'] = sizes[i][1] + # need gt_overlaps as a dense array for argmax + gt_overlaps = roidb[i]['gt_overlaps'].toarray() + # max overlap with gt over classes (columns) + max_overlaps = gt_overlaps.max(axis=1) + # gt class that had the max overlap + max_classes = gt_overlaps.argmax(axis=1) + roidb[i]['max_classes'] = max_classes + roidb[i]['max_overlaps'] = max_overlaps + # sanity checks + # max overlap of 0 => class should be zero (background) + zero_inds = np.where(max_overlaps == 0)[0] + assert all(max_classes[zero_inds] == 0) + # max overlap > 0 => class should not be zero (must be a fg class) + nonzero_inds = np.where(max_overlaps > 0)[0] + # assert all(max_classes[nonzero_inds] != 0) + +def rank_roidb_ratio(roidb): + # rank roidb based on the ratio between width and height. + ratio_large = 2 # largest ratio to preserve. + ratio_small = 0.5 # smallest ratio to preserve. + + ratio_list = [] + for i in range(len(roidb)): + width = roidb[i]['width'] + height = roidb[i]['height'] + ratio = width / float(height) + + if ratio > ratio_large: + roidb[i]['need_crop'] = 1 + ratio = ratio_large + elif ratio < ratio_small: + roidb[i]['need_crop'] = 1 + ratio = ratio_small + else: + roidb[i]['need_crop'] = 0 + + ratio_list.append(ratio) + + ratio_list = np.array(ratio_list) + ratio_index = np.argsort(ratio_list) + return ratio_list[ratio_index], ratio_index + +def filter_roidb(roidb): + # filter the image without bounding box. + print('before filtering, there are %d images...' % (len(roidb))) + i = 0 + while i < len(roidb): + if len(roidb[i]['boxes']) == 0: + del roidb[i] + i -= 1 + i += 1 + + print('after filtering, there are %d images...' % (len(roidb))) + return roidb + +def test_rank_roidb_ratio(roidb, reserved): + # rank roidb based on the ratio between width and height. + ratio_large = 2 # largest ratio to preserve. + ratio_small = 0.5 # smallest ratio to preserve. + + + # Image can show more than one time for test different category + ratio_list = [] + ratio_index = [] # image index reserved + cat_list = [] # category list reserved + for i in range(len(roidb)): + width = roidb[i]['width'] + height = roidb[i]['height'] + ratio = width / float(height) + + if ratio > ratio_large: + roidb[i]['need_crop'] = 1 + ratio = ratio_large + elif ratio < ratio_small: + roidb[i]['need_crop'] = 1 + ratio = ratio_small + else: + roidb[i]['need_crop'] = 0 + + + for j in np.unique(roidb[i]['max_classes']): + if j in reserved: + ratio_list.append(ratio) + ratio_index.append(i) + cat_list.append(j) + + + ratio_list = np.array(ratio_list) + ratio_index = np.array(ratio_index) + cat_list = np.array(cat_list) + ratio_index = np.vstack((ratio_index,cat_list)) + + return ratio_list, ratio_index + +def combined_roidb(imdb_names, training=True, seen=1): + """ + Combine multiple roidbs + """ + + def get_training_roidb(imdb, training): + """Returns a roidb (Region of Interest database) for use in training.""" + if cfg.TRAIN.USE_FLIPPED and training: + print('Appending horizontally-flipped training examples...') + # imdb.append_flipped_images() + print('done') + + + print('Preparing training data...') + prepare_roidb(imdb) + #ratio_index = rank_roidb_ratio(imdb) + print('done') + + return imdb.roidb + + def get_roidb(imdb_name, training): + imdb = get_imdb(imdb_name) + print('Loaded dataset `{:s}` for training'.format(imdb.name)) + imdb.set_proposal_method(cfg.TRAIN.PROPOSAL_METHOD) + print('Set proposal method: {:s}'.format(cfg.TRAIN.PROPOSAL_METHOD)) + + imdb.filter(seen) + + roidb = get_training_roidb(imdb, training) + + + + return imdb, roidb, imdb.cat_data, imdb.inverse_list + + imdbs = [] + roidbs = [] + querys = [] + for s in imdb_names.split('+'): + imdb, roidb, query, reserved = get_roidb(s, training) + imdbs.append(imdb) + roidbs.append(roidb) + querys.append(query) + imdb = imdbs[0] + roidb = roidbs[0] + query = querys[0] + + + if len(roidbs) > 1 and training: + for r in roidbs[1:]: + roidb.extend(r) + for r in range(len(querys[0])): + query[r].extend(querys[1][r]) + tmp = get_imdb(imdb_names.split('+')[1]) + imdb = datasets.imdb.imdb(imdb_names, tmp.classes) + + if training: + roidb = filter_roidb(roidb) + ratio_list, ratio_index = rank_roidb_ratio(roidb) + else: + # Generate testing image, an image testing frequency(time) according to the reserved category + ratio_list, ratio_index = test_rank_roidb_ratio(roidb, reserved) + + return imdb, roidb, ratio_list, ratio_index, query \ No newline at end of file diff --git a/lib/roi_data_layer/sketchBatchLoader.py b/lib/roi_data_layer/sketchBatchLoader.py new file mode 100644 index 0000000..aba32b4 --- /dev/null +++ b/lib/roi_data_layer/sketchBatchLoader.py @@ -0,0 +1,536 @@ + +"""The data layer used during training to train a Fast R-CNN network. +""" + +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +import torch.utils.data as data +from PIL import Image, ImageDraw, ImageOps +import torch +import torch.nn as nn +from collections import Counter + +#from scipy.misc.pilutil import imread +#from matplotlib.pyplot import imread +from cv2 import imread +from model.utils.config import cfg +from roi_data_layer.minibatch import get_minibatch, get_minibatch +from model.utils.blob import prep_im_for_blob, im_list_to_blob, crop +from model.rpn.bbox_transform import bbox_transform_inv, clip_boxes +from torchvision.utils import save_image +import torchvision.transforms as transforms +import numpy as np +import cv2 +import random +import time +import pdb +import pickle +import random +from collections import defaultdict + +def convert_to_np_raw(drawing, width=256, height=256): + img = np.zeros((width, height)) + pil_img = convert_to_PIL(drawing) + pil_img.thumbnail((width, height), Image.ANTIALIAS) + pil_img = pil_img.convert('RGB') + pixels = pil_img.load() + + for i in range(0, width): + for j in range(0, height): + img[i,j] = 1- pixels[j,i][0]/255.0 + return img + +def convert_to_PIL(drawing, width=256, height=256): + pil_img = Image.new('RGB', (width, height), 'white') + pixels = pil_img.load() + draw = ImageDraw.Draw(pil_img) + for x,y in drawing: + for i in range(1, len(x)): + draw.line((x[i-1], y[i-1], x[i], y[i]), fill=0) + return pil_img + + + +class roibatchLoader(data.Dataset): + def __init__(self, roidb, ratio_list, ratio_index, query, batch_size, num_classes, sketch_path, sketch_class_2_label, class_to_coco_cat_id,coco_class_ind_to_cat_id, training=True, normalize=None, seen=True): + self._roidb = roidb + self._query = query + # self._num_classes = num_classes + self._num_classes = 56 + # we make the height of image consistent to trim_height, trim_width + self.trim_height = cfg.TRAIN.TRIM_HEIGHT + self.trim_width = cfg.TRAIN.TRIM_WIDTH + self.max_num_box = cfg.MAX_NUM_GT_BOXES + self.training = training + self.normalize = normalize + self.ratio_list = ratio_list + self.query_position = 0 + self.sketch_path = sketch_path + self.class2labels = sketch_class_2_label + self.class2labels = pickle.load(open(self.class2labels, 'rb')) + self.draw_data_path = pickle.load(open(self.sketch_path, 'rb')) + + if training: + self.ratio_index = ratio_index + self.draw_data_path = self.draw_data_path['train_x'] + self.draw_data_path = random.sample(self.draw_data_path, 800000) + else: + self.cat_list = ratio_index[1] + self.ratio_index = ratio_index[0] + self.draw_data_path = self.draw_data_path['valid_x'] + random.seed(14) + self.draw_data_path = random.sample(self.draw_data_path, 8000) + + self.batch_size = batch_size + self.data_size = len(self.ratio_list) + self.cat2sketch = defaultdict(list) + label_array = [] + for draw_path in self.draw_data_path: + label = draw_path.split('/')[-2] + label_array.append(label) + self.cat2sketch[label].append(draw_path) + label_array = list(set(label_array)) + # print(label_array) + # exit(0) + + # given the ratio_list, we want to make the ratio same for each batch. + self.ratio_list_batch = torch.Tensor(self.data_size).zero_() + num_batch = int(np.ceil(len(ratio_index) / batch_size)) + if self.training: + for i in range(num_batch): + left_idx = i*batch_size + right_idx = min((i+1)*batch_size-1, self.data_size-1) + + if ratio_list[right_idx] < 1: + # for ratio < 1, we preserve the leftmost in each batch. + target_ratio = ratio_list[left_idx] + elif ratio_list[left_idx] > 1: + # for ratio > 1, we preserve the rightmost in each batch. + target_ratio = ratio_list[right_idx] + else: + # for ratio cross 1, we make it to be 1. + target_ratio = 1 + + self.ratio_list_batch[left_idx:(right_idx+1)] = target_ratio + + + self._cat_ids= [] + self.cat2idx = {} + self.idx2cat = {} + for cat in label_array: + self._cat_ids.append(class_to_coco_cat_id[cat]) + self.cat2idx[cat] = class_to_coco_cat_id[cat] + self.idx2cat[class_to_coco_cat_id[cat]] = cat + + # self._cat_ids = [ + # 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, + # 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + # 24, 25, 27, 28, 31, 32, 33, 34, 35, 36, + # 37, 38, 39, 40, 41, 42, 43, 44, 46, 47, + # 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + # 58, 59, 60, 61, 62, 63, 64, 65, 67, 70, + # 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + # 82, 84, 85, 86, 87, 88, 89, 90 + # ] + # print(coco_class_ind_to_cat_id) + # exit(0) + # self._classes = { + # ind + 1: cat_id for ind, cat_id in enumerate(self._cat_ids) + # } + self._classes = coco_class_ind_to_cat_id + self._classes_inv = { + value: key for key, value in self._classes.items() + } + self.toTensor = transforms.ToTensor() + self.filter(seen=7) + self.probability() + self.class2cat = {} + self.cat2class = {} + for cat in label_array: + cat_id = class_to_coco_cat_id[cat] + cla = self._classes_inv[cat_id] + self.class2cat[cla] = cat + self.cat2class[cat] = cla + + + def __getitem__(self, index): + index_ratio = int(self.ratio_index[index]) + + # get the anchor index for current sample index + # here we set the anchor index to the last one + # sample in this group + minibatch_db = [self._roidb[index_ratio]] + + blobs = get_minibatch(minibatch_db , self._num_classes) + # print(self.list_ind) + + blobs['gt_boxes'] = [x for x in blobs['gt_boxes'] if x[-1] in self.list_ind] + blobs['gt_boxes'] = np.array(blobs['gt_boxes']) + + + if self.training: + # Random choice query catgory + try: + catgory = blobs['gt_boxes'][:,-1] + except: + print(blobs['gt_boxes']) + exit(0) + cand = np.unique(catgory) + if len(cand)==1: + choice = cand[0] + + + cla = self.class2cat[int(choice)] #---------------> + sketch_array = self.cat2sketch[cla] + # print(sketch_array) + sketch = random.choices(sketch_array,k=4) + sketch_array = [] + for sk in sketch: # ------> Uncomment for sketches + sk = pickle.load(open(sk, 'rb')) + key = list(sk.keys())[0] + sk = convert_to_np_raw(sk[key]) + sk = np.stack((sk, sk, sk), axis=0)/255.0 + sketch_array.append(sk) + sketch_array = np.stack(sketch_array, axis=0) #-------------> + + # sketch = random.choice(sketch_array) + # sketch = pickle.load(open(sketch, 'rb')) + # key = list(sketch.keys())[0] + # sketch = convert_to_np_raw(sketch[key]) + # sketch = np.stack((sketch, sketch, sketch), axis=0)/255.0 + + else: + p = [] + for i in cand: + p.append(self.show_time[i]) + p = np.array(p) + p /= p.sum() + choice = np.random.choice(cand,1,p=p)[0] + + cla = self.class2cat[int(choice)] # --------------> + sketch_array = self.cat2sketch[cla] + sketch = random.choices(sketch_array,k=4) + sketch_array = [] + for sk in sketch: + sk = pickle.load(open(sk, 'rb')) # ------> Uncomment for sketches + key = list(sk.keys())[0] + sk = convert_to_np_raw(sk[key]) + sk = np.stack((sk, sk, sk), axis=0)/255.0 + sketch_array.append(sk) + sketch_array = np.stack(sketch_array, axis=0) # ---------------> + + # Delete useless gt_boxes + blobs['gt_boxes'][:,-1] = np.where(blobs['gt_boxes'][:,-1]==choice,1,0) + # Get query image + # print(sketch.shape) + # query = self.load_query(choice) # Uncomment for images + # print(query.shape) + # exit(0) + query = sketch_array # Uncomment for sketches + + else: + # query = self.load_query(index, minibatch_db[0]['img_id']) # Comment for sketches + # ''' # Uncomment for sketches + catgory = self.cat_list[index] + # list all the candidate image + # all_data = self._query[catgory] + + # Use image_id to determine the random seed + # The list l is candidate sequence, which random by image_id + # print(catgory) + # exit() + id = minibatch_db[0]['img_id'] + random.seed(id) + # l = list(range(len(all_data))) + # random.shuffle(l) + cla = self.class2cat[int(catgory)] + # print(cla) + sketch_array = self.cat2sketch[cla] + sketch_data_array = [] + random.shuffle(sketch_array) + #print(sketch_array) + for sketch in sketch_array[0:20]: + sketch = pickle.load(open(sketch, 'rb')) + key = list(sketch.keys())[0] + sketch = convert_to_np_raw(sketch[key]) + # intrim_sketch = self.toTensor(sketch) + # save_image(intrim_sketch, 'outfile.jpg') + sketch = np.stack((sketch, sketch, sketch), axis=0)/255.0 + # print(sketch.shape) + # im = Image.fromarray(sketch) + # im.save('outfile'+str(sketch_num)+'.jpg') + + # exit(0) + sketch_data_array.append(sketch) + query = np.stack(sketch_data_array) + + # choose the candidate sequence and take out the data information + # position=l[self.query_position%len(l)] + # data = all_data[position] + # ''' + + data = torch.from_numpy(blobs['data']) + # query = torch.from_numpy(query) + query = torch.from_numpy(query).contiguous() # Uncomment for sketches + # query = torch.from_numpy(query) # Comment for sketches + # query = query.permute(0, 3, 1, 2).contiguous().squeeze(0) # Comment for the case of sketches + im_info = torch.from_numpy(blobs['im_info']) + + # we need to random shuffle the bounding box. + data_height, data_width = data.size(1), data.size(2) + if self.training: + np.random.shuffle(blobs['gt_boxes']) + gt_boxes = torch.from_numpy(blobs['gt_boxes']) + + ######################################################## + # padding the input image to fixed size for each group # + ######################################################## + + # NOTE1: need to cope with the case where a group cover both conditions. (done) + # NOTE2: need to consider the situation for the tail samples. (no worry) + # NOTE3: need to implement a parallel data loader. (no worry) + # get the index range + + # if the image need to crop, crop to the target size. + ratio = self.ratio_list_batch[index] + + if self._roidb[index_ratio]['need_crop']: + if ratio < 1: + # this means that data_width << data_height, we need to crop the + # data_height + min_y = int(torch.min(gt_boxes[:,1])) + max_y = int(torch.max(gt_boxes[:,3])) + trim_size = int(np.floor(data_width / ratio)) + if trim_size > data_height: + trim_size = data_height + box_region = max_y - min_y + 1 + if min_y == 0: + y_s = 0 + else: + if (box_region-trim_size) < 0: + y_s_min = max(max_y-trim_size, 0) + y_s_max = min(min_y, data_height-trim_size) + if y_s_min == y_s_max: + y_s = y_s_min + else: + y_s = np.random.choice(range(y_s_min, y_s_max)) + else: + y_s_add = int((box_region-trim_size)/2) + if y_s_add == 0: + y_s = min_y + else: + y_s = np.random.choice(range(min_y, min_y+y_s_add)) + # crop the image + data = data[:, y_s:(y_s + trim_size), :, :] + + # shift y coordiante of gt_boxes + gt_boxes[:, 1] = gt_boxes[:, 1] - float(y_s) + gt_boxes[:, 3] = gt_boxes[:, 3] - float(y_s) + + # update gt bounding box according the trip + gt_boxes[:, 1].clamp_(0, trim_size - 1) + gt_boxes[:, 3].clamp_(0, trim_size - 1) + + else: + # this means that data_width >> data_height, we need to crop the + # data_width + min_x = int(torch.min(gt_boxes[:,0])) + max_x = int(torch.max(gt_boxes[:,2])) + trim_size = int(np.ceil(data_height * ratio)) + if trim_size > data_width: + trim_size = data_width + box_region = max_x - min_x + 1 + if min_x == 0: + x_s = 0 + else: + if (box_region-trim_size) < 0: + x_s_min = max(max_x-trim_size, 0) + x_s_max = min(min_x, data_width-trim_size) + if x_s_min == x_s_max: + x_s = x_s_min + else: + x_s = np.random.choice(range(x_s_min, x_s_max)) + else: + x_s_add = int((box_region-trim_size)/2) + if x_s_add == 0: + x_s = min_x + else: + x_s = np.random.choice(range(min_x, min_x+x_s_add)) + # crop the image + data = data[:, :, x_s:(x_s + trim_size), :] + + # shift x coordiante of gt_boxes + gt_boxes[:, 0] = gt_boxes[:, 0] - float(x_s) + gt_boxes[:, 2] = gt_boxes[:, 2] - float(x_s) + # update gt bounding box according the trip + gt_boxes[:, 0].clamp_(0, trim_size - 1) + gt_boxes[:, 2].clamp_(0, trim_size - 1) + + # based on the ratio, padding the image. + if ratio < 1: + # this means that data_width < data_height + trim_size = int(np.floor(data_width / ratio)) + + padding_data = torch.FloatTensor(int(np.ceil(data_width / ratio)), \ + data_width, 3).zero_() + + padding_data[:data_height, :, :] = data[0] + # update im_info + im_info[0, 0] = padding_data.size(0) + # print("height %d %d \n" %(index, anchor_idx)) + elif ratio > 1: + # this means that data_width > data_height + # if the image need to crop. + padding_data = torch.FloatTensor(data_height, \ + int(np.ceil(data_height * ratio)), 3).zero_() + padding_data[:, :data_width, :] = data[0] + im_info[0, 1] = padding_data.size(1) + else: + trim_size = min(data_height, data_width) + padding_data = torch.FloatTensor(trim_size, trim_size, 3).zero_() + padding_data = data[0][:trim_size, :trim_size, :] + # gt_boxes.clamp_(0, trim_size) + gt_boxes[:, :4].clamp_(0, trim_size) + im_info[0, 0] = trim_size + im_info[0, 1] = trim_size + + + # check the bounding box: + not_keep = (gt_boxes[:,0] == gt_boxes[:,2]) | (gt_boxes[:,1] == gt_boxes[:,3]) + # not_keep = (gt_boxes[:,2] - gt_boxes[:,0]) < 10 + # print(not_keep) + # not_keep = (gt_boxes[:,2] - gt_boxes[:,0]) < torch.FloatTensor([10]) | (gt_boxes[:,3] - gt_boxes[:,1]) < torch.FloatTensor([10]) + + keep = torch.nonzero(not_keep == 0).view(-1) + + gt_boxes_padding = torch.FloatTensor(self.max_num_box, gt_boxes.size(1)).zero_() + if keep.numel() != 0 : + gt_boxes = gt_boxes[keep] + num_boxes = min(gt_boxes.size(0), self.max_num_box) + gt_boxes_padding[:num_boxes,:] = gt_boxes[:num_boxes] + else: + num_boxes = 0 + + # permute trim_data to adapt to downstream processing + padding_data = padding_data.permute(2, 0, 1).contiguous() + im_info = im_info.view(3) + + return padding_data, query, im_info, gt_boxes_padding, num_boxes + else: + data = data.permute(0, 3, 1, 2).contiguous().view(3, data_height, data_width) + im_info = im_info.view(3) + + # gt_boxes = torch.FloatTensor([1,1,1,1,1]) + gt_boxes = torch.from_numpy(blobs['gt_boxes']) + choice = self.cat_list[index] + + return data, query, im_info, gt_boxes, choice + + def load_query(self, choice, id=0): + + if self.training: + # Random choice query catgory image + all_data = self._query[choice] + data = random.choice(all_data) + else: + # Take out the purpose category for testing + catgory = self.cat_list[choice] + # list all the candidate image + all_data = self._query[catgory] + + # Use image_id to determine the random seed + # The list l is candidate sequence, which random by image_id + random.seed(id) + l = list(range(len(all_data))) + random.shuffle(l) + + # choose the candidate sequence and take out the data information + position=l[self.query_position%len(l)] + data = all_data[position] + + # Get image + path = data['image_path'] + im = imread(path) + + + if len(im.shape) == 2: + im = im[:,:,np.newaxis] + im = np.concatenate((im,im,im), axis=2) + + im = crop(im, data['boxes'], cfg.TRAIN.query_size) + # flip the channel, since the original one using cv2 + # rgb -> bgr + # im = im[:,:,::-1] + if random.randint(0,99)/100 > 0.5 and self.training: + im = im[:, ::-1, :] + + + im, im_scale = prep_im_for_blob(im, cfg.PIXEL_MEANS, cfg.TRAIN.query_size, + cfg.TRAIN.MAX_SIZE) + + query = im_list_to_blob([im]) + + return query + + def __len__(self): + return len(self.ratio_index) + + def filter(self, seen): + if seen==1: + self.list = cfg.train_categories + # Group number to class + if len(self.list)==1: + self.list = [self._classes[cat] for cat in range(1,81) if cat%4 != self.list[0]] + + elif seen==2: + self.list = cfg.test_categories + # Group number to class + if len(self.list)==1: + self.list = [self._classes[cat] for cat in range(1,81) if cat%4 == self.list[0]] + + elif seen==3: + self.list = cfg.train_categories + cfg.test_categories + # Group number to class + if len(self.list)==2: + self.list = [self._classes[cat] for cat in range(1,81)] + + elif seen==5: + self.list = cfg.train_categories + if len(self.list)==1: + self.list = [self._classes[cat] for cat in range(1,57) if cat%4 != self.list[0]] + elif seen==6: + self.list = cfg.train_categories + if len(self.list)==1: + self.list = [self._classes[cat] for cat in range(1,57) if cat%4 == self.list[0]] + + elif seen==7: + self.list = cfg.train_categories + self.list = [self._classes[cat] for cat in range(1,57)] + + elif seen=='sketch': + self.list = [self._classes[key] for key in self._classes.keys()] + + + self.list_ind = [self._classes_inv[x] for x in self.list] + + def probability(self): + show_time = {} + for i in self.list_ind: + show_time[i] = 0 + for roi in self._roidb: + result = Counter(roi['gt_classes']) + for t in result: + if t in self.list_ind: + show_time[t] += result[t] + + for i in self.list_ind: + show_time[i] = 1/show_time[i] + + sum_prob = sum(show_time.values()) + + for i in self.list_ind: + show_time[i] = show_time[i]/sum_prob + + self.show_time = show_time diff --git a/lib/roi_data_layer/sketchBatchLoaderVOC.py b/lib/roi_data_layer/sketchBatchLoaderVOC.py new file mode 100644 index 0000000..e8febf9 --- /dev/null +++ b/lib/roi_data_layer/sketchBatchLoaderVOC.py @@ -0,0 +1,526 @@ + +"""The data layer used during training to train a Fast R-CNN network. +""" + +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +import torch.utils.data as data +from PIL import Image, ImageDraw, ImageOps +import torch +import torch.nn as nn +from collections import Counter + +#from scipy.misc.pilutil import imread +#from matplotlib.pyplot import imread +from cv2 import imread +from model.utils.config import cfg +from roi_data_layer.minibatch import get_minibatch, get_minibatch +from model.utils.blob import prep_im_for_blob, im_list_to_blob, crop +from model.rpn.bbox_transform import bbox_transform_inv, clip_boxes +from torchvision.utils import save_image +import torchvision.transforms as transforms +import numpy as np +import cv2 +import random +import time +import pdb +import pickle +import random +from collections import defaultdict + +def convert_to_np_raw(drawing, width=256, height=256): + img = np.zeros((width, height)) + pil_img = convert_to_PIL(drawing) + pil_img.thumbnail((width, height), Image.ANTIALIAS) + pil_img = pil_img.convert('RGB') + pixels = pil_img.load() + + for i in range(0, width): + for j in range(0, height): + img[i,j] = 1- pixels[j,i][0]/255.0 + return img + +def convert_to_PIL(drawing, width=256, height=256): + pil_img = Image.new('RGB', (width, height), 'white') + pixels = pil_img.load() + draw = ImageDraw.Draw(pil_img) + for x,y in drawing: + for i in range(1, len(x)): + draw.line((x[i-1], y[i-1], x[i], y[i]), fill=0) + return pil_img + + + +class roibatchLoader(data.Dataset): + def __init__(self, roidb, ratio_list, ratio_index, query, batch_size, num_classes, sketch_path, sketch_class_2_label, training=True, normalize=None, seen=True): + self._roidb = roidb + self._query = query + # self._num_classes = num_classes + self._num_classes = 10 + # we make the height of image consistent to trim_height, trim_width + self.trim_height = cfg.TRAIN.TRIM_HEIGHT + self.trim_width = cfg.TRAIN.TRIM_WIDTH + self.max_num_box = cfg.MAX_NUM_GT_BOXES + self.training = training + self.normalize = normalize + self.ratio_list = ratio_list + self.query_position = 0 + self.sketch_path = sketch_path + self.class2labels = sketch_class_2_label + self.class2labels = pickle.load(open(self.class2labels, 'rb')) + self.draw_data_path = pickle.load(open(self.sketch_path, 'rb')) + + if training: + self.ratio_index = ratio_index + self.draw_data_path = self.draw_data_path['train_x'] + self.draw_data_path = random.sample(self.draw_data_path, 800000) + else: + random.seed(14) + self.cat_list = ratio_index[1] + self.ratio_index = ratio_index[0] + self.draw_data_path = self.draw_data_path['valid_x'] + self.draw_data_path = random.sample(self.draw_data_path, 8000) + + self.batch_size = batch_size + self.data_size = len(self.ratio_list) + self.cat2sketch = defaultdict(list) + label_array = [] + for draw_path in self.draw_data_path: + label = draw_path.split('/')[-2] + label_array.append(label) + self.cat2sketch[label].append(draw_path) + label_array = list(set(label_array)) + # print(label_array) + # exit(0) + + # given the ratio_list, we want to make the ratio same for each batch. + self.ratio_list_batch = torch.Tensor(self.data_size).zero_() + num_batch = int(np.ceil(len(ratio_index) / batch_size)) + if self.training: + for i in range(num_batch): + left_idx = i*batch_size + right_idx = min((i+1)*batch_size-1, self.data_size-1) + + if ratio_list[right_idx] < 1: + # for ratio < 1, we preserve the leftmost in each batch. + target_ratio = ratio_list[left_idx] + elif ratio_list[left_idx] > 1: + # for ratio > 1, we preserve the rightmost in each batch. + target_ratio = ratio_list[right_idx] + else: + # for ratio cross 1, we make it to be 1. + target_ratio = 1 + + self.ratio_list_batch[left_idx:(right_idx+1)] = target_ratio + + + self._cat_ids= [] + # self.cat2idx = {} + self.idx2cat = {} + # print(label_array) + label_array = ('bicycle', 'bird', + 'bus', 'car', 'cat', 'chair', + 'cow', 'dog', 'horse', + 'sheep', 'train') + self._cat_ids.extend([1,2,3,4,5,6,7,8,9,10,11]) + self.cat2idx = { + 'bicycle':1, 'bird':2, + 'bus':3, 'car':4, 'cat':5, 'chair':6, + 'cow':7, 'dog':8, 'horse':9, + 'sheep':10, 'train':11} + self.idx2cat = { + 1:'bicycle', 2:'bird', + 3:'bus', 4:'car', 5:'cat', 6:'chair', + 7:'cow', 8:'dog', 9:'horse', + 10:'sheep',11: 'train'} + # self._cat_ids = [ + # 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, + # 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + # 24, 25, 27, 28, 31, 32, 33, 34, 35, 36, + # 37, 38, 39, 40, 41, 42, 43, 44, 46, 47, + # 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + # 58, 59, 60, 61, 62, 63, 64, 65, 67, 70, + # 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + # 82, 84, 85, 86, 87, 88, 89, 90 + # ] + # print(coco_class_ind_to_cat_id) + # exit(0) + self._classes = { + ind + 1: cat_id for ind, cat_id in enumerate(self._cat_ids) + } + self._classes_inv = { + value: key for key, value in self._classes.items() + } + self.toTensor = transforms.ToTensor() + self.filter(seen=7) + self.probability() + self.class2cat = {} + self.cat2class = {} + for cat in label_array: + cat_id = self.cat2idx[cat] + cla = self._classes_inv[cat_id] + self.class2cat[cla] = cat + self.cat2class[cat] = cla + + + def __getitem__(self, index): + index_ratio = int(self.ratio_index[index]) + + # get the anchor index for current sample index + # here we set the anchor index to the last one + # sample in this group + minibatch_db = [self._roidb[index_ratio]] + + blobs = get_minibatch(minibatch_db , self._num_classes) + # print(self.list_ind) + + blobs['gt_boxes'] = [x for x in blobs['gt_boxes'] if x[-1] in self.list_ind] + blobs['gt_boxes'] = np.array(blobs['gt_boxes']) + + + if self.training: + # Random choice query catgory + try: + catgory = blobs['gt_boxes'][:,-1] + except: + print(blobs['gt_boxes']) + exit(0) + cand = np.unique(catgory) + if len(cand)==1: + choice = cand[0] + + + cla = self.class2cat[int(choice)] #---------------> + sketch_array = self.cat2sketch[cla] + # print(sketch_array) + sketch = random.choices(sketch_array,k=5) + sketch_array = [] + for sk in sketch: # ------> Uncomment for sketches + sk = pickle.load(open(sk, 'rb')) + key = list(sk.keys())[0] + sk = convert_to_np_raw(sk[key]) + sk = np.stack((sk, sk, sk), axis=0)/255.0 + sketch_array.append(sk) + sketch_array = np.stack(sketch_array, axis=0) #-------------> + + # sketch = random.choice(sketch_array) + # sketch = pickle.load(open(sketch, 'rb')) + # key = list(sketch.keys())[0] + # sketch = convert_to_np_raw(sketch[key]) + # sketch = np.stack((sketch, sketch, sketch), axis=0)/255.0 + + else: + p = [] + for i in cand: + p.append(self.show_time[i]) + p = np.array(p) + p /= p.sum() + choice = np.random.choice(cand,1,p=p)[0] + + cla = self.class2cat[int(choice)] # --------------> + sketch_array = self.cat2sketch[cla] + sketch = random.choices(sketch_array,k=2) + sketch_array = [] + for sk in sketch: + sk = pickle.load(open(sk, 'rb')) # ------> Uncomment for sketches + key = list(sk.keys())[0] + sk = convert_to_np_raw(sk[key]) + sk = np.stack((sk, sk, sk), axis=0)/255.0 + sketch_array.append(sk) + sketch_array = np.stack(sketch_array, axis=0) # ---------------> + + # Delete useless gt_boxes + blobs['gt_boxes'][:,-1] = np.where(blobs['gt_boxes'][:,-1]==choice,1,0) + # Get query image + # print(sketch.shape) + # query = self.load_query(choice) # Uncomment for images + # print(query.shape) + # exit(0) + query = sketch_array # Uncomment for sketches + + else: + # query = self.load_query(index, minibatch_db[0]['img_id']) # Comment for sketches + # ''' # Uncomment for sketches + catgory = self.cat_list[index] + # list all the candidate image + # all_data = self._query[catgory] + + # Use image_id to determine the random seed + # The list l is candidate sequence, which random by image_id + # print(catgory) + # exit() + id = minibatch_db[0]['img_id'] + random.seed(id) + # l = list(range(len(all_data))) + # random.shuffle(l) + cla = self.class2cat[int(catgory)] + sketch_array = self.cat2sketch[cla] + sketch_data_array = [] + random.shuffle(sketch_array) + #print(sketch_array) + for sketch in sketch_array[0:5]: + sketch = pickle.load(open(sketch, 'rb')) + key = list(sketch.keys())[0] + sketch = convert_to_np_raw(sketch[key]) + # intrim_sketch = self.toTensor(sketch) + # save_image(intrim_sketch, 'outfile.jpg') + sketch = np.stack((sketch, sketch, sketch), axis=0)/255.0 + # print(sketch.shape) + # im = Image.fromarray(sketch) + # im.save('outfile'+str(sketch_num)+'.jpg') + + # exit(0) + sketch_data_array.append(sketch) + query = np.stack(sketch_data_array) + + # choose the candidate sequence and take out the data information + # position=l[self.query_position%len(l)] + # data = all_data[position] + # ''' + + data = torch.from_numpy(blobs['data']) + # print(query.shape) + # exit(0) + # print(query.shape) + # query = torch.from_numpy(query) + query = torch.from_numpy(query).contiguous() # Uncomment for sketches + # query = torch.from_numpy(query) # Comment for sketches + # query = query.permute(0, 3, 1, 2).contiguous().squeeze(0) # Comment for the case of sketches + im_info = torch.from_numpy(blobs['im_info']) + + # we need to random shuffle the bounding box. + data_height, data_width = data.size(1), data.size(2) + if self.training: + np.random.shuffle(blobs['gt_boxes']) + gt_boxes = torch.from_numpy(blobs['gt_boxes']) + + ######################################################## + # padding the input image to fixed size for each group # + ######################################################## + + # NOTE1: need to cope with the case where a group cover both conditions. (done) + # NOTE2: need to consider the situation for the tail samples. (no worry) + # NOTE3: need to implement a parallel data loader. (no worry) + # get the index range + + # if the image need to crop, crop to the target size. + ratio = self.ratio_list_batch[index] + + if self._roidb[index_ratio]['need_crop']: + if ratio < 1: + # this means that data_width << data_height, we need to crop the + # data_height + min_y = int(torch.min(gt_boxes[:,1])) + max_y = int(torch.max(gt_boxes[:,3])) + trim_size = int(np.floor(data_width / ratio)) + if trim_size > data_height: + trim_size = data_height + box_region = max_y - min_y + 1 + if min_y == 0: + y_s = 0 + else: + if (box_region-trim_size) < 0: + y_s_min = max(max_y-trim_size, 0) + y_s_max = min(min_y, data_height-trim_size) + if y_s_min == y_s_max: + y_s = y_s_min + else: + y_s = np.random.choice(range(y_s_min, y_s_max)) + else: + y_s_add = int((box_region-trim_size)/2) + if y_s_add == 0: + y_s = min_y + else: + y_s = np.random.choice(range(min_y, min_y+y_s_add)) + # crop the image + data = data[:, y_s:(y_s + trim_size), :, :] + + # shift y coordiante of gt_boxes + gt_boxes[:, 1] = gt_boxes[:, 1] - float(y_s) + gt_boxes[:, 3] = gt_boxes[:, 3] - float(y_s) + + # update gt bounding box according the trip + gt_boxes[:, 1].clamp_(0, trim_size - 1) + gt_boxes[:, 3].clamp_(0, trim_size - 1) + + else: + # this means that data_width >> data_height, we need to crop the + # data_width + min_x = int(torch.min(gt_boxes[:,0])) + max_x = int(torch.max(gt_boxes[:,2])) + trim_size = int(np.ceil(data_height * ratio)) + if trim_size > data_width: + trim_size = data_width + box_region = max_x - min_x + 1 + if min_x == 0: + x_s = 0 + else: + if (box_region-trim_size) < 0: + x_s_min = max(max_x-trim_size, 0) + x_s_max = min(min_x, data_width-trim_size) + if x_s_min == x_s_max: + x_s = x_s_min + else: + x_s = np.random.choice(range(x_s_min, x_s_max)) + else: + x_s_add = int((box_region-trim_size)/2) + if x_s_add == 0: + x_s = min_x + else: + x_s = np.random.choice(range(min_x, min_x+x_s_add)) + # crop the image + data = data[:, :, x_s:(x_s + trim_size), :] + + # shift x coordiante of gt_boxes + gt_boxes[:, 0] = gt_boxes[:, 0] - float(x_s) + gt_boxes[:, 2] = gt_boxes[:, 2] - float(x_s) + # update gt bounding box according the trip + gt_boxes[:, 0].clamp_(0, trim_size - 1) + gt_boxes[:, 2].clamp_(0, trim_size - 1) + + # based on the ratio, padding the image. + if ratio < 1: + # this means that data_width < data_height + trim_size = int(np.floor(data_width / ratio)) + + padding_data = torch.FloatTensor(int(np.ceil(data_width / ratio)), \ + data_width, 3).zero_() + + padding_data[:data_height, :, :] = data[0] + # update im_info + im_info[0, 0] = padding_data.size(0) + # print("height %d %d \n" %(index, anchor_idx)) + elif ratio > 1: + # this means that data_width > data_height + # if the image need to crop. + padding_data = torch.FloatTensor(data_height, \ + int(np.ceil(data_height * ratio)), 3).zero_() + padding_data[:, :data_width, :] = data[0] + im_info[0, 1] = padding_data.size(1) + else: + trim_size = min(data_height, data_width) + padding_data = torch.FloatTensor(trim_size, trim_size, 3).zero_() + padding_data = data[0][:trim_size, :trim_size, :] + # gt_boxes.clamp_(0, trim_size) + gt_boxes[:, :4].clamp_(0, trim_size) + im_info[0, 0] = trim_size + im_info[0, 1] = trim_size + + + # check the bounding box: + not_keep = (gt_boxes[:,0] == gt_boxes[:,2]) | (gt_boxes[:,1] == gt_boxes[:,3]) + # not_keep = (gt_boxes[:,2] - gt_boxes[:,0]) < 10 + # print(not_keep) + # not_keep = (gt_boxes[:,2] - gt_boxes[:,0]) < torch.FloatTensor([10]) | (gt_boxes[:,3] - gt_boxes[:,1]) < torch.FloatTensor([10]) + + keep = torch.nonzero(not_keep == 0).view(-1) + + gt_boxes_padding = torch.FloatTensor(self.max_num_box, gt_boxes.size(1)).zero_() + if keep.numel() != 0 : + gt_boxes = gt_boxes[keep] + num_boxes = min(gt_boxes.size(0), self.max_num_box) + gt_boxes_padding[:num_boxes,:] = gt_boxes[:num_boxes] + else: + num_boxes = 0 + + # permute trim_data to adapt to downstream processing + padding_data = padding_data.permute(2, 0, 1).contiguous() + im_info = im_info.view(3) + + return padding_data, query, im_info, gt_boxes_padding, num_boxes + else: + data = data.permute(0, 3, 1, 2).contiguous().view(3, data_height, data_width) + im_info = im_info.view(3) + + # gt_boxes = torch.FloatTensor([1,1,1,1,1]) + gt_boxes = torch.from_numpy(blobs['gt_boxes']) + choice = self.cat_list[index] + + return data, query, im_info, gt_boxes, choice + + def load_query(self, choice, id=0): + + if self.training: + # Random choice query catgory image + all_data = self._query[choice] + data = random.choice(all_data) + else: + # Take out the purpose category for testing + catgory = self.cat_list[choice] + # list all the candidate image + all_data = self._query[catgory] + + # Use image_id to determine the random seed + # The list l is candidate sequence, which random by image_id + random.seed(id) + l = list(range(len(all_data))) + random.shuffle(l) + + # choose the candidate sequence and take out the data information + position=l[self.query_position%len(l)] + data = all_data[position] + + # Get image + path = data['image_path'] + im = imread(path) + + + if len(im.shape) == 2: + im = im[:,:,np.newaxis] + im = np.concatenate((im,im,im), axis=2) + + im = crop(im, data['boxes'], cfg.TRAIN.query_size) + # flip the channel, since the original one using cv2 + # rgb -> bgr + # im = im[:,:,::-1] + if random.randint(0,99)/100 > 0.5 and self.training: + im = im[:, ::-1, :] + + + im, im_scale = prep_im_for_blob(im, cfg.PIXEL_MEANS, cfg.TRAIN.query_size, + cfg.TRAIN.MAX_SIZE) + + query = im_list_to_blob([im]) + + return query + + def __len__(self): + return len(self.ratio_index) + + def filter(self, seen): + if seen==1: + self.list = [2,3,4,5,6,7,9,11,12,13,14,15,16,18,19,20] + elif seen==2: + self.list = [1,8,10,17] + elif seen==3: + self.list = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20] + elif seen==5: + self.list = [2,3,4,6,7,8,10] + elif seen==6: + self.list = [1,5,9] + elif seen==7 : + self.list = [1,2,3,4,5,6,7,8,9,10] + + self.list_ind = [self._classes_inv[x] for x in self.list] + + def probability(self): + show_time = {} + for i in self.list_ind: + show_time[i] = 0 + for roi in self._roidb: + result = Counter(roi['gt_classes']) + for t in result: + if t in self.list_ind: + show_time[t] += result[t] + + for i in self.list_ind: + # show_time[i] = 1/show_time[i] + show_time[i] = 0.5 + sum_prob = sum(show_time.values()) + + for i in self.list_ind: + show_time[i] = show_time[i]/sum_prob + + self.show_time = show_time \ No newline at end of file diff --git a/lib/roi_data_layer/sketchBatchLoaderVOC_v2.py b/lib/roi_data_layer/sketchBatchLoaderVOC_v2.py new file mode 100644 index 0000000..a9999d1 --- /dev/null +++ b/lib/roi_data_layer/sketchBatchLoaderVOC_v2.py @@ -0,0 +1,532 @@ + +"""The data layer used during training to train a Fast R-CNN network. +""" + +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +import torch.utils.data as data +from PIL import Image, ImageDraw, ImageOps +import torch +import torch.nn as nn +from collections import Counter + +#from scipy.misc.pilutil import imread +#from matplotlib.pyplot import imread +from cv2 import imread +from model.utils.config import cfg +from roi_data_layer.minibatch import get_minibatch, get_minibatch +from model.utils.blob import prep_im_for_blob, im_list_to_blob, crop +from model.rpn.bbox_transform import bbox_transform_inv, clip_boxes +from torchvision.utils import save_image +import torchvision.transforms as transforms +import numpy as np +import cv2 +import random +import time +import pdb +import pickle +import random +from collections import defaultdict + +def convert_to_np_raw(drawing, width=256, height=256): + img = np.zeros((width, height)) + pil_img = convert_to_PIL(drawing) + pil_img.thumbnail((width, height), Image.ANTIALIAS) + pil_img = pil_img.convert('RGB') + pixels = pil_img.load() + + for i in range(0, width): + for j in range(0, height): + img[i,j] = 1- pixels[j,i][0]/255.0 + return img + +def convert_to_PIL(drawing, width=256, height=256): + pil_img = Image.new('RGB', (width, height), 'white') + pixels = pil_img.load() + draw = ImageDraw.Draw(pil_img) + for x,y in drawing: + for i in range(1, len(x)): + draw.line((x[i-1], y[i-1], x[i], y[i]), fill=0) + return pil_img + + + +class roibatchLoader(data.Dataset): + def __init__(self, roidb, ratio_list, ratio_index, query, batch_size, num_classes, sketch_path, sketch_class_2_label, training=True, normalize=None, seen=True): + self._roidb = roidb + self._query = query + # self._num_classes = num_classes + self._num_classes = 10 + # we make the height of image consistent to trim_height, trim_width + self.trim_height = cfg.TRAIN.TRIM_HEIGHT + self.trim_width = cfg.TRAIN.TRIM_WIDTH + self.max_num_box = cfg.MAX_NUM_GT_BOXES + self.training = training + self.normalize = normalize + self.ratio_list = ratio_list + self.query_position = 0 + self.sketch_path = sketch_path + self.class2labels = sketch_class_2_label + self.class2labels = pickle.load(open(self.class2labels, 'rb')) + self.draw_data_path = pickle.load(open(self.sketch_path, 'rb')) + + if training: + self.ratio_index = ratio_index + self.draw_data_path = self.draw_data_path['train_x'] + self.draw_data_path = random.sample(self.draw_data_path, 800000) + else: + self.cat_list = ratio_index[1] + self.ratio_index = ratio_index[0] + random.seed(14) + self.draw_data_path = self.draw_data_path['valid_x'] + self.draw_data_path = random.sample(self.draw_data_path, 8000) + + self.batch_size = batch_size + self.data_size = len(self.ratio_list) + self.cat2sketch = defaultdict(list) + label_array = [] + for draw_path in self.draw_data_path: + label = draw_path.split('/')[-2] + label_array.append(label) + self.cat2sketch[label].append(draw_path) + label_array = list(set(label_array)) + # print(label_array) + # exit(0) + + # given the ratio_list, we want to make the ratio same for each batch. + self.ratio_list_batch = torch.Tensor(self.data_size).zero_() + num_batch = int(np.ceil(len(ratio_index) / batch_size)) + if self.training: + for i in range(num_batch): + left_idx = i*batch_size + right_idx = min((i+1)*batch_size-1, self.data_size-1) + + if ratio_list[right_idx] < 1: + # for ratio < 1, we preserve the leftmost in each batch. + target_ratio = ratio_list[left_idx] + elif ratio_list[left_idx] > 1: + # for ratio > 1, we preserve the rightmost in each batch. + target_ratio = ratio_list[right_idx] + else: + # for ratio cross 1, we make it to be 1. + target_ratio = 1 + + self.ratio_list_batch[left_idx:(right_idx+1)] = target_ratio + + + self._cat_ids= [] + # self.cat2idx = {} + self.idx2cat = {} + # print(label_array) + label_array = ( '__background__', + 'bicycle', 'bird', + 'bus', 'car', 'cat', 'chair', + 'cow', 'dog', 'horse', + 'sheep') + self._cat_ids.extend([1,2,3,4,5,6,7,8,9,10]) + self.cat2idx = { '__background__':0, + 'bicycle':1, 'bird':2, + 'bus':3, 'car':4, 'cat':5, 'chair':6, + 'cow':7, 'dog':8, 'horse':9, + 'sheep':10} + self.idx2cat = { 0:'__background__', + 1:'bicycle', 2:'bird', + 3:'bus', 4:'car', 5:'cat', 6:'chair', + 7:'cow', 8:'dog', 9:'horse', + 10:'sheep'} + # self._cat_ids = [ + # 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, + # 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + # 24, 25, 27, 28, 31, 32, 33, 34, 35, 36, + # 37, 38, 39, 40, 41, 42, 43, 44, 46, 47, + # 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + # 58, 59, 60, 61, 62, 63, 64, 65, 67, 70, + # 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + # 82, 84, 85, 86, 87, 88, 89, 90 + # ] + # print(coco_class_ind_to_cat_id) + # exit(0) + self._classes = { + ind + 1: cat_id for ind, cat_id in enumerate(self._cat_ids) + } + self._classes_inv = { + value: key for key, value in self._classes.items() + } + self.toTensor = transforms.ToTensor() + self.filter(seen=7) + self.probability() + self.class2cat = {} + self.cat2class = {} + for cat in label_array: + if cat=="__background__": + pass + else: + cat_id = self.cat2idx[cat] + cla = self._classes_inv[cat_id] + self.class2cat[cla] = cat + self.cat2class[cat] = cla + + + def __getitem__(self, index): + index_ratio = int(self.ratio_index[index]) + + # get the anchor index for current sample index + # here we set the anchor index to the last one + # sample in this group + minibatch_db = [self._roidb[index_ratio]] + + blobs = get_minibatch(minibatch_db , self._num_classes) + # print(self.list_ind) + + blobs['gt_boxes'] = [x for x in blobs['gt_boxes'] if x[-1] in self.list_ind] + blobs['gt_boxes'] = np.array(blobs['gt_boxes']) + + + if self.training: + # Random choice query catgory + try: + catgory = blobs['gt_boxes'][:,-1] + except: + print(blobs['gt_boxes']) + exit(0) + cand = np.unique(catgory) + if len(cand)==1: + choice = cand[0] + + + cla = self.class2cat[int(choice)] #---------------> + sketch_array = self.cat2sketch[cla] + # print(sketch_array) + sketch = random.choices(sketch_array,k=5) + sketch_array = [] + for sk in sketch: # ------> Uncomment for sketches + sk = pickle.load(open(sk, 'rb')) + key = list(sk.keys())[0] + sk = convert_to_np_raw(sk[key]) + sk = np.stack((sk, sk, sk), axis=0)/255.0 + sketch_array.append(sk) + sketch_array = np.stack(sketch_array, axis=0) #-------------> + + # sketch = random.choice(sketch_array) + # sketch = pickle.load(open(sketch, 'rb')) + # key = list(sketch.keys())[0] + # sketch = convert_to_np_raw(sketch[key]) + # sketch = np.stack((sketch, sketch, sketch), axis=0)/255.0 + + else: + p = [] + for i in cand: + p.append(self.show_time[i]) + p = np.array(p) + p /= p.sum() + choice = np.random.choice(cand,1,p=p)[0] + + cla = self.class2cat[int(choice)] # --------------> + sketch_array = self.cat2sketch[cla] + sketch = random.choices(sketch_array,k=5) + sketch_array = [] + for sk in sketch: + sk = pickle.load(open(sk, 'rb')) # ------> Uncomment for sketches + key = list(sk.keys())[0] + sk = convert_to_np_raw(sk[key]) + sk = np.stack((sk, sk, sk), axis=0)/255.0 + sketch_array.append(sk) + sketch_array = np.stack(sketch_array, axis=0) # ---------------> + + # Delete useless gt_boxes + blobs['gt_boxes'][:,-1] = np.where(blobs['gt_boxes'][:,-1]==choice,1,0) + # Get query image + # print(sketch.shape) + # query = self.load_query(choice) # Uncomment for images + # print(query.shape) + # exit(0) + query = sketch_array # Uncomment for sketches + + else: + # query = self.load_query(index, minibatch_db[0]['img_id']) # Comment for sketches + # ''' # Uncomment for sketches + catgory = self.cat_list[index] + # list all the candidate image + # all_data = self._query[catgory] + + # Use image_id to determine the random seed + # The list l is candidate sequence, which random by image_id + # print(catgory) + # exit() + id = minibatch_db[0]['img_id'] + random.seed(id) + # l = list(range(len(all_data))) + # random.shuffle(l) + cla = self.class2cat[int(catgory)] + sketch_array = self.cat2sketch[cla] + sketch_data_array = [] + random.shuffle(sketch_array) + #print(sketch_array) + for sketch in sketch_array[0:5]: + sketch = pickle.load(open(sketch, 'rb')) + key = list(sketch.keys())[0] + sketch = convert_to_np_raw(sketch[key]) + # intrim_sketch = self.toTensor(sketch) + # save_image(intrim_sketch, 'outfile.jpg') + sketch = np.stack((sketch, sketch, sketch), axis=0)/255.0 + # print(sketch.shape) + # im = Image.fromarray(sketch) + # im.save('outfile'+str(sketch_num)+'.jpg') + + # exit(0) + sketch_data_array.append(sketch) + query = np.stack(sketch_data_array) + + # choose the candidate sequence and take out the data information + # position=l[self.query_position%len(l)] + # data = all_data[position] + # ''' + + data = torch.from_numpy(blobs['data']) + # print(query.shape) + # exit(0) + # print(query.shape) + # query = torch.from_numpy(query) + query = torch.from_numpy(query).contiguous() # Uncomment for sketches + # query = torch.from_numpy(query) # Comment for sketches + # query = query.permute(0, 3, 1, 2).contiguous().squeeze(0) # Comment for the case of sketches + im_info = torch.from_numpy(blobs['im_info']) + + # we need to random shuffle the bounding box. + data_height, data_width = data.size(1), data.size(2) + if self.training: + np.random.shuffle(blobs['gt_boxes']) + gt_boxes = torch.from_numpy(blobs['gt_boxes']) + + ######################################################## + # padding the input image to fixed size for each group # + ######################################################## + + # NOTE1: need to cope with the case where a group cover both conditions. (done) + # NOTE2: need to consider the situation for the tail samples. (no worry) + # NOTE3: need to implement a parallel data loader. (no worry) + # get the index range + + # if the image need to crop, crop to the target size. + ratio = self.ratio_list_batch[index] + + if self._roidb[index_ratio]['need_crop']: + if ratio < 1: + # this means that data_width << data_height, we need to crop the + # data_height + min_y = int(torch.min(gt_boxes[:,1])) + max_y = int(torch.max(gt_boxes[:,3])) + trim_size = int(np.floor(data_width / ratio)) + if trim_size > data_height: + trim_size = data_height + box_region = max_y - min_y + 1 + if min_y == 0: + y_s = 0 + else: + if (box_region-trim_size) < 0: + y_s_min = max(max_y-trim_size, 0) + y_s_max = min(min_y, data_height-trim_size) + if y_s_min == y_s_max: + y_s = y_s_min + else: + y_s = np.random.choice(range(y_s_min, y_s_max)) + else: + y_s_add = int((box_region-trim_size)/2) + if y_s_add == 0: + y_s = min_y + else: + y_s = np.random.choice(range(min_y, min_y+y_s_add)) + # crop the image + data = data[:, y_s:(y_s + trim_size), :, :] + + # shift y coordiante of gt_boxes + gt_boxes[:, 1] = gt_boxes[:, 1] - float(y_s) + gt_boxes[:, 3] = gt_boxes[:, 3] - float(y_s) + + # update gt bounding box according the trip + gt_boxes[:, 1].clamp_(0, trim_size - 1) + gt_boxes[:, 3].clamp_(0, trim_size - 1) + + else: + # this means that data_width >> data_height, we need to crop the + # data_width + min_x = int(torch.min(gt_boxes[:,0])) + max_x = int(torch.max(gt_boxes[:,2])) + trim_size = int(np.ceil(data_height * ratio)) + if trim_size > data_width: + trim_size = data_width + box_region = max_x - min_x + 1 + if min_x == 0: + x_s = 0 + else: + if (box_region-trim_size) < 0: + x_s_min = max(max_x-trim_size, 0) + x_s_max = min(min_x, data_width-trim_size) + if x_s_min == x_s_max: + x_s = x_s_min + else: + x_s = np.random.choice(range(x_s_min, x_s_max)) + else: + x_s_add = int((box_region-trim_size)/2) + if x_s_add == 0: + x_s = min_x + else: + x_s = np.random.choice(range(min_x, min_x+x_s_add)) + # crop the image + data = data[:, :, x_s:(x_s + trim_size), :] + + # shift x coordiante of gt_boxes + gt_boxes[:, 0] = gt_boxes[:, 0] - float(x_s) + gt_boxes[:, 2] = gt_boxes[:, 2] - float(x_s) + # update gt bounding box according the trip + gt_boxes[:, 0].clamp_(0, trim_size - 1) + gt_boxes[:, 2].clamp_(0, trim_size - 1) + + # based on the ratio, padding the image. + if ratio < 1: + # this means that data_width < data_height + trim_size = int(np.floor(data_width / ratio)) + + padding_data = torch.FloatTensor(int(np.ceil(data_width / ratio)), \ + data_width, 3).zero_() + + padding_data[:data_height, :, :] = data[0] + # update im_info + im_info[0, 0] = padding_data.size(0) + # print("height %d %d \n" %(index, anchor_idx)) + elif ratio > 1: + # this means that data_width > data_height + # if the image need to crop. + padding_data = torch.FloatTensor(data_height, \ + int(np.ceil(data_height * ratio)), 3).zero_() + padding_data[:, :data_width, :] = data[0] + im_info[0, 1] = padding_data.size(1) + else: + trim_size = min(data_height, data_width) + padding_data = torch.FloatTensor(trim_size, trim_size, 3).zero_() + padding_data = data[0][:trim_size, :trim_size, :] + # gt_boxes.clamp_(0, trim_size) + gt_boxes[:, :4].clamp_(0, trim_size) + im_info[0, 0] = trim_size + im_info[0, 1] = trim_size + + + # check the bounding box: + not_keep = (gt_boxes[:,0] == gt_boxes[:,2]) | (gt_boxes[:,1] == gt_boxes[:,3]) + # not_keep = (gt_boxes[:,2] - gt_boxes[:,0]) < 10 + # print(not_keep) + # not_keep = (gt_boxes[:,2] - gt_boxes[:,0]) < torch.FloatTensor([10]) | (gt_boxes[:,3] - gt_boxes[:,1]) < torch.FloatTensor([10]) + + keep = torch.nonzero(not_keep == 0).view(-1) + + gt_boxes_padding = torch.FloatTensor(self.max_num_box, gt_boxes.size(1)).zero_() + if keep.numel() != 0 : + gt_boxes = gt_boxes[keep] + num_boxes = min(gt_boxes.size(0), self.max_num_box) + gt_boxes_padding[:num_boxes,:] = gt_boxes[:num_boxes] + else: + num_boxes = 0 + + # permute trim_data to adapt to downstream processing + padding_data = padding_data.permute(2, 0, 1).contiguous() + im_info = im_info.view(3) + + return padding_data, query, im_info, gt_boxes_padding, num_boxes + else: + data = data.permute(0, 3, 1, 2).contiguous().view(3, data_height, data_width) + im_info = im_info.view(3) + + # gt_boxes = torch.FloatTensor([1,1,1,1,1]) + gt_boxes = torch.from_numpy(blobs['gt_boxes']) + choice = self.cat_list[index] + + return data, query, im_info, gt_boxes, choice + + def load_query(self, choice, id=0): + + if self.training: + # Random choice query catgory image + all_data = self._query[choice] + data = random.choice(all_data) + else: + # Take out the purpose category for testing + catgory = self.cat_list[choice] + # list all the candidate image + all_data = self._query[catgory] + + # Use image_id to determine the random seed + # The list l is candidate sequence, which random by image_id + random.seed(id) + l = list(range(len(all_data))) + random.shuffle(l) + + # choose the candidate sequence and take out the data information + position=l[self.query_position%len(l)] + data = all_data[position] + + # Get image + path = data['image_path'] + im = imread(path) + + + if len(im.shape) == 2: + im = im[:,:,np.newaxis] + im = np.concatenate((im,im,im), axis=2) + + im = crop(im, data['boxes'], cfg.TRAIN.query_size) + # flip the channel, since the original one using cv2 + # rgb -> bgr + # im = im[:,:,::-1] + if random.randint(0,99)/100 > 0.5 and self.training: + im = im[:, ::-1, :] + + + im, im_scale = prep_im_for_blob(im, cfg.PIXEL_MEANS, cfg.TRAIN.query_size, + cfg.TRAIN.MAX_SIZE) + + query = im_list_to_blob([im]) + + return query + + def __len__(self): + return len(self.ratio_index) + + def filter(self, seen): + if seen==1: + self.list = [2,3,4,5,6,7,9,11,12,13,14,15,16,18,19,20] + elif seen==2: + self.list = [1,8,10,17] + elif seen==3: + self.list = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20] + elif seen==5: + self.list = [2,3,4,6,7,8,10] + elif seen==6: + self.list = [1,5,9] + elif seen==7 : + self.list = [1,2,3,4,5,6,7,8,9,10] + + self.list_ind = [self._classes_inv[x] for x in self.list] + + def probability(self): + show_time = {} + for i in self.list_ind: + show_time[i] = 0 + for roi in self._roidb: + result = Counter(roi['gt_classes']) + for t in result: + if t in self.list_ind: + show_time[t] += result[t] + + print(show_time) + + for i in self.list_ind: + show_time[i] = 0.5 + + sum_prob = sum(show_time.values()) + + for i in self.list_ind: + show_time[i] = show_time[i]/sum_prob + + self.show_time = show_time \ No newline at end of file diff --git a/lib/setup.py b/lib/setup.py new file mode 100644 index 0000000..5d556c9 --- /dev/null +++ b/lib/setup.py @@ -0,0 +1,68 @@ +# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. +#!/usr/bin/env python + +import glob +import os + +import torch +from setuptools import find_packages +from setuptools import setup +from torch.utils.cpp_extension import CUDA_HOME +from torch.utils.cpp_extension import CppExtension +from torch.utils.cpp_extension import CUDAExtension + +requirements = ["torch", "torchvision"] + + +def get_extensions(): + this_dir = os.path.dirname(os.path.abspath(__file__)) + extensions_dir = os.path.join(this_dir, "model", "csrc") + + main_file = glob.glob(os.path.join(extensions_dir, "*.cpp")) + source_cpu = glob.glob(os.path.join(extensions_dir, "cpu", "*.cpp")) + source_cuda = glob.glob(os.path.join(extensions_dir, "cuda", "*.cu")) + + sources = main_file + source_cpu + extension = CppExtension + + extra_compile_args = {"cxx": []} + define_macros = [] + + if torch.cuda.is_available() and CUDA_HOME is not None: + extension = CUDAExtension + sources += source_cuda + define_macros += [("WITH_CUDA", None)] + extra_compile_args["nvcc"] = [ + "-DCUDA_HAS_FP16=1", + "-D__CUDA_NO_HALF_OPERATORS__", + "-D__CUDA_NO_HALF_CONVERSIONS__", + "-D__CUDA_NO_HALF2_OPERATORS__", + "-ccbin=/usr/bin/gcc-5", + ] + + sources = [os.path.join(extensions_dir, s) for s in sources] + + include_dirs = [extensions_dir] + + ext_modules = [ + extension( + "model._C", + sources, + include_dirs=include_dirs, + define_macros=define_macros, + extra_compile_args=extra_compile_args, + ) + ] + + return ext_modules + + +setup( + name="faster_rcnn", + version="0.1", + description="object detection in pytorch", + packages=find_packages(exclude=("configs", "tests",)), + # install_requires=requirements, + ext_modules=get_extensions(), + cmdclass={"build_ext": torch.utils.cpp_extension.BuildExtension}, +) diff --git a/ratio_index.pkl b/ratio_index.pkl new file mode 100644 index 0000000000000000000000000000000000000000..6828e549cc6003db107368cca3f15bee338ddfeb GIT binary patch literal 1210929 zcmXt=cR-Kt+y37rA)1It$;uw7kQLdf$SQm96{3i;5|WisWGiL+i0te=lbJormc9L+ z-}iWV{&%QOlM&#)?GI+%3(CYn0jTumVMDXx&L;8#v(3jh%I|IPHkuVwz(2^WqIaGEqyMuu2rB67>)Yn<|NYMHw;nZkpX@-OZwo*XD# z&_Mbh?!ub+W$(2>SPgDgN8J6BbSKLTZEp$R*H!)^p5p6n3nxucT)R8suX+ei4HjN< z5vKGOTEU=p`U@kbNVj#6_}LoLwGNei-5Fu}S^0gch_7Yb z52wlA#aifmTK)&)guma*ULWj#R`xCt!pdR7woRpThu7~Q`+p^bk2?$3o|G>At*~s4 z?5C)^-U`{*jFmlNi_q@6>?0qF=gY5tZtpH$&O!b|&1L_xRrdLrvbUNcJiAUP{8Ex=FmzW#LyB;l?ESdlnS_siQoB?8gCC(xo$=#Yc&Ux0Jpm z^Sh08Gk&$~mZzn&WHuStO7UeV9Ai}JUaD>P+)&R{%N zPnLaaKgBsF3TL{jKLcxuzovd0bMeS#irefed}A;B-!9_KmD+QR5)>w z{AV~9YH%L!klE0>lK$f+>ufaZ?tWFpPv|IrI{Q43=bbbCi(wq{unt#tl71`uv<3V3 zcPZIF4_Dr$oG&r4vhQ;imX_P_-)8+sY8BaCIcE>F5RV%peq z^;Uix^6vX6yEWV-MSfcbW-`y!k38p2Cd%*aRc-Ik$$f2DEnr{qfv(RF7d*#!-c#0 zNY@0OTvT;-R-6Kr) z@qam_i;(RH(K>RMeGV}3^{8`v1_m-}~59R;P`8a#A_?wpM zXTf~ppIFDC{S|kNbvg5w_)6Bp;``F?Zz}tL?1RhZvj1h=cm3OEBcw}Vd^)d|&VGRG zdD{tncrHD5Vf+JSKRjOgz(2wbycbNXEM0Y;TP1hN|MiRF+FcY*=6#|7&jBaqJ%sah z759$;=n7F+^kT(d;JhvGC*C_&=)gHSlXI%pEZMU^3+?FlS=P-)?rn3Y$sbWl^_M@O zy3cJBI&!}%!am%#SN6d?mq+vbN?RuT!j;NrR#CiDJ>jZ}!qlR|#VdqMz@?xs?d<+H z4}F!dEjVqCcs(D*yD`t#E{fOVIqS>5UdXwZ45olhYD(`{S^0`^kLr9<+=%Bw>w?lf z=XvrBTz^fvro)78V52e`#}Tyu!dUS^k{KTGJdH|{!6sV%_r!aFTe-h^wNk!~=u$!3 zI*OayRe8##h%e{dSm2G7b;z+;(T!Xsyu((g_Bqp&mzP-3>DHX!!FKmN9OtZ1^EYX zA8tzC{)~Ix4r(v(opgC-2@hJ!9?AQHZItZwsXv|fg`vHqt9(NK-<)UP*&p#&Wv|>_ zc$)R}?B8>tjqGi|DbFF^Gcq|R;uql0mcJ$Y=9z`Y_2F^(qj=w1z&;9#l-`s5eYL3g z2`lM+IcI94dpA-3A;;uz6)n6HFZ*rw`PEUfx2E2gcg0(x59d6r+luzV+r)ikT-)!K ze`rI+Z!9N%VXOGu7~wpy$b9ieZH12+zYhZyx0QQqQR?i$_ktaFB` z6O)89%LvDCAAA(9_z~{HFIR>0ze~4ht9X@6@z$S(ZP<6y_%5=O{o>~(eGdC|2kWmF z`jTrEe+vEfN#YkdpKLoS-j(~(w(as4jgtK`@1yQ-#D_CqCUeEj>#P3>Ja5az$bKkQ zd1j6m&)|MIt}yL$|8U^F-<5MK;}Y$Bk**ZysT22%8Qdp&Fm6$Mr2q0w`hqIQuz`D+ zDd&BeL-IRw4@>79aAMzHsH8mmx#!PbBK|X1aedE;ujV`$z;k>W_o?M2rF+41sg{=t z=^vrE->iqcFY0^h>FeoMvOd44AF zeEU08ap9bQE!dy$c;6lCLwmuB-!oFYX@Bw3Il_K7WFNFk`0%*!Nj~|%1V(p+fjp>}h6NZ;kUupGFvn*7g7 z$v(nHaUV0pjk%u`H8f69CNk#rBqV~W1ItNh0BC534J zq3~)eVPo!HiQFeIvcA0H6+d*eaIn4f1sjSF;X7Ok{p`Z~<$v+gITLTey|yId^kSd< zSpnz^R zmR0_5KNV*`MD0JQA)MYs_7?etdpL*vIA>3CzE;gI{lWLro#ou=vQzd>)O~oi{Eemy zmlhNzu|996NdJg+Hi_p=kq@%BvX#Cs`=>^2**#hB=RL%GkC!g*dhwbw#49q-XE)1! zYpU!)JU_EJmt6|WzW$?h^I0dux$i9)EBjY(>5lglugvqqx0>u`7lhvvMO&Oo$Y0^EqFMF%K;&#u3y9z0O@*DY|@?KPyb$F0< z=h#yE0LICFjr2$8=kyTy@9>?hNkRG3cyB2^Nqq7Z+Sw%itPaAeoIl^6%RhyF-`XVZ zz_^sZDgKV{y3go$^mgT0!1;KRbGP>q*(__`%;)h&^4sN+{Q>7p zLW1}>&J)uw;{Kc`xx9zj<;cE}^-}Gq_)MM$8N8QWW_`JzRC_IsNw@o+xJQh5KoRj! zz6(@lo>%ic@uE(fROts)5xTREUva+eveZ1CV%&XfrMt^{_nPOgBlqgGVQP1-gRoo+ z#rrl9PqkD0v`q1b6~u3HUp~P&hQE?Oo^^TJRJz0pvKz7f*XH~B zd>Oa->^o1^!;3c3b>jJL6{!4%9ZzUvo!zoAnjRJ-t_I}nBmgRSrTAX9UxF0{^yURY#rRG&N z?psWh$3IedJ44uDnDTjU5oRuuy+|eTqU9A|>YVHursBP>iYI!C&*l3{IljAG<-Ydz znRG+B=WT5#-s!ONo7;)cSSKF#Tj;^_@>H^T70$WIoZ~0fDQ*$_(?I(Z+ROfZj^fhm ziMz7ioo!@a!M=!N{eGz=-F^DqL)|ji@?1&f{$bDkArJS#p<|VA2+xrnJU4%Ht{F3b z7M+#0OuyquTPvF;7j{Z<`v){&lvnJL5lx-!m3)@5?Q%e4nofKkOE6pss>Ervv9H&nljW zd3kQOW&AEDC~kO=up{g9hLt8DiF3|xr}AVslfBVn@r>5O1FZL(ym$V`yjXCqxsR7F z=a$-;#J*|xLiWe(W8YHp+cM6RkIC=F_X+Fy^50o2dkIJJNb=T8mwgw%6aHo$&O9jl zZzJhL28l0a{n}Z|{vXe)kN)_1KY6o5eC%22q9+Qos%t#1Ws5sJ6?Wr!)U~(bX15c5 z;`vsFbMfOW>0P;BKIi_IFGKog`GsS7u5IMG>d15b$z6Z)rJqt$_zCXAc|3#jIAV$XA$-qU#B;*>tL)!DDS!3| zp=rA8<=Ce|;o?zKgwsw4t)@#qV!7}H&z&zCcEhP&vKMv}t~e^Z#P`zV6y=#;S!gmv z{sf-yIh=n}n<(Ks#$g=u+#^(Rp6pLI3vt&M!Y$o}N$lGO=f!(5ueUgt?ygn4eYp1= z%98HPR@qVZo{L@8cd;l75`yT-nXN(u#atd9MHA{H)ISZQ#AAA^RfT zU->_>?rg58oe7Sz`?EeiUzdFu=kA7U;xWIZ+syjTEhzi555l%y!czBy&bx$_=2<`?-Lm8K7&OIl_YxGC?3zXD2L@{n3 zIS;oSm%sTdwO5t;&HQE0J|+9hVBr#Ib`-|a&!4rWZ_7DS>4yB#j9WhJ2M$R0>zJ@3`{=$w{jbJ7zHo8H z|HpG)N z%Da>E_$K}OJ6QIpii*GYO?Y#hu&tB)zZf5%0kSV?B>O1#)oAL!8!CHo&cVaAr2oNu zJYzpyZYujxzFUo6skl9?i^bdsp1!m61r9tu8`X>F|Yn3 zdzI`@YY1=DlYJY{dq>_Urqj+3=G&{6^ka_-N3y?;^4#9xExYdo<@@isuqF3`QGMiJ z@=o@)JXdG)UiR{b?C*1gcV-InvET2+iC5>IXH`J?lKH!w51hlz-$*x)?-1Vk$+KDd z!qtRhw+j1|m*0+k8Q5OD0{eF)=l-s6>C-A|J}d5#?mpi~im~rf>d4+>vv2_CZ*%r{ z8vAlXI=AI|?T*Q9HBO1fX0CI!!Z>g9@LgfsAnDHY-RZ^~>7#j{8d_ccaGndx?ZjKomoAm@>)%ZL8ux$? zJ*2Z|9~KM|f5Q16$9u=er?Rh&QoQd_@$7}-cB{qfP;Y1Yxw3}r)i($~axSj_thiOw zz0F*_*Lh*$W$C+~6i(tfvU-91yLdjIMsLjfScS*ZzoUPf{z`vwpzMbk54SF|524+G zG2)MTuCyfI5xzHA-co$|!NSI0r8gZSZgxp{iuIGsy0T=SyL12CR8?_StgnQ5ikn$V zxQcj(=F-)nf3XYYuf}=p?I-?pymSW6rQzIHF3y(SwXbx~80WbiWY5caIh=EJ4)$Ud zq>pudJP?!$Rpl;`*O-LeNQ7fxY4WcY}iaemZ$p!_?0gu7XPmb|xC z;(T3@SN>e?!@c?5P?zUqK$!B@;NCt3yFcr4AM=xTTzRg(5}sjvceB5XZ|oLW^wKW@_rD@eb|e*6;Bl3*jE_m ztn)Rgmf~;6%6`*Tyh}gf(-OjZJl`ExN$2S)OyFEe^OVk?eQ}L@M;Pzd#V1O?@Thd9 z`A*`-IvpG+{|Ptw7mpJ*GMC+t=k7E1ZSn>A57(DJhjnF7eNWEIzKA@x2T5m```N;c2U3fH8s!Z`Wz9A3o!D3~n&-v+{!|JHe`@@8=#sl)!Z zkCCoqZTXk?7q((uEzB!^h4H$rvJ9!@d&K;0xFTJC?gwKki%%=4{71fvujRR)r=)mg z)=@9&Xu~~j=Xk|AZxi0d;#Pn!nXke-r88naoLj5V49yG&M z7Q#q)iQj5x0lG=pEArg)Wn9m4E>`3IGMVpgw|FnDgnlV`a(N!^VgGjsP&>=ImhfeKmuldkJongdgE=2BpYqSf9#dZS5;J7KyivHHbEJAb zjbA<1;UB&OIP;uIW;}1w-W|S6U52k&pnOfqpF(}x@dquEfAbF2;dER4BJH>El)Y%A z?7tZ22dsly=rib7C&sNnIn|xzuDAiTyDw3EE%y%}=5yh6*;~=ia@1F-r|b#L=Z2Z$ z#fXc9r*d9jCvSRh)m@T%Q6TS2iN>lcliwr%WJzbm-!)F-{&}sO>aiAl1@g9{j63%-jy$gg^)nn*vN`L0j@>VVstDbJQ$ z(mi5-IB~y7W}hq|-u$lgj!T3NV3kWUlrd0`zW3#<+vA~EGqv!+VAqO-<&)1IseP>{ECDZ z?5Vg#-0OWp#YcdL(#11;)vsfP#Fug3Is$L?TlW3LT}HpTuk3A)2w%Nce;%N}RZ;ev z;EluLIW?rSJ0_f(E*w)uc!B%UuUFDPwvzqKOW~UyvY&-t0FR*0TUEN{%h|ee?%wl{TcuyYvOZM{cr>vWn!`0pt?4|i#Jq`S1ueedqrQ0)F{E4;rGyFN1 z#cOw!{~7v_3$jlDKfjgV|D&c?g{t<@i)dF zNk5vEQe189_fLtx8LGUwU~+fa6VOeC*F@jKQGU})inGFA&QJ3dR7w7C-GmP>N>|fC z{&}pk)q(Oi`zZ`NE-b+Ji?@8YuN)xz3*J9#qpJzl0OwUzJ5%7d^C)gwBiZe!tCNN7 z(de5pervnPZo+)rWFPyn|Gm(48zJ3E>I2zP;AG4gvj%Rbg!Jchd6u^W=*fALg)CwQ=(?7>m8e`qQGiTrc1 z$Lx`RAMsttKc%efZ>TqGw|H^>{ZC4S@^#%TJT^f7HRZ)u%@bb-W;WM2Y=BR6mH#kt zPp}UqzRzR%r$1D_W{k%)_^4?4-O+bro|gN_KEYUVe`xohx7zmzm%Rn^vV{I*^p-t_ zbr3+l?c_gBTs-+}5r4I{;wlgqhd+S4e)&~TB#=^S;>Xs2t`k}ZK;*vpo+8IVWv$zj7hDW2D2_BuUe32o_H{3-0Mqlw9+I9aR z-iZFrWq&kBcb$ED1$;oi3)1c<@}9$gfbXSc%PDWii)!~mAK_^7uQSMhp11%D@!|V~ z^_iyuHN~Cp3-j+5eqi1{(*6ru<=!us|%;?v&8q&?! zA}n=X?e^llI>q^So99{49n#%_XYd?8iS7j0cewKO0egd^c`i9vE6+#X=MD}OcjP{8 zY9s!ceN>)#igr=n_G5*ej!2i6_kics#7{@d-@T}?Rs-1|lBYZGpDpXlzK!>VXb*80 z)}h}g@kw`;XE@&(&h-;-%D4@=AzfRzMWFnhZ^|Ca^Xl<`;>EDvuA==m-BI@8oOh!Z zD!x;U@Cn~J4^)<}2lJCWTK=B!p^RTY&S_8f&+Dp+%i(>dI_(74lD*6r<*_HO32_mp z<##rfzoWl!D$nI-8RBW)(mhxse9w7YXo>u8V`QJbM?8h^m19T9ewRE>A>w=MN>_pB zh9}>1 zLe9uPgt!9j#jUBUIOo7gJLR8OR{qnp-+8%sI{m&vJy-V2UV-P&8T42U&5Sq!kHbV_cRff=A0?a`Ja#Xm+)cIckUo;!9HtLOY%VaXS`P(9`vW>cJSI^ z(z}6c{p7#G{Wk+#k9{N0r9`mLF2$SeRop^&P57q|@*m`Wx{7u_kgq?w(O?Po#YN)k z{;QAiOky3};2w5~e$MCI`rcD@v`$mIC%7-YqNJG8!g#k+8hyn?S}zaKrKxJ_538+Ts# zG)VR*;4i*IgyUZhZsWaluf6nDu|GONJopg1(+K5%0pG>*|0wYeCl%Kid`x_K-iON* zR~FpVL;8a`${W{De8XAsRB#^tH_vAiM z3A-ot@8Dk9HCyeKqTRx$)NZp;!k|m?+dLJzl#)H}iFg^l=S+rA0w;n;yGwszsPqxs zOIO0DFn`0~BTGx~$$e-r`Aw*!$P49(eJs33f9hNiU&{Tr8S}RQ{+|8@(taY({Ws4P z*No@C7uXbR0(yXTx~aaQ(*9|AOm!rV5#D+& z?23IaJb`=VrgXKF42I!92~R~g341nqCcZPZS@| z^Euf`ygBDbUh<4(-&WyXP`;#eR+EJ0?Cod|B zasDhvSM|8^@8?{ILbn2cMcy0A9+fVgb+Lka1~|zcL_fSws-5=mQ;f?b;=4FXUkCqh z-hVcBmVFcXPrg*1(u~st)~^raR2=^^>TZg?9`)qfYyGa_`Fi4$@wx7;->VSd4Kg?A-mz0?B;WXg}{Q~(Rk^; z#>pRBL3}dYWv=XZmkG1Li<_iNU&V#zl;*|HIyYx5s&TwUwbT7fE=F$a3$$q7t zc&NGJs`Gw*1bYH@Gv0Gd829q<7yM2*si^XFAg&euw|ocK#`xdj_w>Ekzcy2x6YJnN zzb`eypRrPP2GZZ(=x@`%842zMyk0W0ub{od+IsTi(xw4L$FrNPOCxdaX z?WKC>tQSVJPXAk^IuiLkIVi8j^D2KQ@@l^P*TF9MZNcOGeau7j{)3gjd!n%TV#UwD zAsmMN>^k}PfhpwMS6KF~5eRvkw61xY#!<#HryT54vFa6IX?{j!P z^o?o%F82EL=T>92zZiQKJQ_ZO{kD_-Y@y$M_?>+4TE$;Z5>{s)Uu!D>0Sm-31Cq}}yRl(!)Ml8pab#^X7d0M2GymNHI{sN)HEq_^_bZYcC) zeK+VMewOoSB=1pUzp6iWDZ-X*r5hY0ELm1KhJOz{gzxZnU!-5USvba3x?bQVEAi7A z^6y2rI6}P27NHNA2rhF|+}8huYvAVI;*I#bwW&MBnWznE74y zCAWpw;r{r2+enwi^Ys_`hyNQd^o6Z8e?zdJov*k6#_7s5uz!{-gEbcot71Z7u^5ra6T=F{QIsRL?cA4y@)`-W=5;k5doB;M+ zDqX{^!bV_Y&=a&JKAQd;=yw$USL7>29e(&H!}pW0AYOgH)xj$2N^+^;C0=v!- zziFv{2cR#yNbwe6yB*?#z!hMkt?cW`w+Xz!{w_LQ`J2~~F0hZVIqP9P`?Cw}CQ!$g zjfz_X=CW^JfDz1R0p_zibzJ?axcd4ot6g9A)g7J>Qy7;ojF+LebRDp-q@F>v z*93dN?b0pboO?iB@w_iLnl1me0;;E858g^Uy6IcYZAAjlKh9! zM>i4Qnk#+F2f{92g}=<@_b4UYY$AJug2H0xvRZ21t=y#R?kj!{eV6;vZzSKo&eGM( zlKrXVhFJ34^^^Z(dEt+~!sg^@^+<7E@HX(;8M1r(OW%z;7Sr$W*YfXS{N^wY8yuu} zE+(96DqT)*@rIR!afM`eZYOSueo;yB&kcpo7#C~mD{?_`CbYYR{x~zQlgU5CQSr-| zx9d&Cf79;Df8#H+VUD-{qj4i)TrFWJ{R$c+J`LTy_Tq!;3WuW)Mi+u^JoYbVRrlR4 z(jO@!3}?Med?CL#{Vzd3rZS&J^GM(Ei*)N*M~RJP-&tGO-bh%olkhP8K6P7hM&+;@ zgcDnnGMx^^&jc9TN~Y3=5aFn_7&?moqgJheU|B>_y*0@ z&zi))XI$=5#}@J>IZOYOc{as^XtERo)_;o1^o}Zf-5K1i#l8_uyP< z*g|o9Mlg7lmOuTm@;4YF&UM(3(MCNxy{nS03U%%nPq?hB?^dXg7;-S^HCkCeZK7H^eiq3a^pBEBy*Z zA5Q!&@;+x=`erJw9l8tsRnJYnzgxeTe=6&CDd)^MxEt$bcN@hOVjVVSA7tlKya&$% zJM{LSWIxO}<)900sXSddf4+4SzjImoj@%QDc96XY&&|5md0alVIEW_<70SKi*Eq;JlC zKiyLKYLAgUzK!@LQNy50`VW5(*TJe(X>ol<962-5=zvnufd04>w zHOiEI9P6z=<2ewtM7Nmu_F#YPb&0>ibK=+#)#HsnjCz`5?*gAmTxaUD#~xit@#Sgf zSb}(`k;04cQI}Qs{^i0Tcm(rliGDHX>|O5Do8j|EC||8r!pEEg$aU|`{=3ELP-x2CDj#plri^74_F&KQxxn(Y?*8vCPAF)*WwriAU4eM$EJRknItnZSnldk05guOWXqYL&7)_pPN zuM%}1r~SLb)!yy`!aMMDU>f5v{;KMm1rEl(eVOb*ow`kSBtxn z=Q}zN>T@G+WyaABduQ|!`0dSc3*H4x>ex7UeYau?|&$L z0QRxiPxh294PG9cg?%P?F-Gwhz?U_|_dOCG2Hnt4rmk#s&%vTeYOf>Dp**y=mVW!( zl>Z)ew%;f|lK0JldwUq$EmTYIT}!~Z_;acA2t14aJ%d-{x$Q^$X0+3ddN1)Dx;;)ETy&~ua#@NW;p_{NZ_?J8> zrDZpCRs4J6PIHg5=6AvZ*js&4g4YHs{wjEa zd&(;Ks2kGvLtldNb?5of3f-v=(m6A(JKV%g|K0lsshz>tYmsLOzx&q5UJrCdUyuIQ zhBtzHf`#bcBie7z{vW`27PzB27IhYG$`bb9pn5{VbJ#C|#{J~)c}w`buka+;ZK3k4 zg|7j>yU4x@9s>6O_i}FTrTlc|3_r;Jcj{ zygAqw^Z|F$UPpL7#w8Hm4IBXu1BZe`z`@`Ea1_`d96>ulU?1!~!MWJG!~21svCn5- z2QeSlBh>#e{@(iFMvdP-(BDV=z<%K}^hx+1VIPP6-Xi78#h$O3;_~2+B<^*%bWcIw zeBve#g?T{-^Z|=yPxVqhZ|Z7=J@Q{3^z-0l@DI;Xd~Yy~JWZM3TM_bq028QZJnORp z>n}jwJcvCLZn;nT;^3M@acgw<8LxlE|L|ZUJK+%YPnz4m`UuARiCEn~`KE}g@an5F(^1>g( zKM{8yZeX9>gL^SQci=a`Oz=8*4ZI7k%~3rz)bSO21IEpXb}N9Dz`9^-a1rwsO`f6o z$xEI=*a!aWFZG5q|L>TuGW9in(+>)-Z4g!sR=x|X#GjoOhBgxJUM|1Az0d^xA9Rk` z`=h@%PP#wD{ROMvmwoXW<=qTA)zCU!@kaixe2+Ir|B!pvgR$}-$KRDY{NrS=b5?nq z6%~I+{)+f((!Va$*B<*d;&zj7*lWdiJE?pF!4=DG@C%-d!e9%>Z7YChaKWByNy-VCm*69%J z*3^HS@i9H8daAQd^TCI-lieOZl6=2ehYzZ2AADRX-AS+p`abchBLRDU@?R#d67%q$ zc^NWB`e(#vg7+FI{|@|bs4I>9hu{m*ufu)?{dn3B!+!+*64v9qWoow=>&O0x+A9T) zdLaLz^|Cu)uK+FylYbNc?jtYrmIPn!tGJi3($z!n0#*k%{%aThVx8hF(uGd!hceV- zz;51D{vE`X=6+g?dcRLnyQj(Th24@mt%yr{AzcdkSNxsT%EQWkjQeCh?$6^&NPlpO zu=*kChQMD@S6O&z&;o4DdH!ay;;$259s7NFD*i3xt86QMGW}RWeS6>$@YC@7@OtF= z#`EYJ{{Hy8gPUn*Ci?T}rZ6r(jJr)q)$!w~`u#Xm{3z?HViVaju-88(K76gPJ$&&? z#Xa_v-T1h0D)@E!i| z6O?CUf8i+fL%}WRw>MP2U0|=W;v0y&FkbOb(I0^y1QS6Q@^&FU? zwv>Gp_@R+_{(NfxCfvk9aS7OC8K+h7+UUxF#lalvFoj=lsQfJs2z|f};A*fd<6IDZ zr3%t}!=ErO6{%x9_6gv^eyTUQlyGH!;c~D8x?2U+&pP(Ijr{foEO%$ki8yQ zELi%c@YMsvTfzTQ@1Zh^vnnXR9e-!L6a4|u6MrC>Mf>;c6!*kJb@V(UY-pvtwspik z;8khAcnQVj#qL5}E$};alo==81?n(^UtygTBA;tLwbPq*{@p`7m+^bbIz7(%9eqgt z6Yya8cl1>Xss8!cSAu@z&t-gHlXoHdXW&cb<&L@X+y>hbXGMP;S=S@rlg-p$OZZ0g zZn`tX%tApJ3Ito{|}-yiMf-y^(jt9m|y*-fRZY$Yt}BY!aV7T{(6Aj_z< z>gyCH> z{Cmc)n8FRmuoq%{%&99sm=`nwjX+D#0OqHiZ~R@6CGA%$uZAwtPGwWo`3GGH`)v{9 zOmb!~g!zlYie;#az5z3AJAp-f)EU4Zy_e(rpBr zofRKK-0KtK=|vSc9^C>{I<4=vjfN0RQo|-tcCn>;3NKbS*?p}+%kzfIY_!<7K*rZy0#;wJ6=P&v-l6<&n3>6|J_d?a604soqkkCUjVcQ(@^<4R#LuH^by!Q zqw@#bfgv`Eo8zeVb`ifD+yh<&uT$@3_($*u_<(k8(B&iVDbRv?F0+oa(e)mtIzp?d z{!^@{)vQxr#x0U@I*-3U`rh~-_^Kb_@br_)*T-J=DC~7u-}{y<0{3tI=Aw5kEPDg+LLvDJm@6&<`)c%OoTNYMEZteK&{6RUw4Vs?Qd{=e zbHXLy^dRMrq%ITwJ?3ZHiy`g+?Y{n32lhkc35TcA-X;2H?WXqLgEzon&f~N2j{NUi zgkkRl?+i}e5M_nvY-#>3;lRMzz@E`smSjl};RJ_G&@?r)*`gQ&YP?R}u$ zr{t~7cnl-{3G?8}zki<2xK9J!u$vP1hW-t5(KrkQQ%9@)S&Z{H*6&X+h;{pueN&wF z?ZEP2EOomxu1A=Uqu@r`zX_j;t|jri@t38Zy4b6tOU2(9|9$#Dhx27U_by{2_2RnLzoXJ;_ z@$OF@b*OVLdCD>#F8+!;&$#7)v)jtPhJ2mMtFAv+WiR?wyoa%{Ed2E}aYt+Edg2cv z-w1S%(dB_ZD5tm(_;%KhwX^!W&0G0agK^+oa6I^$_Ktp2zI5t;i+wHiPoSNy^y}6R zx(vJ{u3jR^_!;$*D7!PyS!TmPMvypX~%ldQfraC<42z1;=fi>{1-4`w&GH|NVgj-vRT~kmoN)` zcl7bsWp76QaCGS}m9K)0{7L8s(|$YbJ?UTYbLr2Nmi`?4Jopu~&X(?cpmYz+gynt; z@8W-3TKqY@BmR5IvcI8@w{YJ~+3SIa(QnLAdy^RNgT$?%?)P2gKZQOVdvWIFFZ1vl zGdUd-N9Z(u{NM%Cb+-BYQUMws}YKH1xIL1>Z{ly@UK-@E_>L&ys%y z`Y`;ZsONbl`CoWweMJ3Ho>%a9U|e^`6AsF3Scu*id%3^zuP-B9gnxyV@?Im4 zcS~_+^vj*3x1-)$z~qvwh*6#Jp|qPwh0K9SiEK0RNA6|I!a5+HFn!Q|a$J@>C=)o^hSdd>o=Z z2gY+EdF>h3MC>`_z1Um*nO#=(jou}6Am2&Gy$bbCpbl%+K}DX=XTB>>GV{ade8ZHy zvR@%j8oEH@oLDc*uGxq*d$xHl8#_=KTB%yc0f0Oxhouat(S{l!%qJ||V;{D&rFoN?TANT)d z?Dvmvq&rq5^i^@Y>WbHXD{g2iw1NMsCI8~Mf_s&zgr_4k8Gx74^2FC9h@6j#E_ekM}->ly<^rK#J#hbA2_7s-z zd}Y~(vCm>hi#K)9MoQ;CG09r`Ys8(rAYLNB^bt?Q?{pWx#P_derm{zIUnyTi{5yG* z`8_76y4w4Jy>KPv={sB4zO-;X6FLL?y2^@c`(FO{_QJB4)XpS+2iiuwJMBcbmcO2j za4Y_I-0y01Qyx#gU*4mhz0G7_yn~GPjD*sFN(|hg}g&N47mwj*BQ~EBPD_JZc z$J)wwi}~{>uW6L@E7`Y&(e)tDNX~;LeBU1dpF`f^@NMXSeN(<6*hf*PHFcJvzZI^i z?*D2CThRYt{Ki4bQ=0F+lP^oxAN_RJ$2{zj@E!G~OTzw|{b4dv`SO4_80Q4W;|BM~ zAl^@Y?ogh4)iiFr-Wv`xZj(X(>dIScr}Q1+Yq=Np{34RV%o^|{_Sg(ZqYwF1UEknGVvv{w`!iD^OMr1+xCxVUf{~+!sXx3Od zFUGkRx=h~B`!PQ*)SHj~e`Q>*5g#`}?H4$yeEGrpFJ%uMEIc+59rp>dqtdsnFMD?| zFYD?k^K1eiRzUi9H|A#UMy`F$Hn zKf*^idXlgg^VEm&HpAb=O>qam2>aX=Mzb#4z&-P;-CrM+FCXK4f$z@7wd617s`wNa z={AFgG}&#Z%U%IKC!g$vYs((U?<^znM{&<^Y$g9R?7f>S?keqG0f$VJE`s039mk2= zlhbwFYu1%Ln)*`mDt}JyK=&w3=g4eCJ9tIweKM}O|mHp&t*|V^Z3s?LYa2fGA zj9jXom>Vs$x+8y*o8~d;zm%{@`AE21Lsly z0^%+%mcKmtoWOk#7)~)kFEbHVNk>DqjZtBi~=oZXvzNMXb7wR}e z{uRteHsg38PC94eT*(_}sk~|Q_dDZ#jqihI2jov!qWH2Cge&2L;>8O*kggcxUwp54 z@uk?oZtJLn^KveATyLg%8Ax0K&e1=d|Mhw)t{dwokFD|^@|8WlkFYg)%U+hh4ZIlN zeXFjK{Sxz7l<_v5toS92M=W@0uIy&v!o@`ue`2?A8S}O6{{j7w^mN!#D*J zR}ORm&(MFIwfWPu(Gavoo-SbEvmn;8r@H^ilRyEhS*5{n;SW)^?$K4ejKQW`9IB5wFuzdIRUwrO&djau-HWS4EyTk88O5IfBR1o2DVzl!#Xki;koE_{ z)5vH1O8Kt$7B(>v&c<&KU)fpthg}!GC%;96^h=3&duuC2k?(KbE-p@T)DP zkN&NGE+qdH+PzOd7U6$5$YUdsOyUMt|g>RsrxwPj={6fal z9Ug)1DY`r05ZW(>&KfkQ-$U`2qnw@0kRPu+jPhL>p66XJN9`(cMU%nsWRl$Hv!$GW^|3Eto!-O0hV@mDJkPN=LSLes+G|BU6Uo;Be`nBos&vL+YxG0# z_hcPTfS;t@;_y`R7K88nu6%bHmtF7(>R%is|CnCFv-pkLXgn^$e~>qkx$F!%%F+t5xy^opAI^zE)O#JB z2mU7DE#_w<@$+ftDdV>gJ{JEX_%*mys>anG?993P$)Nkv1uyx}g3*0c=a(+Be*@F; zFX0@!$^4gKJPzRB2WEkLzyhYqn*^`L?~5*A-T<{%YqE5O&=)2Dv(mD6LGS-U{O}&d z?I!Ofbf(1r%`06=`r8A2STn`Vr9WNhcYEx^(cdLLp1NjXuYoQOdtTa$|2M9T&o$7_ zNp(07H=R1RpwEZ>4dWe7|BSIufoGta{0a7Z;1c>h zllZ0Zc=~e)T?^h<60ygj_a<*6#@z#4OE3oG>o}N6H z{vS=}9hURkhVil!2_==0m5PuRl~iO$5wiE*8HGsMdy^F{J9~>{?-5EFnNeo^$o3w` zdwzQVIe+K1uj{_Q_xFCD%KHhv6n$;#YlZ#<{wvrw$;_uY`p(#A5T|n9I^);8hvs$} ze>3J?9=loC1%O4-M-cZ7`A#yg6QCFQe={dfcoF8j4*#>P^99bc%hZ_!PNKed=x-c-}?$5{}rC#p5u<)QTRcy4d;X#@3}kP+E+`_TX5efLS13#Tk#xK{HHwqi1UN| zf55ucTFA`DTH$v6}-{z`hc=5c##~s(U5twFP-LajbbC^`mb`<`>BP&hz}A1NYHS zJh&S?h&~2Bg!K>Pe!7sl*1(^Tr#|!Dj9)Y6*@b<3jCC5uKI_7Bb{zRo1u@?aV0*AJeH~+t1@Uiy{swY;csl$i z&-GX89!_0G^!){SAax(0p2x^fz|F9qgk1vIrmFVCBJLG+`-q1oYd_a=5Wm_}*wt6^ z;OgS#{Kcz*;|wHshmYs;|Ge3fALRQ^N8(OJzYeU6d_8;v=uf=u@H2exYDGQMsrNMc zB=no9#{;`z*bT()XD8L~gk3y+RYc#HI3vO8$ZLWtiTAIU`rAkzgWlpP^gRIkZhw`} z6}}Mvb{}LvkUG9oR~Yro0HgNEe>{2i6aNi!?M~d@#Jh&yIqDxmJ~!%nVXM5J$eR$a zK?mh=gS&z*U;_K$I5?5~jrPiK%@@Ue2%6yML7o!K;Sl-XwU^%@{6~Nl_&t`GamVfO)i-cj?tLtIPd*6E|-S;NbLr-<7Qy&?NMo;jQI{pkun#jQbJ zC;AvaM{&c^KLB6xbEWFk^%T2~)aM8OAa6K)E%Br9PsOjoUFBbkU1RV`vgG%$i$v~2 zUSF^j{$t+<~))0vZEd+JI&pkefkdj&e-QL$D5ot&p8iXR+nFS{2sv*Ik&E1cN+c^y#w*) zGbbPNoS?rruqk!KV)vXn{gL;k|7!H(ML)Li&Dck>@8j^>438#HOX5T!Z_E6w*uT?= zQ-`^`qIZBhVs{Gv0<3RAFtNS%Re#R2!QlMPlDBFne8YRX0sLjS<~uf5=*oHX82JP6 z7C03$bjd^r0d z{hR72%lse0AA`@pI`d?=fqs^QJ!VS&ZJ+AxR!!U)EKJ<#*tgj)yR17x!+UV%HawsF zBl!NW5%s!(jfv|GFN}W#^GTy#6XfN<_2j$Dz3U#IA66hAP5w*BUr^^)uo&N?jmN$Q zydF4~dQA_gpC-uNK`*cj`jO-r3>IQN!m)d~OL1H|x7xApmGB?MdYq?k!!EM_LA?E} z`*P~v4X;n09q>4C2Yp56$@BW$t+-{`uM?@`J?oSKz6D28S1kUGziT~nn7a@0dn12E z{RY%u5B&w|4r5)4Q+FEsEQWO+z`joOSDi_qGtYSu&a2ArRYybQ4M0cG0W4-KJJYYi zTZY0W=*u843tE8@vt;)!Z{L$Q5P5Cvnu57Ls@EG{h`xg07T{EHA9W06UfIMQ#rc&5 ze*lg_J_+oC{~_kM4Y@IO*5^5`1J-8_6Peoy?ALJbiUPy1>&<+QGXL@Ho88zIWnW|x zX9#{L&>uzqhUaJ)eGUhGnO6s}BJ1A{UJHJg=cP70mbp5?tFm93gJX$r$NtUY9@rjx zOXkrA`|-#(Qs+71cS2u;dJMr4?1zEiN6tZK^wr7Ro_{yXkoY60s~YiFun$Hd-$lF% ztWS9`p14P_cf-FJ`(iZyZ&{~u_$6Q;L)^8@;UnjJA^IDGe=PfG3h~R*M;de4h5vQd z;~sIgaK2sj(*CdcLTF~A=jVvIzL!n_6G6wZ(%aOP{VfY|BX~aW2lh3w4>~LRmRE%> zz?V+qRk2HfSK{~k-LadFe{J|q@@@q?4N)BlV}w773;PhKFX)e5J`?E=Q)eIY4*;uR z*Pl54{9f-8@=u1>uBZA}z}t^g+~Y}-KSchFxs)s`eF?A-_yfCQ#GeC}Cf+OJWrESv z^_+SGi9d;cg1}Vt^Wf9qCiK^dJihqXCf_>d_?fv+V$KP5)YqJI!q=nKPbBg7qEAD< zfI08u@30Pm%dvX^zlHr&_`LSaGa z1?!>DgbyQ5e&i0+8-jl>@#`S}LSOH|aO@Uux$dRMy!!n5%2h~1b5(vJWeS}Oli;Aig8| z%s~0KB43rfxae)*Bf-|#4Wyo0gXO<~f5&t&xCD#<*MaN7n1D3tcA{^{b7qZQKIXfT zxrFok>4P}`3Nr6`$d`dD!M@n}gGoG(kJ*P?h*Xi#n@y3#81#)BNw2S?Er@rzTGB*Qo2K#UR z8R-{+8?b*tf7h_PL%cM2QS2sweaSxxo`C;z>O2YmN}M=&P3m99+|seX2G%BC2kaK( zH;R01*dJ%h=sEdXTm8iH`)GYHi*FereIoJ=@S!!NcPuIWMC3lh#GR18z;6)x{$Mw- zI`&?~^G9yN-}f3LA49y3=#Q3G9#8B#Aol^EI;cJmct`9GUX=U-_?$SQ#9u|e)!<_O zUh}D`@(nQ)u0tMDQ}L4E=fN?^`(yv;g6x_hHy^1u-O-mrew2E@lfOOsckowWA?mHb z{O%xcf&F=SHt~vKUk&@q$Zg@x@#_jYP~UOp_<6YM{Z&fn4X?}JAG?9i?A2!mIOLLe zb^IK_^gKJbDe>+gKZu_Z>r)W@3G~a+=TiScy>7JWQ?3iWk|&wz)4pNR7jd% z$@dGiM_&~jfd2{XOCm1@mSQgEV1DLylX|Li9uxJcKjr}wD$NrMv#x9aLulW1t;qY1D3F783r}8&d=YPa`i#!|rFYoUt z@T)<8HNo0o9WWWcz2Hgw&QniM=J^r(uFNxt`8I&>=I_|&@pmac=+7V@(?oS&Dx&_M zf&aI+mImkbOvsl+K;)Q~5(Ko|?I`VGtH{^Z7+|II3ez9-<9@RWwcnY6_o%#Qt7zXC! z@0}*WuV6O~ehB`4s^R|w*0FFx}w1%4s^AFva4N$iV!oO=tH z;{@uP4(8*$n!r4VVLz1lt;cQ>^18&W2ZkW;g#Sg(+k;>z^3~X_M{e(-IoN^KK}+o8 zi2t1YR_LeVUl6+k*cC)yg}T?#S6eWQ{>KyV4*%{%ZLkUG4aO6HIQ+{StydvWga7~U z81W*=_l^8(;B)bt2ks_bGCT+Se$=xVc{*`lqkjcHM?Q!6f%xsm?*JH1o*Cc;RQP@BXo0;S`i|gO?4Dsa5Z)K; z1O8#17E<3L@IU+#!H3kjkGW)E=fHexTdD5T{Ci6m!MorcW9e_Oe+;?j<^wH=)6Q9Q z^iLGlfR`fvI(QYZKlMN3zWk5xi!;e*ieCvZ6@3bLAG`-9gLlB&;4QEL_3mX3^{IO= z`4+H`)`PFmKV@FG;Rn#0u#b}9+1UL9?;=0Rx|SeMW3VZGMG@DSd9R00V?O7Z`)=%? z5N{fB(wJuk@=3&*N1T_)S0G=C-+AH{<6d-*{rHXjb*~)jeqHN%zG%Mx|HlRJt*hi$ z;mP2A@CtrG0~Mzr|G#JF@H(=` zC~yoI=AyZr;M|!A9}A|i&%EeoEq?33f!K8iGkDHQF^?iV5B_=2CGmR0?-6GQez(y7 zMP81$CBb~)P3->A?{DxT@=nBW&3>_h=c12b->d`QPSXCl&b)5Id(lT6`*${TsK~r# zWA_ce6yn{%{s}yqx(%tv5&vZDJm3Mun+5-a|110(QqMzpI+zAt24~}6l)hc?>#;z6 zmZ>G2uv6=QcdGCvcmuo+mX48qx7D)C=Ou0kUT81=H(EFtyI-E-)*15q0goo`7H~1R z5Og~uKTG_kArAqkfUU7J$L<{YH<15smhxti*PK4G@J~)uo-)WEu9AHxl1&2;i-(A)SW22;Rhuk+?@}}^g)Y|}V1Fpkw1aShv zI+(D22a%s; zPUG2kcj0MZXXfU>9NWRY!Scw9GABdi8;KX0x9`#KCT}eA64Y}X{)+w|fESQo0dFGj z&RpIgZ$jVhpcj}xzGm>P*bnj2Tql65m{0IZtwX$z^c&xZPe>4-j6Ne)d@uYtc9zW~ zzkohpsQg#s|8=_ff8b8+KjQx%_!;|b=JOT#Kjg2G|3kiqc-ho_2fYE$%_{VU@cO4z zXAb`Ps3VAe{+yKl%?j1q3hsiv(G1CpfS<9O8z;ZN@b~op8XQf1KgefBzCQRBpuZ{P zyNTUU@}45jFnAPpn~*O9$CBp>dMENsK<)we1~(wTioerY_2JH(-lIR6p}xzXmVO}T zm<_x(*br<2j=(Mke=pXd#WclBjZwVoU?}^tH2WwCc}?s+Ifpuex5(2E{u^$|xfp@} zX!6If-=n~A^y}eWuuDMxj5!$-*PDI@v#0S%a9;lc4SluV>F5i>%`ZznC{p-jg5nfHe;wWnyNlSJByYiWvUhZs|5N0~ z$cuwDp2*G_{{h6cL0=R6LY_MCKX7~e^CP#%e-`<|!Df?`XE%L&z^l-=JNzj6+W6H$ zUJtv*;PH#Svt22-xc{>modF>oK~+(hzS@S*I3miS*{{$6mStFoVhU2CxS zdgZN5yb{=(K8{Y7UyHM{TTZ`Y(8r)31>XQ)vqpYHkgvjT6F8E1qrq3?oyQ!)kjH_Wh_@ep z7kmg_!QTM?SnRWhscui?oxmEbYd`o&=I2ZOE=}dPjyatJr(KZz_GY1DkosJLd@bv{ z2HcN)CHx5M@jP!mh;tpg8{ixCC%_f>U+0|l#m@(fL|!;T^|)|OHwRmR1DmSuPViLf z3Bf-LJ_h}J>iJBc>+pAn=P;Ld$o<(zN6{Yw2dq_HhQzCjofBw$gk4JF8cd3S9Nx!zMt?l*!9G(;V#v8WS_9YeEF3Jk0K8vP6FHveI@+! z!wtb)`uzqzTdcU*)b|Yef5iI+=7Oit7a+bV^_B$x5+@h5MsD9qeSARv9{kN5Gl*M- zI#b%nzVZR#pjWE%H}k!)LvpKwLTj)bSOKgEnzfbPw>gUQ1uRDXHN?A!{1f~F`~(o4+zxaAok1J+#dzk` z9Jx2x0{lw6+1QO`UH-Dqhhz5zj9|Y`2Y2J=j-MOY7<2}mz(D5xgm@0fy@=-tx-y>^ z*credGyiz@V|VsdyVhEV1uwKN2jj(SBVPlLLtg=T81mc5?}Djd`X0r32;Nzs_Q|1pJNO0{uVgSaMbMWpj?W?-1`AuIJ$OG4UeDg)Xlp-_cIICU$3@O8&RGXeAM&2yhOLqZl6M61o#dOIX9va;FAj_aPgBE$&gE`nO zgKwulJMu1At~#TUuZEYJDfvctQ|6VEDR}@ql{t-o@5KHXcn+Mw9A3c<$sdFN7BCWw z0GES1iNBRP`w*`aXh}Q|crtmmVV{V99P#SW-*M)7H<{7S-G=EWoLKjst$p8i)|7I$+n5IgZA@9{cYxbLokHE#y@| zNBr(kcSYoG)bSm8SK|634*+9`I|x1)e1_j!`W=J(Df}+_Amsnx9^Bsy**9tI`(xV; z|38q#Xa5I-(QU;`FB5M(TR0Z^EbJ$Pb+8)@?*(6qy%X})@b}z5hhi6x+!(tlhn4>* z@~zmNf`?G&n{BcyMtuh0Q{=7aFA@J9@MZXCV3$DN>tGYk)e?sk-;TM>Z6RJ6UJ0}T zdsCkkyfXgPzy{zS>U;xUB5x=3+nG-i`ki15xEb6C4kYg}{H}ucz#qi5&D1&u(1#m* zHTtLUGtB=S=yz0ox99vhz&X=}`3*o{nz?R6KMHvid^5NSoP*w*=X4(O0mN+xCQ(-l z?5^N9hI&TeHwf$vb_Tb5tA2mDA81efRN{Xl?rt!N{;SiMC-U#aOJ-lCVwVP{gWs^b zG)r?oPQJIuXOg$r5!IK0yaGHLdo%j>Mn0W*tKrG`m1G`WsP_(XOYG<5#e0B-*#?)O;nqmg?*kUXV}J#76R#2acgQP| z&l1d{-W2lGz}^P@i2O5XLZ9E@UzqP5;#f1M4CWKVyv(+$&!-uxw@F{|%}d2=z#Tw4 zusT@wsqC!4>fa6i|Gz5mWyEnN&t39(!kgvE`^fKn9mTr@Z-YJoeiCetyg7Xy!S4|I z@#J?1P`s&dKkyvu(2hQgsrxJQ`2qd}_p;ySkgqN4dIB2~ zr0x{tuaUn2*W&++Jo)H*Epyxen$c$g`WT1b3F4aKmxO&$>`LPo!M=LH{(lUXjWPKD z|7xcT?Y;_YfPDsuzh9v_J7VvL+#_A`3;seM_>VOC8FrT3puTWBe!2C;M`J$;Od!uO zFckS|;>G60AE@{z;UC})$#(_$U9cPS6!NYk-a+a)1oog0hcwlf5KaH!N&5H#{|ed< zmR&BqH~!_2XZ$DqbFd`x4#W$=zQ#)B&8D8$;45$kcK6_S!BNz`7yWgI`itmd_HjQS@ArDKTsdnk=t^8^M# zi{xib9OLfd_tD?OJ{#-=z6EQ%P#kmoO+ZuP{&7^i20O?Hnq^A<;iu%TaDVU_eow(5 zYOKNY|)$bE_17RNot_c@H}V$&ik|^~L4KS#jfj7leOD2F z5W5rj&4!mE&p+%ZAs+|+0yD7dOaHCN7f9U`!8y!jCA@fd)msew#eCm0*Wd89*#9K{ z5701gKIET5otMxzV?NEnw%|qVkAnNaX!P;$&CDm5c&E{CK_7{J82XFgRo**mUTD2) zrl`+h&%_OQ|2$YCKBu?z$?#e5x3#6eiF`5sBhX(%-VJ^c?hlU!6S*&C5w8jIG~{LB zkKhHjsh;=L{SKVX{pw>c>0c19A@)z;Ce-m6zuxHIAwNLA4cuQ_5qAvvO;Z(r4CilW z^j*Li*mZ>u;e76fy)phR;qG7#`CZ}pmTJD$;WLTTne{mazYE?2>#`2%^x+LJOy2w0 zrGS6Q`;vZJu&-^NEB{9N@MW&IeyD$+#q1B}*c5#`u}!wV}D)8{xJGm_>E<5x6vnq_rRUlUu8drV?P%>$$HGhZU#6Vj3rMDcpATGcobNX zI!EC*61;%@O)!_bCgSIcUljN1iG#Hd4yOyJ_-TEbeiC0YS{SxTI0sw?`eD}*T#o!< zW5t<;|4i^M@(}nY@I!>`pMwv;0khx5n=Y{0MOm;r9~x$49FBD|{1i%HaPW z`f&VWk>}o2-rFwV4dFg`I{Xo6K>R)EUm$-CZbg3Mqv~iP}-8Y%nt zYb8I0{SV~d!KOK~JB$7*XnaS0Z?W^kt|@!r5cpuc-tb>0Nak|&jYx}SNzf={RZoz(RS`IAwq?=g4*JOd8H?>6zO zk?%Y6?aaE|p{`*3>QT=qcpKu>M_vtX$b4I1=M6Ro-9dl+tjO1fI_fZ=)9kMu?DL>& znokHg?}Pdrzd`b}apD2+53Z6QLVh2<2Y)~8wr`N%MdF=+7iO-PkpIB1GJcn_D-ACN z7PzjwCE=#smm7q9OSK$H^$x>{OK#dQPdH?Uh&Q&Uyt3B_mc0wD*JWF zAGwKtM1K)|HvV^sH!o2B_u+5AA@uv3zRJRTVPB3pl?SVUw%`!*yWn@0I9~9+*uABm z0Qx+FT`}z9*$+*blQr09tm-b!9R1;YIB#+}|CVzuzK5@ce_N;dSTe7A_}2jKz*gjs zCT>~meUN7&FO9t^IGp|Tg?;@QyG(c*_y9}=?}4j`zX5zq{U4c2dE{G&JDh#>biMj| z2)3h+?eK8ymVjB*yB_`;z76|s%r_kFK|Txed%`<{dx_KHqt+*ZcrD>RpdE4h;P)QC zPSjhIIaeZY7;(Cy?~MO4_VsDb*VsqO8@5Vwm;r`@)4^X2q|X^Dd$)(eQRqj4CMmM} ziTwraw|$ZQNpJ-?9KT`UdhC~XQk-yjKlC$+KOgLh{37u#gS*imCQei0xPva}o4{uh z=k$H$o!U^CihMHtKD;M+%rNz{8C(bs#BVJ2t>C?=!-e?6;j4(Bh};JI<;bVd&vfj^ zU^f<=4o<~xHg>kuGmALJ#65uhA@DG`0=ruHA8(*O9gqhMQNICvAKM9D5Pbo#DRL+7 zxsBlsKxgDlz`DpC!51r)_kOCd^aEiNun+lr!X2n{H1e^;4MZP;+}vMrmLi{z{BM29 zUm)Ltya@JpQluY5eO}~CL0*advkm!Q@=Mpyt`%T~@)}c0b!?1IK zdxP)NwJx3DC0K_S$SaU<3~?*M-RN^OewC0{2JOMq=u5)8-_blClgEyIcQ{9NELtml zwT{A;jf8GsDEdI~Dt_bOH%>YBe9mF{gCV?mLE6&_XfPL_*0AIs8`rX9ogxnt-4W%Iqbr)GvvAI zhTT=p#ggzS@)d$RV&6SVb!D*cm*JO0+=1wypif5cMPCn@hY9u*>2Cu2aT>UXeK#5V zEAWBXr_;{};szkUzDDzzls8A>&4iny&m!JJ;><%IOTK&fEkgd1c{~Q25T_wn9lVXc zJiHuOjDGjRbAvUVDc%F*qmjFiFF@u7mc+S8|5xdwfR7AfsAmp-J($D#8q#0HzA%07p^tYhr0XCS#~=Eh!n_udXEAt-bu4P9_)Cx%&zlGNV~y3n5p_kw$1~5SZu0+3 zzQ5G72LEl$!-2ks+ROez6~%2*Ot^}AhL#auW+U7wbAxTvHHdg+m_u?Q+1&+)S&5ra z&lc)iN1UPPU$vDWp12b$%kL07kw_E?>O=dqQ7YPD(1EszMXs#@EveJ;_ZSDW`9Rw*Pi+Kg5&Aq zA@e=Me(I0DFSvo{I05~1o~N4Zn-%C|neS!tt>GMLOg}E*MDjjkUuaqPY#??{}3_2t(X{+WG0 z%~F0f8%u9YzyFF#exJDyVjrZ!AA;qn&y0Cht*bcIz((YY^O5`p*oJz2!M4ozEpvDW z4kb=7c(bPBL|Lf5$;kg%xp z{ch|7U;KYj*Hq@;o4OCO&kj&ubNrg4&!qkmtjA%VKT}8LD@y#=%<+$%=9Ebtmx=!x z?o1vN=3OFheb^tS@C@QrVm`T?S0%}Nm34WC{2lYjrd|Wi>9_D-#M{q)YQVh9=Isai z{esNJ^r1TPl?)+Z*UfNtt1>&T=Ow#E&jTx@CW)~*3wTd zD148;K{eSu=Y7z{A0l5<;+jxz82Otae}-Qc@11n`LE;v`&j#F!d=PoIuzw~}-x>P) zja>%%?c_CQeJnsrunYFF*jXW8&OB<7uMKvg^ncS#^A3a0XC0!5vjyBioPPAtA3Q?6 zU+I4Y{+pRkAa)&zUy}VYjylF-e=e_2{C0wK@n1kcPV6J65~|y}j-HQ!+}93L$2IgL z*{2rVH%Gyn){>tka(nKRO>8BvhrTY@wX*U#!He-enn>Pnyl)c8TbVfh*blxu55KYN zz&}e@TcC+UL*CEiHG)^5zP`i>V1C6|xAMeuV;&D#?-uykpnpk!Bghx*pt%i!x57S_ zJU!{RCGsQepG@K#vhF3A=Q!5I6n+EyAm-&q-IIy$NZeWI?^EAY@*2`#70$O{2^e>Cw2 zBDcf;A#n#F_oMz`*2RbY*0GA_ltrIaKws|j{iypIp9faa?^N_7v2THV9Qh6scLNwo zUHR$LiTrWk9_(VMI~I&4ZbA_ilFYiS#?O!bH?hv^K`Zo+h`S5+>3SWg8g#r+?hvPr8Ve*{W|hBVIKrz zXT|=s;yK@geF*(F#jYxL=`~bG4t8@ncfzroO&wdwm%=>0V!w#>EJ?nC+%w|QmnM!g zeHAiPBe$5-ZT$D3cg6k#&yOMdXg2aQtosu7cRuPnf`238HKxCE%y}mMX6*Ab?6>*! z)r|QrfIneg<=Uv=ne2y>t7JH`uyE%|=?m5tHsbHmig`$1}>XkpW(gs^N!?}_L7&t zfAbN^A0LoB{{-+z?TctmsIysg6JKZI?mH*Sb{ch+eo`dyC{_hgpPpD&EE4vMGp`^uZR_cvcC`LHO( z^WgV+eLN)p!|#t|lJ76|8B>Q>nCuF2{@T#jJnq#G`MdOiyckTGrxE@qhs(by`zdIJ z_~t~_<6ly9y**j-kEW8Ji4eA&A#6q;K1Q-%Nxr{!(hrH3zeRoV>^Sjze4o50Kzx^% z{Quxr7W?M@@*B_oH@Gjpaf5JVb>YY9igUnMSSUjHw5jy(&k1MpdqIO5N6OJ09o zh}GB^rqg8iCs!EPUwHhZ;%zk)hOU%+1$=|Cck$`m4@+5#A9s;`D027X;>W0apv(+*)s(!Fwek%@K6j4f(@zM) zkhAOt4{Ave{!r*USvc>D>^t@suR$N~3&iuYpQgo#FJ#XC8|C+pd+S&B<9lP(^_=}W zmFMc`FZmbFFTcU;liAd<#XaQ z<4Bw_Rgj1TtS_?h~F4} zzSGk8$FC7`XRsdUe5$A7#tjm_d@MZ0KA*<#MUSHnPd+DF^Yi3E%sb_p@)aiUHsn+P zC|(=hiz}H^fz6VCVE=m5kbnG3;p@RdE6(>~eD2xDeAl>0?@xSNK6eLl&UZpyc%STs zaK6ts7cYvu6!-TS`dh>2%#+05H9&PXUnswIX2OKu!cwcH@4z{C3b`+Re)X5$^@ec& zW8qxhpYPb0iK8W-fL~SYR?^3P>RAfU)zn`-GSdr4mJn+Z`wrl zUgv!{=BxNn&WXC*BMQ@Ze)hxkEy^EE+{NkQ(VP!$xo1_S?nhSA$Iwp!=JJwy<3gm5 z{igh$WyCvA6FO0cJI{?L`(O+A+&i3?_1FjJipj4N&*S>*;=8X2_cOo5cH)ubImZ2O z9Q(_Mev&!=0{NT}z&X%@d_9@V1=cZ*dgim93z^RZ_K8)9@=oJ@et`XD!ul*?PTQzA zoppN8y?roo-j&e2vgRw^uV3QzSg$_VjWv+`J@YnuDEsrwv34Qx!|ay=*4@Q5E{xa$*{=#p<03TuY zM#bw2e*@34mVVPk>33ZaRy3D9p7pYQDEZy$lJ6cRZfvG?ORFn>g}CF0a~eCVP10{- zKSopEwMmNi8tzJ*^qrFbAx=B;yk|~z&P(qRBy`}|~Y!9C+3_n^}IByYV& zelwXEtSUk7C*h|F zvU8=b9Qe}H(vK$p+$-V*IH!EB$}cxi^5gVfX` zb;S%(98ca`LwS#mXAW1m-@Y3szqg<@&;J|vF#L-1xnwx}HG0Pc`7a4lJ`diXW3aQM zj)m8xf956otK>K49@`H8bmnvoy&3DdWs>~u`FTcuo}1D1YsU9gZmh!r_S37z^4rFH z;5X~{wT9$V_#E<&`%YEvm$u+x?#Y>~>w`_I-;R8x`8-=Z?|rdOac6-paY1vQc(+oQt2> z|09`W--6N?Sl<@x(-%BvQ@L04N54FWx}uaf;g7JyP+E;hmTe=uS4QGp+Q}}7 zd?U(8?n*xn{lvGG7tW#n!y^^v(PPP9(Rc5o;?oK$?(MDOv&sqQ;vdyY{7Z9T-O9qU zU4;$d&Y5l`b}|DJU>z9qd4evz)?fA$LvsPhl;cQf~F z{45JAUPt!DP5NHmSpI?Rt4SW>Tj<}I{I);kzn#AN-ILw*W|F@&(RxfdA?`_?{joE( zlKlegr}O)d&U+<)!~C+q`Rte53#HE~BHYnK@k1X7CpMA1Fwa}`Ve!q>|7?Ny-W9UH zQB&N5eh(p^&Up~ZInajZF|f1z>W0a02KxWFpQbrV9^Fsq)kpSKIS=C6i8n_+oV+8- zX;+I~4CA=k}6h@rholb9F_<-(Oxhy14Y&+!yRtikovjUEe0VGu?%wcz)yP zGlYB*?DGuzTTT5IKNQc6b#Nm7bk6q(=JSB}f`_;2^yK*|lOX?)Okt?4^yjR^D_E+o zIY;T|wd4(Wo~IX<{Z`JaodiZ-wCH25Wd0x5%sh~z9d9?4`apa+emTjnA0Wt zs>l1jEq)1A62w!d$K2Z4vjMHG-8~NKaFZVXGE5W+ni4u=4Dtuc(_SWpDw+AI}%yZxQ zuJjW#B@d@R3!c;G{Ux_tCM?X)F}nrG&wa75t-JIsrwh~ge3iLR{3-o(=6Q3Z-`5YM zcV^x9>{dMU*^+mtCVp+Z&=;N)D&Cv>$8R6mw`ZLeTS{Ms_iR!2QUj8q#rj!yfEid zIiB}6?9)u_E-aP(S@zWs-h-p_%l}1~^xj{@7j_r+1UrCbW=Z}M`_|l(OwiZ#k$x%n zolw629e-c)cC71wVaivou;gh1gQN6Ufjo1MOEHn>%$9XIg5B*D>3_5CX4c|8S&w*d ztDW-kF~z_+RD3)4^k*x?$1vxL8H&?qk?;YZ$5vL8U61~f7xfUgSRyRXxw(t=yvn|8 z7%hD%?mOFgUsQ%?a4)=w{W-84>oc;0@}u&cuR=oI~3;e1=nIaY=JpD|PU63N>nL%b6HCTZd( z+}FZ5FUoQs>rKB`EoA3kNp++#r|X5pS8<+o;XN~vd#G(G^|9it{C#;J*9{eK@l^h8 z_#FO#&#^E2N$$k&ziup|IP1Df{@Y6!&OYzX=f5m|uPUUD^iP>bSU&lO_)5Nw^KA#1 z|C!{af>oCpXb%2qB6;({La(ht574B({J(NeRWO!*C;Q+{y7U&@qrPz7>~fcU+I-nh ze<42kr+82H-QsM?&+e4`$9nN*Jbzg{53Bh(z)^m$ujyae&2(4)_T1AlxHqi%B7JRs zkD@&H-rapAA6Q0c&N(`j`R!-jvpMIy=c%r3+?$Sk7oUuM#1F+ONZ%v5ca>#-{(30= zLEgv4ZRBrcFS*Bj;US(ESI(OQ1tc$u{czq3pL@!GFyA+nxg`F&zwEO*3a@blnDEsOHgHH4@|F8s` z>Ix5B5q?@Mzxw0iPDE8KTuzIE>hU!k?IW!7f)kOff16o9xM4C_Fuo&_;U_#o*`aipX|q3 z3oqbTZ-n%B`JN<==in#$_042&HB0z*vFu-iL#W4joa9E-d9jsv7lFY`_U|R;GGmzH zSuU4B`@!O?{DdFvBo7D^fAdPb7Wcloyf^yt9_oKec8-%}_oK3~BH!~gPZW2lBfH;M zgu{3q+HMiQF;Cc`itH=lmwj5?^__4<8|~W{Ph{_wU-${TnytmpP){P*wx;|;d!VP! zu*%|7B8A-=2>a1rKjJx7lDx=M#VPkudh)TRubmFE;K$Pth-0{*5tiGU$;3Irfrsf!64a()5m?j?~3-7ydd`pTQ~86CxuTq zhpMbroF`8tUqXK?uZer~lfExI)2_4w49oc6M4HakiY@y8!+4ajO zo^nil*97rvE5%RH|7`=w13e|*!{^qKj^Zu3|D1gzyGUE%BtBrdPhP)LL z6=z>7p#kpSAm2!wQa-Yuu|Rrbeonu9kmNtPUt1Oz zugSVO^LgTM8SVeaJST_X3A`^moR**cLSb+EUbjj-nmKwO6(2EIb^LlMyvcKzz;pgH zMs_uGgd3;G&N5njv6(O&`335V@RQw2JLzrs9Nz4!Ta?^cG=02 zFXViz{X+8C;gSz$9p^T3e-?kA?ORB4M?UC}&0GJT zvb(rP`Y7H%gS&~JY$ScrW#ayQg*Tiecj5dnY9RTzp~zY1yL%;%=leRd$I^e~-sr>q zwDC{LKY6IXs?@h7R&wKYiZhn?(1qp5JtgmbT)2&WaD(?zfA(XY=F<0JeavsmKXtw2 z(Z_^Uf+T;%`IXD}w7>34-;mD(<=e`xow+cJ_wqE>*_wMmS4;W1u+L0NiXS^KGE`FxbwLwqxH@FmVN-oK4`4-Mu$ z5Xe2Sk*E4f<-Jj1fa>(ae_xb%6wl8x>Yc~ux{NgG?Rd{@ZlpRIzY`WJDgBo7!llFw zHdNj&%s-0y4^Nfddd`DeJa5@M6fZJH7{WRk<`*x^J}ej_|JT&{=8gD^D4}1tFrIsK zL!QfnnTlh{{x&))eu{n8p1eNABo8xH{jd2vw-3AH?WJ%3QhD0bZxNn9E8a`3>AOXL z+3#N{%&e!lGuWRt)fHzf-y3b@=M202BtO+exFT2RRaO4mCM#YzpJy6#Z!zI~&f$5k z=OVlO<%MVJ2&)?@UUTB?_$?k_C9J{wE~}F4yKrCGaz*;}rGz%$rN7KYw&*9xFYJ@N zXbbTrHH33HFCusz-VT?%I`5O;TjggTCma$d{hErxhL+4~SnGBmB(V9=plk z0K2FBUPITdq`0inWKE9Bpacs1usK53xj-M)(_ zzZ2GJC0sU5IGgj^y|8%fIr)8{&#j!Ji(gCMYPj@Ce9zkav*dkSNZ#2-+?Kz4+Uq4A z!*g({g7{;8AKa4PZ#nls{^vo5{jxLOC_Ky02UB@p)IeVr|DxJNp6&cY=;U%{JYXLnHOKVACuy~XR3|1-~7N$fm%Uahz{g%y;d{xoZF_{7nU&3VD{mn&GP%iTuZW_ zzho=^SLU3?e(!!x_IoBt|BHF9DJyvp`>kOM)zzOlHm1*&xw1RNTyFF8;Q&4dBy#@L zvT0h~go05CD2#0V!#)0nGH~%L4*8Z|P z%JVt;9&t)YKDvW=EA9t-*{83VWA%s9FX4N&cJzCHxBQPe3jI3E?lh+y0etUo#D2WNJ-QNe z8&g+tt@wP@h2M)Xdn9=w;x8&K-fX(!_HHa5&*$h+ey`;i=gt}G@F*m^Tt5Gt?kC=L zzT#AK6%ONks$5O3)!D~EOaie4L|mq_|7iErkoEgsIwyVWtu7O1Kzt`_Q?J=?}?B1 zr7yNjIDV+~^~vWID|vEj;TXO@u;3iM$lONp+)tV(|J3rT(}w-Dk8?D0ko3kE6)$wL z@Eo5DpSKlv=pnmkelI&=nRt;*=>r2mJ{PsFDt%fV;f(^yzptdQab?MkO32UAOuX|k zaf@tmcjkJpz4(q0VF~V)b9qk6_LRKNcln2Z5Z^yjd@ARJHRrAw=gC^`p?ia6SBCqx zCHuZS&s)GB#XG`tx8ttt50({f>nD9XK5x%p|9n~_eJuNUH_vHz?r)`eew`9z=iESO zY^!)V-19wnE+SS*-gS)d%U0R{WgSg9Z`QJok;P?qq^0Iw-bVJmmcj!W(vL_IzGL6r zX(js;qh!~jp0E@5604cAuf+2Z&v|`tr|jDDbEigpZpdOT1+t_c)<*I7eH0Jo`FzMa z+^#IS#bxEm;5iD26%Rfv{c4`8$61p5ZxGhvIWEcb`~Ix#y;$E#?86+sC#|qW`tl*d zS-cNs2P@v*N0OgBDSW^-14e0Y=O}Cy7X`9Zz$(o`BT!5SStORiQ)zL zT>f8->_l1C1d`~&OkHbU~h zvxO6RznE~&cVpe07fIinbNU$P#3%G?crLrJPPKU+hvX>Vpx(k$%D zBNWGWleh`zNfw_kd~K!gm?Hhe8$zQb$>07FCY~3LT_?RU`D5v4b!W+kajxfEEBjj0 zgr8U+bMDjqsk3T^^Z~cz-<5rn*h2D!MA+b--}(Lae7zH`Q^4x!Y3TEY6ES{EP6t%b2I~ zH>Umy+?!gjmHhldVSnz`)p);M=6OBMzB(DAyuJ8*`m>n!%N5=WNAF8tnf2)RN^$G* z{aU{!(y!ya_WZQ?Y8%+|6mSJKt52rpPz^2Z!}o=k>_>U0mZw|dS0jQdel9AkM#5To+5IP{1-J6?rAH%GwYPddmwC- z^z&_$e|E-GG7 zHR(HS7B(s%jNT`-S}i;Cs^aER;vt;ZU)VQI`F{OQ4e2}a-kx+t{Be~0Ta^_C@EmvH zo|4Ge6G07d9;fA{xHs+?Qx11O}~4)iMMR6ycv7Nm#q?BFd{jl6&5eJUCTo#l7a>Rq>vDUg=&;{43uRe_=iC_}rbu=jw~B zZy@)>4@I>P`mi59A6J}iE0li=&(oMf;%9jdJHHU0vqSdhjtI?LNWN#3xP5^5t3dI= zr^E|q3LUt=wQDOr?5}X|3)vT`CCq25I?E(T|L>*b@598?a)oAlB@dh_K6S3pc$egn z%q^b%XvRKF`X{^Y)s?3pbB^NuFu0NQE}Z{vX^MA$s_+S)lOkPY=jJag!Mb{SE3P-6 zqn!K8&-|k7_PiH&*({6-lDtupc+7tBe|^NamltkcC;24y;b-mvanGdR<12mmD)IO_ zs^b7Z7x>A&ATwTe`%6n-jPr9P=koyfwG5WPgwG51oS(klk_Q(j?sMT!-j6}g#BKO| z9cLuoAzOY0xR;dRxqS6N`i0!5Ch~cEGW+~MPx(b~f4V?FPnXEA>^tE+?ul(H$o`VI z%7kEy6^i_ z-`-W?zIfKTJhVpWUvosFBsSV-QH2}igTfGr>K|vx3HJ=y$#o1rJy2rju1tZu(tsu}tt_g_8t!Bc-l z-zhtWf1UTP;nzZcM(2Mu;{JLm?6+~;r=e5Jf9zPqmBNJ+LO(!%=)H3>dsg)i<%l{{ z*~iomea(BzWcJy{>ro@>j`iNUfPHKKu($VqUARfqX>6XmM}^Mi@83VK81c2uuhj3M z>$o3Y|0v==Z5#IC;@TCZ4+JN$uUs1Ob=((eeScbWPsB|h5bR$&;<6_V{m!u9`7*J; z#(RGo=6?Lid(64!5m)Hv;0*rF_VwtKQFk?a!AcSLqwo7}*_Q>_zxzD=In8&~rO@Mi zew}XJi}T;_eyL`@g}TIegT;SbIQsu`YSj71`tS0&;*RJ1&kuzEzvRIS>{}j>df$0p z>-9zWzt|A=ZtjaF{X;MF9G~D^>E(T_v-hGr>Q_Yw)b^<#Rj7 zzjyBDvo0;&kDsTB{DN76*}NbA{czN&<8w@i`|&r)qTbh@ zm-|yjenaO%3io%929f`n=VAAvk=I6iE5GZMcr5Ixd>?ji^2mGno2dK9+3?>o-x>$NAA#olEqBSE7%tV}geY1`GF&dVjEYbDpn~ zcj>+GkDeFtO9qBshHZ|8-t4`iRD;m#=0^OLKA{JQd(?B~hKFWiuAV6L zIdzNp9&X<7s8`l?7`-+0Lvw?#-w9@Lzg8I^b@F>3Z{ztseL>h$dhVB975ZAE;ONo8 zq8~)P-xr5YH#YPG?B%+J-a3bWOK_RbcZKb<8?NVr#lnBjk>Hf$k^hh9+CSF4Yqs#G z@P3lbb7SU_h(9?f{F^$3UUzTsQO~=ro5;H6ejw`f_MDn; ze`Kl`{yNRWf7JWtN2$WzX=&J}c|W`HVc2)OAK%Cy{t~`l>+AcHEY8E?S;K$mOt8QE zw6F8@*)d`N!hSB~dHiAJILFes|K_`&Dj$gPGkOk9^m}u~hGEa@bH+QK3%`^OdvedY z9?t(vHNyUe_nH%)GmR^UeP@;6&1fT0(?To^t*K{`?Q$;KI$9(Y)?ks zbobAM)?vR-O*d`=V|&`!Uzr(DhRW&p2P^x_|ok?>AP^U(xOn_fFGb zC7-K06pC?LJKvL53xBnNVSmWJ8|ysl?E2UGJmMz0zQ@i){5Mm>-fm;)PD_G)JeMSOlBXwnk3@)^$-6)&cOlB zify|AgPVV1=)9u%O4@dmo zW?}!`efO+={b4ICo}yp3L$*XrlkxpGBP)?2lCwqkbj7_wG#ChrfpXOZ#iT z>#(g>EWkAOy_urkPdkHm+b?xruah`|$HUk@ua?e|y}g1)T?bibVV$1%h*r2glTp zeYqoH9~dv`x~P{nQ?PWh;L`Gux93*q4&LXV^E^wbzj~PX+lafD?wTR=d&b%5?^V+9 z_j4UPPK|MHJ{R#R-Pc2gho06rxWey;Z+;!RN2AEQJB|5S|M{Nt9exV?kH-IJQ|NZn z)!Q99zw_*mjG<49-`hFjCXNXE@ba;K<-A{XbMAd0{{G7m_sAQ;o8H4Jn{SG;Vb4VG z`8etyDipkQPxu$ASHyeG5<0v0=#$QcyPbN79uo_ROwF7~`l?KxF{ zX!tX15C3HM`%#}KD$bTSBUpHO@N@4CHBLqTS)r~HKhJaIDd+gX3~{}8zY=+$^$%7$AIzz*N4zh5t)G)VZ$9n*tn*^T_jV4fPa5N; z_jji$y^joZ9X5;&f8sYIuX2yj?bKOXC+sb~S9G%<&bZ#!y#KuGoSwZh@~hWWw{5WU zkf@W=efW>Qf3$wxeBQ{{KH@q)7Q9s>IH^p#^;Ue zTC;Z4uj6~u!QOj+Ods~{-tY5282Q(42Oo9+{^;}FM(0pN-&>!$FYOAl6cjy&K!akyX#AmaQd$g3_F#L4}hpy?p>Rj*8H3|oRHm~0*Mf^wZ zoA>gEUTxo2^`5pomL*ZGdXayqWW?RB8~S;9Wgd#aPyKzw{eMKc&OG{$-q0hDFoCp6bin#at1-IGffBqAB#a|Czbv{2=H1vC!BfeI}&<|p%c45D| zF!=c5@J|rGEm_!4=MHA```qrgBJNZ7@%!FmKk&PEZtFdzSL97`eHZI@z~hl$#JVn4 zr_n_kF&V$TfIlTZ$CWiym|6y)ZMGzuYR|E(&zi4Il|vjUt6ojIaN4YjPt1H z;NL#~jPN{Y?_B8piUiZAp@AsB5_U8rf$xr_7N^VUYXfo>4M*bf&8 z`|xc$`OaKxo| zqhD+jy6jKELDkgR6LoGp7o7TJaQSQDpWwMsls@kKJn})r_4+a5{&jz~Ul;b?b%W{M z4^^E1>Fwk7e@EV1=C$lo<1Pq$-XB8OzZ$%%zcW5(eY7L&jh(lycH4m*h8T+d;k5|dw##$VZX=sfyIqi&-WZFo!9$32iG|-vk!^91}B5t zyvGf)4)a|9t=>moITdmF?bm;5Mqf9qYuWchmvz0`dG35^AC7U~?eaUqS>GG=TpoEt zRtF2&r#YNw&w3t~aQ-LpUfe0#Np$0j_#e-EDP?^gx^!6V8Rbuz7ytIrE{urn{~sb46Zv&#SCu zLT@b}`KiVQ*X;@Zv^pq+QzxzmVoO9`uKf?dV z^T8au!vDwU&?Pp8F1#Ul%XxSim(&S+x3t0eo-e<6zT{~V_7mz2bWYCo{;|pLA`g3R zU-CYX-@lLb(NB?I z7=O(Nk=LzTaG-PGt_2bQfcLTQ{BAXXznuBj^L}-~c<*+YCkMRyx3l@1P;#z$l`nRs3lY0*T)FJe1_^a!f$nQ$aeBbz-bFO>7sB^u3aM842 zXMKP5N$C5m_t&oPl&xW3vLyJI-$8ooyXUCrV~g?Un0JjCVQ**rZHpuS#B*U^X}nq0 z!#>LVlXwmvvCk%2zl9Scu4eVv=TrQyJKlb;{Z06Pv!7aDjd6a#CUZj1?Hjx-u9JP; z$@Mtsy=l~xs8`MUck>+i^WLxz-V$8$bkxh@eJ{aRMxZQrsCH|yw?kO1lJ@S)T z$7dc7dwcJt*Nk^~P>j>m{+YZWbb*BLlbtuG`-eT(gy7?z$ITWQPu_j}CA}9MTNUw- zd0#1y+r)3hgW~r0iuf&4f*((f`rTd*-MC)pcis&B{xhL-drl|%F!XZvng>JwQaPA+ zT;!F0Cv={#f)9CbY}+#Y$?WH!{|WuBx`~^HzTGak*FL)6`^6=nOK$7`ntq@0y=txB zBd?J6$d=~!z31E73*oQlyxUYG`fEBZ?DzN`V)hqdzxrO-_xSzjG4uTX)9`0&9{%aR zpUdn1OJ6$nd-1sux6Arw6u(9Nv93o_=k429qTW}Y-w!X3{8Rp(@Im^B^R$q9-#3fA z2k9lQ_hKCF{k)g=*Bh0h?z=BUUQhmu*7@PP!(U9@uFj_<=D#RQ_`h&{9<{FN^*7JF zN?6a8)@P#iUZd^~+`c;M4f#0u-uB=_-lGcT5B+A{;ElJV?>jzMJ=#6=Lt}$QZw4!x zXRdsa_osDEF(mxsz76|5^!06_t5*rukw4h^mEpz68%mdv_vys2|KRyHiGS+es55tS z@Vw{r4A1|AkB5D_amVitUE6cB($uJ%bW_-C_6c3pc~Okc<$QUZeW>#@Cwn62NDlhz zyixCz>zCDdJ6!kk*6Shn#qrBA?t9k#s^{mQ?&tTGM!hHPuUpLKzOQGF zxJwy>*)B$ZGv5e)c_8ek+@F8yzmj>@)lZ4)5m&xRWz6Q>_giG$7Bh6b)Szr{u%b>j|I2;KBuJbod)>*VorIY$Bz20&zqTRx>+#_1qQRnRf@z9Ge)-Qr*E||L=zEj22SdM8G~zZT z51up6mG#5l=0ez?@poJ2%`aQ2u#XrKtYbaz{1bZM&0u2vO!N79i1qsV;h1RJ6ERN8 z(!uBJ1PeV9JZ8LZc|xD<9d-BVe?sxlr?Uo2oA>=MhaS)0!1ev)eAx5*p0tO4rWXtQ zter8=Ci`c<-@o3oPQxFFxLej~!oV(5*gMw?c6I;E^F2i`e>YJ&S@;{SWX(dSqC8EzlsTNC-C+z%D|M%)tn{)&D0?2WM3-x%?A(+3CS z340s!I4XX*aUL@7G{zZFHS%(qM}GJ92;=9q4#R05yA%E1E5^xX9g;bJ?tLQarEz_p zwhohAhn5NRa6jDgd;SvZ@rQHbVfu-(G0t<}MBSI{&&gN9UOG|OSK7w|?2}5yf5rWO z#r;qrcjPtmJzGcXQS3z6=ie9gW}8p)LG1NnKkn!g`n2_5(Jk}~3FChm`5o=|`N>1~ zH%{ISp^G_J%Q|PSR}K3BaYx*LSFOh$-%I~HFvk10NW`Z$&m1K}H+>{{`?ZLxP$~4o z&gZ@Ev)6o|@?5@{*QDkVKd4-AeDYvU>%91C=*0g0?2WI6K2R;{|A;L<4SnQR_`NnI z>Q*!C`JW0VFA&^kyyh=N{JH#LUm8d>>g)I)4|`tCa_;pr|F`-7a89l^ubiWz-WvxZ zf8y(*Q#mJdI!`xU4|`$v@73KAKjd_9LC#=u=Y9^?Wy9TJA8cO?O%-)kWe*N_?(VaH zcNjnWPm#Bi-i0%dM&9dK=(o@<=&AQd-sk7S-X&$|*UAPnJRA0^u47`?@4i!EAEuwC zzeN1u=fhsiI<##UdYb!bt>@RCy%B%Ldak!#=`w}=ktD$_;_{}8_;UK&xi$1Q>orlor}gz%&Dh67?bCUllf&$fb>}0$)}G+K z&Yem6EuwBF`+BYWt?k+9uQY$DbCKU7b?~p}!apWg=;rL53i?fEUJsbZ$)piKzfAC8&R}c(7IojxzW1-|IR2x^zf>dG`T6K;ko$FSLR`i0|81X+ zY9DcJtlzV)OGWqJTgSp*r$Joz?cNuDIT`l#&dt=6SZzdTmx+MUBvZuzf3ev?MEZ7k+^2K%6hcU7XE7b z-q}2KUf2KU^3iuq_umws!|ymJ7JAO7TpoF!&kUA)CpchP^fh5}=!PpoH}l+@*&=j1 z?>TR@4Snp1;EBf~uerFpJy$+)?jQDjLcNg@*ZNLy_Op?{?8D$)X@hV3{8zMp#9g*O z*9;B)n)imZ^<&;Cyg#M$dGL!85qJ9isMp4OT4L+G+w=6n_2EC_J)-&i$ot0npY~ks z<+)TVZ}^Xl4OUwcyzck51)iIwGOOd9?Da{Evwbn92oU>4Z|S;rN*wFq==g%{_5HAuQ%S@jN#wAKX|Kl_;Y$+nQoAmPU)T8ej9CiC@w4MD?+~=~F&HF3&(HY-MpT_>qh4-v`DeIWp=Y@;n zKH_g>+yOq{cbyjfoN16@S9_DlO3(l8T?$50QqHam=S4W*Yt9L~G3dT$B_nJvRg?%EHsuKG#?TM)KUC2Ze z_}jD&`&$DdubS_>Qt7M37vW#*bIbR4hc4}Y&$BD?_8kxVv9E%8+4JGEOCxTS^~kU) zbP?}al^=?{3!X!l+^5&QKcBoO;)jopxKXapmy^SOJZsn&d0sW#8TQUegLluA?|ZYx zeIowmrLb4G&PSSty{!2!uN400wuL>F?+5$1??!D3dx}jF_fDcoms zU%3!*>F*7F!}mc$4uziJy`qBW@XNizK5K1oVf$bY`*BbIsQ1&7V7*_$pD$l9nfK26 z?3?Zn`}3Tr=|>!Jkb0L;OV(=BbZ#{H^sdL0&!m6qPrRy$O3$Y>5@{NpZK# z;|+R{`ZZnO+CHas(9b>keo|lk#6K-Ri9VhepNxKv{?&LX*&mgchOTJ5D(W|rm%+GA z=`Qjv*)L68&-CK@^5;^wgFd$#zmIXQ*cT~WpMS&^SEsx9-^KSxSg&srC;IG* z8TL~_>$k%^3e(%@BnjsQZeeewpD)$>3XhrhUV5YW#QOP8A4QDQM4cV%o5kN&r!jw4 z^B$~DP4-8uTMqUl>ZHI<`W}b{ z%=b8dQT4`PHvUH9pEk}Y{_OlIjgwy78TC@QUslpz=)W(%Yd!m_mr39C@CN&z&YjHm zWp11%e=1JITk^K+tH1I4;YNL4Quhh_f4KaojelAG6>%Ti->vmuTi#pp{&PRwHvSUv z6Zkh7cfWN^Zyv9yH%EV;$$!E49Wb-;7K?w0eV_W1*}Jm;pw4OIWt9JezIuu4jXTvz zqOW!II`JFmOX>}i_aXZjDF0jD-`}JMihl!N z$F~yl)Y;K9=AXvr=Pl;ZRs1M%o#>7@Qk@QT68#r8ugCTA3tfZ%eR?&f6<2}3JmzPA znEqJ&r}#O3fe(oLir$7Z^tq2NuI>hXSEBEee=pvHKUQ<9?ijZ{ug;)?iohHReQqZG4x14mM|RtIl-xR`hfH)7Yo0I~(WWavUkHv%F8( z>*FB)mFn-Mv-0M=$uKQ0mwzAKRNXc>h5uJ9V}AMdn@wB~x;u8muK0kw4)j?4wxPeu z9P4u4`Y+~RicQ2liSMvirBmtSJ@(Y}ZGDfkZnx;)@e&qO=K@{OdDh%@-Rzv}K0o@* zKO^qTKD&c?>E8TLWRAGk=$!n2dw(0oex1I8_lcXXZbmvCo)wprK0}|tYp_lg`&8`hFWr@ZYh1W$69hCw|1K;(w;!qH}p4=}JGP@07+%jaAg$o-@XO zQG8|bS;hUWkK*iaIA4qMm&Z=(?Nx8LzRsBcF8!-_?1SmMymuwTzT!)W z>m#l=cH(~lpTQpdjp^=mMs@45cV@3nccMFDdwda7>0`5bjbcy1zSO!L;QxVtA0A6s zFM1EIl(!1E>t_f5DS7Ad6LDYgcXoZ&(i{1I!ddLs&&^9X!u|2NN4_kowoeJ@1@ogO}NV$G-ZVZC^G? zcz;sww7B&8Iz=Ba?tYwsTig$$)fYiw z-1KtuzMp=NUWKdiCH2ya+pO*{>TRMo;+OK)((TRjr1+KWFR}m1-kEOg^XLcP$MbQG z&%aH_g-+&o=ea+Ie(R+~|NCbQet1vldHj#d%PFrWJw$vB`gJ;wxa#cle1E=9y?ME! zep~S^v9P>j;u^4Dpo^&YvHm*JH7{pq3D z*ZP0kA?EQlZpZ2JW{U46{%!h*xc9K%*cfkz>$MZtieHD_#QkkPOXTn3pGBXP{{#Cr zdc5m0OP$XARr&w54v$!e$Jw)3_mjqb(|pd+71gPSKdJu|y;Plx;`j6K#2q+5ToZY> z&1WF{v+SRXzs!FI$B27c+>bb1{|C)$L`VDYV66LzWub?$j~XBLf!GUooA({@gXO=L zP!C@c|2+0)e-+!X*TO04bmZ@VmH6A!v&7BD$@~MX>)YZMV1WrSkNmiseFtV||C+vs z{*umToCmN7Ua`O5rau;cM?crFo4)FZtBcF5-&t`-@PfMQ`M+kbFYgH~=KgJF+_LnC zuFnX1H9b!sY3%R&aD#oZ4hykguutZyvj9I*?;Y{WaTzYb6Y|%}dsp6ix{7h8h(98J z0=+}ruj~itet243N$XRdeVcLWTbGCVbK(8C);eaQtBJ3tPIC6%^wU^X+-~`M@nQCd z@K60+!&l@N;6EzwH~yP+662P!4-dJ2597=+v7hfd63mL(ur!vp4pmmfefupL z{*|}_-^HH}$NEg6v&g>}d*FST4R`8eJDyi3AOCvxtL)XR$FKToo$$Og?n?0!=z{pF zdH*f%<92bKKEj;xGT~C=ujHSPDgE8ZG&&32(sle$-XF$Gq+VWe`SBqvjXl-7H9FSu zI#%GXiZ2?cI=$C;8}Yw)V_t=gyH?#2)~yBm4E;5^6W4$)j4k!i3b&c( zlio|}V?BIJpEc=UooD6f-xA(a)O!=JvR}i7#(zZK9ricG-^<^H&PtCmero$8Ev8ZD z74cilBcFNSQvVzFmh7$7t!2IL*q>wBZ_t)HyKygm zm!QSfbKe|eKa1z^0+zN8C-m_Mz0ExG)1&Ep)+rBmV(*~d+t#BidpGRPpH;od;>Kf7 zam&PIP=73)o=%5-<@J@9hW&o^UuSP^9pSANOt7Wx=iII|IADgSB3qMx(9KA{G{URh--vf#TD8YeQlvP zV-fbR%qzP(hkSldHzo2iV0-qC_%e=>Hyl4uuP^@~9E`)TxA^|n>2rO}GRr2Fw#P`3}=+de76{wn)`Umk67p~bdna-C%HPTV6n_I;w>Q@Fd404suk?PWY0KV@y*>V5J-5pLo<2+$ zRez{)FW_eRs>_`k(o`q@K2B5n}hZUNxV6`szma6IY*p9KVuRgWf7{pm`paw*j9v?k>8RyxnvWy0N%A_yj)8zt6Z2 z(fRRfbt+GYefz9_PP&g5FOBD7Ip0^TI}mXtyr0}XG4yu!-B^ZymHZ6i(qlSI{X^sz zz{Kp=y(e75|Md4SZc+CNeFk58Ir^=t-p}Gb(pOIP4~WZ6-}g%7wHB9&PKN`;^}?6c z?Ib>#xX$eD#kIwn`bi@0FXKPYe~X^1USD-u@E33%)Tftd32sukfdoKfyXYz~0!nhs8f`Up`~K8|uFaw#F*_{pd61RZqP?tmienqwm}FX5$T$ zzllz*uQ%C8;7Rr0qNib2eY{V%(Ek?o+IsFzG4GbHd%gW}U;XY}X-)5&6!w}+V!yw{ ze%-mhi@zCvC;n>*`XPi>(h1EUGU!MJ8 z_R91_bVK=NaH_mX_>cJH_E}o{p@RM2RljNZ57`%~?TdRbbAlF^g?>YRX7(JIA4`j? zD(*4*F}fOEg8tC>E!eZWf2yljUtBBx-^5>V9q!n_W9g~pKZV{Qewv}7D~ws> zmlR)!{Q-PKUTOa9;s>(lU{8&QK8txgCvJ^8P3cASLR^6J@ud8l{yR={*>BM;>2%g@ zJl#nB2AE5K*VP*!t{?uzo=o4#)hi({34PnR>s-fS{Hcv|ae2)56?J~e7T51I`>X8t z`uA=7(3^%t+@vyu@n1y|ZaSyWZqW9o;I79uM@_uCh(0I%7j6NsRpUC@^{t16K z-Z46rc~=%cLj5{)T^z}N(|%oR{nA?h2I3mwE%mSA6!}we8qUJGI3Js+(;SbQ-va(j z*5h6Js(EE*KWIN3z_SzL`s~*Cq<0hl&rq6uEM0t9#8qW~gsw(sQttuw`{;ahPP$}* z#`^LbU>EEs4(cUhZ%Mbn-1=Uu<V^zmd3t;^ykBuDCDEkBYE6hHP{er#T?(@^mqlL?2zyCWa?%(zUVSaj&RXEPM3-GW~`4b_v&AUKOl_$JDvkI7jLG=%48C)yvLaN`CHyIR2k; zr@Usa+XlLj__cH?Jd62othhD)J^T-_k@aeTZ(7HCbS%Ct=nPi zKifFn<>!-^3#am55TDoj=ERHaBjjJA@0MR2$LOOy-4T0=e-*P^kCps$tjkh5BmW}$ zUH-}DcSFC|ajLi_>X+2_K>ZBH;_QvB&kp(9aHKk~;Rtzs={~q#d~SU{?R@{#KKTU8 zU^%RSm9W~7MF0DzEZ%mmSK)ujIkDHgi;ByMrNt#OpVo9ud6m{D{$KqU*i*@?%wGXJ z^QYu5%ASJm!Cwb!vDe1O@iXr^Z_%UiH_x@C^0$jSW?r+6_lNnX7q>@TZ*``KyDF|d zdpmp))0p>U@mUi3=YPm`oy0#8)5$9!{(Jo;mv`RvPD-b;?&F;s1n)zf_%z;{L+F6Y|_IDY1q8)$*FqjWMmb5BYnsPsc6lZpPH+ zJyd)ieWqa_!G2o)Tl82Qhm-N7xSr|{!#8m_P7&Y0dJVFEcN;$=ex+UpdLunc{z`fY zF2d`0YkZ>r{qv>wwaeZI?)y0L|LmDYhCeMnz+ME4;`{GMe7d(HK0TJ^e~*7DW>GJ< zxRLBnif@9&_+R61%HE4E$N$TS821SFhtCJp=e-!iy32|d$ zyo>5>pzDiU<-Z5^{fdY?Bd#ug9X!Q;64Pgm_#fzs;!Yd47=4>gt^YKb7Smx5byn!F ziuHP#eW&;PaqKhX&BSf|Q~0OiXZ+dK$%b$9r=7NcVS9u>cDbm$-HAMi)^chuR#ew_VldIkS1c;yNYtFTabp&Nvl|iGNw#4)(wFa~-eZB|M8gj5A4{$#_AX-|>L>{Ww!x zWqO(W|1A4#{giQ^x3PZf*_+ZeQ*$)D4#=GIS)3vztehdSNJsU z+hM*>7=hoc2>VX_8XJm#^Ub&~Cy8&x{)M>nSj;#Z=rve|y|uh@^t1G13H@Oue8ade ziJNEq;`}+;uNo&6J=3|nb4|?aq&m~tzh$qZ-uHBol@UKd+&=aL_=NrTptytVkF(dt zn%G~Rp2j&Tz7P9<`aZ?}Ctgp`<6_;fiR)>8JNSFioy;#4-i0+1#__(k*}84PtyoRm zw{#|-+p-(?F#8%jf;q$`7njGpZ+b60W89PYi1;7q{kRRc;#KvtiZ85g4)e;1b;Nb_ zxu-7umUWqgt=L=RQrF`%{_gCb)5FYX0QSdW;$EURi{FD!vOlW7MdFLlhsD(qcZ5EJ zXR$@Xb#oppb-kC`4}Cw0efkED!ihKqTaJzWGl!mwYlnyZ*Y~2%Pq>=>MR9xC$EdTA ze>M9A`aOCyJzxA8bym@z;5qhB%=1h6b6n@7u1^DT`@~)IestYASlu~S8Xv}gz32Rg zqn(30)yXezrSYERUry)NXC3zZ`gn-FFqY^4Pd^LgmlOXWe{K4T^~uNH&%Bqpt`p>s z#m?--?CB6_my-7hU70RuzgD5E%O7Q)yYzR)@62O7r@Q+eW$V_s4;Re~?(}~+F^S$q|156% z%(#C~(_hm&aTlKDe@C5*^dA1N`bM3>{Cn94(YuX%SzaIZo_JV%54sC(R`(SDD%`;T z9DVO=F@D!9!4LiSYF1+x_6f$HhO_aKdT-NjsQV7iVgJlL=FtQBuj}&~t}^aYajS8> z_^rm<$bMShT>3lXtjrPfxhSv1tk89~#r3U^wG!;uh`k>D3??yd2jevpcNcqi_U7zu z<#oi%b7S1+_5>7|%bKa1!!`YCAK5|~!p6UHmUK15zQx+;Hm@#X1$;;M)%#r_}8H}2E=Pc=W* zciD`%&Kb6Z&V>!DQ-7=d3q0Bgf5J)n_qr9 z5AGHJ9gYxpoW93+KkIWOe`51Ug43Ndnbe)k-pTb}Xq~^4KUDlz>JCZBpBeLOB)*_? zVGw^E_Rr;2weFR%0w$AJ5g$~y8eN30MHg1LIQzqNcJ&^jGt<50rJ*a+b?Gho+ltGq z#|ZoWkad`%?qnPKOjMi8;M8NeM{VK+sj|-v?<$|1Php`D7RWD|-RD zhP)T$9p*2^-^;kA=|{0F)|0AvbdEv^flQd|mLV4N~@Vm_(FrN?6Ichis1 zKhKW!*dzZ8orgcC_{P>@ySRGvZ{o9xufv{&UMK!jOwFDOQ(_9NVZ8s$Ke_q!XRmA> zhR`31YmaCAcVu1`_lLMw=#2U}DXzG@>*5O2>BJou*MKmoANU6i0hS%{}g``-Jc`5BkJ) zSdQKKJK#e0HgscbgtPfKV^wu)V;ww~BgSb#KPLZ*_m7fv7VDN3Us3mEysSNmv&8x}w;sLO+c>wH zv3Fwch%e$&aVzjC_J(-czWjuL6ISOx#ovowhAH&}e!(IBQtL_^0zGc5czu~=Xf%|$s z9$FmtZ}tIkou+&q`XKwp>|vkIJ_Eny-{k+_E~Wg_em~#Ee-zit`wG8c{|vXWFPj?U z{n0;o8JCLNA+F%P;h(_1ll_kP0{Z!x{{ecBeh1Sl%`cbyn(7v!AH*k?#JW60m%}AE3!S(#R_%q@?Uqrt@TF*+>C6mwB zv#rA{EW@8#KNYQ83HBxGWs^TuUdd^39jb^cEbl$>x!E6N&x+^t{jc-kJpC7afo`Mz zE7%1eP`3uw#JBbJ0i9bPc`%px&FAl;pWm$0Wvn9p54xkcs_gfuQ;puM-`CV_%zn4H z@A+R;=NbN&@p<-);_n!@2Y&|kH^p64Z@PW35EJ>kl?OJ(^&dSju1|4#1U&>FpA!Cx z{C(LQu@_q!b)KTz>!UIKtoYX0Qk}NqUJ%!t{Y845{y%bFbY#zFyl(XS{E5x0CVO@4 zD1OSu=yQemmh5-S`%8Zh$$J=I)@K9pJ@oaBdMV`JqHBr!O1JEv3lq*E z=Xv&gaGp!(Jc15m$qLS=?y$wZ_>)e~+hd6aT;7 zL;ig|`YF6H#@WvQF#QkzE%|ro^8AhT+X7qRCcN`y)cug|qJCoay3svwg1Tw=t9YLp z$DYo*^%b8@TwWZ`zRB}vvT+~ge-ta?c=4&#oj`Y$H<4~l-!T6v3u9gnU@m+`zfHZD zO%^{1$6?+XvF^j^H}OIC-&~(Q>J(vbKo_IC$?J;6*-Kz&_D=XRzJw#xYfC?iO>rRq zO7EQu*)Qwwe)E3DyboBfzxi)sN^$Gtr=XKzQoIWjVP)grG5&k5>&NQcV84t#+z&P6 ztq|9T{f_?r!GE#6{Uy^r#eJ>VrJ!XizDQ*}4*Z88ouIQsJ{h9Her5CGnS=>YFx8`q!pU7K{ zFPQ%~?(Y}r4p_$ixKBU%)v2TYLUHN&m(oe;vhqJ>FGtsvpF`Xp`~7!)d_^}Dzf1lJ z{+;G|jQu3;=ii4j)R~@8&$uPkEsnYMamzYZ6xUJR!qzK$j@X|)+0)2R!CzHgPH~y} zuN(hQyo&XWTMz4CfAx=;=bQ9-d506`PY>sR3n$?;tgF8rK1Yw+6!X|OI_}?=j|E@E zj@SwN;3roi??kfTQ1;O{9_NdjP0ysK<0PDjOT@iNkA32<{|(TB{Ws$^r;pMp>CAsb zKN;zJ@q2Omu_SwGJjnhdUNe3r{>oSlt7A>PAif@bhHggZ($`S)ImCYZa`Zc_e60Iu zoQ?BvA$}`<8$PGrCjQmz@8SXWpYRwqmN!}4SR9J!^xqzzkyjs|Wp9}POFxaND#Uu;E*Ct6HOhwmEg_E{a5b(&1NupP z3L9g0aV_bN*co5P{y52gsx5B{J(+(7R>%2R9*2lebS?VZ@M!eE7cZ)N7JG_6PM;EY z8ZRW|;eVLec_5}TF)4czJgonl{D0vA_WhVk zKNWDZ@hj7HaJ%>|xW;u$Z=b*Fz8zgD_QzCg_*?9o8T6lz$9cM#uFPK%-(i0jSKvxq zi=SgAc|X!e@n=lMKZ+iaJo*_yzlkaEF7x|b-X_e-pB-~xF}!15wdkfeM*eO7TlfNh zPwa(*a2O89UFuw+?_l4`vEBpl2lXdkig`|CpKac6;|%s$I0xtBGJIK`kLj1_h3b64 z-iG~qqoy7b2kJ9(kg|RqR#0lzb5&w%mKce5o z!|c87=Wne04>;U@AC2R13f?7e7QFx$;)nR{?{R&;roY1q`aD7ZiUsY<#qt(mUiP8l z-ew;{cf}m)cG6!C_KtKOx*gpDn_>z6x^w~csv5s6duc3*MX`#wSJcVNKA28!A57E# zL~L0x_V<&<>p~ade~o?}vlyoz-B{j0`e{17{8j9KxxSb10{)6;FopV+=DD5<|0)sdo&IL* z&r~Htr=~N}nK2jsdn4it(4WlD{H8jjix`Y>O}8b$zv`|Dbd0t2w@B zye9NB_#`&MhWNQUTd)RubzH69ZvG1F<#D5VmZSHHD?wkOThJZ!-w_XBee3fC9%ny+ zRoG9{<>|-pQ7nz6@QnDgcn%-oFO0vjzimEW(J$dz>?OW4y@CD=d$7MxZ?}HS=mj_n zR~c_QJx=}iNC0(@8A0C{gtt$!cu-?n({=NGUYzJy(|JKi?VYxF1_ja_fW z{(g&|h_~cTre|R*@nx_CKF_}cTPNi4pTZMZoPRI<6@GymaXqfXHTa6_@;==_y`}U5 zoQretZJdp*pV}EdNdRobwlajJ}IbjF&wh&f_QQ9jA}rSL}!A z&2$NMw$N>{6`n60eJ>XGCw&`dv(Lgr^6tWk?5XMdFe~Q5g4kaCgXa4*U4_4lb$*V1 zmw%6WZNeAicX2(sVNL$3SQ#r}1uTazsWU|W+n9$x7iPyS*h$_B@tx^b^lou&*&k!C zN3Y}m3_rnN&3h?*lb%L5lb>F_j5v~i1P;Zl{4M3Bw!VG%dt(!EdF|)DuK#-L|Hbv# z*H_#x8|Zbo7RQ!~{WJ?_<6>NiAK`R)lkiLS5%kaWDLjMc@m0KtUGYWCWj^=gO!H65 zpM`x2dkQ)i|9JL9>?PT&Vs#uM?t=Ac%KoEy9K<&4-_YxcwRi|bLSDCQ&*je{av|E?B5z#JZ0Fs^LN3n{4dkJ z=zcf~E6QI)U#S)E=hfH?$}fPQi_1gjq`yoc`(9lAMD&}lcGOLBI{MA0{@>y@iMv7X zq`$}gcn~j$`-MJ6AE(dagT}c=XV%AcI*op|>OZ?WwdzLSt4>D0&FP*vmAxN5f*wwP zYaK_>qp_oYcJt3>Uxn{u3-vyyzrdRKwSKG874Qf4Blxd6ztR`*X?>)ScTU`C%)*`x ze_}s^IoN-sAEF<@o$Tf5&GeI)-nzf%Iz0P$tam%Cb|%)nJYGx@dKmu*9EoG_E!=?r z8RrgOQ|Ai3TiibU1utPU<6oic;!Et`;U~4D|Mj?q{ebb-(+BCz;&$Lp{03)>zebOv z?=gN>%!57nAEjTQS6Scd?Ef0S4|`+l@Dw(}*ZJST%=XK0`Yn9O{WOJsSpF>fLH-5w za?B!bC7p?Wl}>`q*xTcC>fOzs6<6`M;4jKv2Fu|zah2$5IG(*GJ&GQRLvSFbvmPDj zUhwlk!zHi|@_2N2Y#VhO=@Em@mULkSSaHPI=i5o?4rC%1ek?ury!KC_H z%b%P*1^Z6(>80+gxJ5sE`48Yj@=nvQi+=;Zke5^3eRxNFe{mVv)8httDe0v8EYChU zVI207=2IMVxjzbFe)f`dcKQ=_Qqw81wYcZ;U)S|dJd1<*hvCocRrFa(y&n23Lnjg6 zk9`P^#_9T+feY9Ns5?@f5xAcJHM$RW$FBI3xZ~KGy^XpJ>8I!h-n$n$$EV>V7ZUyN zpVz7-{vT6%jt->9;9EEu?~!*m&SGDLi*X75_iK!E4X@x1{uA_1*qi-c{X9uOZoD`B zZncoU>ihkf^fbK5K9NqW&JcPKzK*&0^W%%`uNm)A_NrJ7pAuIa-@%LgIn1Mj`8|(~ z)a_V3*8df3!atZEg2V7ltS7&!_$pWtKNhzJA7(#9|AtNQntq?AUlX62UPG_O5Ac0_ zK-?mFAvV+JOnM4d6kijczErgg82sm$+bx;Z9d|IhXM7u)i8z(3f} zs6W|t`i1=%juAf-zhvJ*-)p>)Sc-j)dVAF$$p1R_!k+l8`L?Hjrk|%<<5~6})xAnT z!N0(`^YJeI%%!u^B@^t<>*V%(Rp-fUJa#tr^&y;6EB5_N+{3;bciGS$|g8d%$ zjM$RB6`m5GoPQ*H3fzU?;&ZM;9`neB?buhTmxVnucH{4kY1!YP`{BPn-wvRM;=AhJ znDb(;w68aX%iwBiKxQQ#`|7 zn_i90_0f+1Gxoo*2LDC6xcfV|_!I2;=>qrw9^(H2%dywQhPaJ?Gk$@e<2r0B{*Lv1 zjJ*VIv;IBx{TaOy=i@u_XVCA`t8g^?a2%K-uHzsaiob|IfoJh|yn)@sC!+VAi+UaD zBKmJF?g2U%zQ~?Md=AWu`7l2g#MJWJ$uGrz#`q`jIJV*ckv@Rm`kY+M@27?FpB%Bz zOQjALz&w}>@6H+iPa53yzlmq2@5TEt8)nC+A}vu9e4PDksxY*o57FOadE^_F3#RaB)H&J=ZuNun%KjOTR{cL4S!`FfqT^)I=j)hec_kk-pi3>dW4c(98POzt; z&(KNftMp%(&UmTSIi%0L?EC2L*ou9+{r?qx%slR8KWzQKWB-=kjm5>4!_Dl~=?3@# z`}?>GSKhCn2ir%Nc7hJDI_W9H9-xJAWedX%=fqE7bajvAUyl(sa#;K~`XGIV-Xs5W^|^5)e*k?~T}OUb>@6PKTm$$Y^1q-* z;uvf!ULUXPKTmu?m>6MZ2b0gJIuvzNjJg`)@?v9$C>(03mW)n}sk zZvHOZiNoYglQ#qBVIJpP$o{IUTdnSu^M8)p4gU+i)vx#1irnSbr5i z5xs&=O3$aqS+@v|#ZfrT92M-N43@yg@(R(pF&E~*tXRXGOY}|2Pk~ACGkurIOTb@A zufpsZ!~giu_izKB=bMuTe=AN(6!d5uhW)W0{^tAoQ~DFUz(1OPBHj~+x1!$bUoxDR*XR{R+^;Ux8|=z8Xx z$uC9M7q5f=CJb{|NEX-_o8S}i7IaJe5U+@TL|>x2)5qwe_zC|YJ=k2Eo!fehFyB4% zmsZzZ{z-XNUH)Jk zj=gX+_P}WBCeZD0D(1HCT)H0C!m79$*WnI4fU&KUlP=<%OPT+M_b;owx%|)hiOjK^ ze-fLEU#4TrdqKa%*BH~fZ(w3fipemKzPT}pzVGStCjA{<4y$7=JgvSqozni=&|Aef zVrTv;I=OW+s_Q2{42NST@v-y_^^@t&KDW1ckJou0U#AH7H%iLDSU4_z&~fQ_SVLVB z`U`o(u)O$SdJqo80r(mA$CUb|!9UHFo_BSFN?>&AW{$O08ewe&f{3W;uCx}nRx%?mKdAJ-`;40jRn{YG!jEl_ijdL2H z|8}~b`G?_ae9QT7lvjw}L|6BmHq$?2C3$_U+kkF@`PH?g+hRNHf|=!I!v6S?`G(N< z=}~x*KbbyDAH`+-L-cxjBaS!sHhQhRmAC?z+V4>L^ZB!J9Dakh{PW+r{2YGR@6DTY zhx_{IRcN?_zDb{=Pe+n}1n=@URtrDp?B+k`N6QoXuMnRu{uVzSPUe4yo7CqJUqk9@BRSy}%D7`Q)|Wm!-?$LV3;UQu0b-3G6Q31NU3+JNkRv!=Fn>;8^?l3dhP@ zWM66dOXy{on4buD@T1Vj=;Jt4-y8Hpe2g#fB@U4v@pgDV@Pv}a6d25V_%2+ z^EKY(Kg6flTRgh@?sPZoicxZfb-K_==#1EupNZb9e=$0p{ww8G7q5YJu^qmU_cwmP zZ;u_Z6W)@S!#XqhA347TbVl*z^h#WZ>+zAfOW+IVebIY!0ngxRoFRV!9^kK_*Wr4+ zqVEoQ+xVO5Rd}3#1{d-#(i82oBz;r-F23h{N@GoVb+7@xk9p;NNN1-1G;d#iKYUaC zk$8MMPGp@q#>>A)e@|C)?lIi+%`e0K{U>j@cd_#Y#>Ml0hxlns!7mv-_@yu<|De1B zn1-JjvtkkR7oyk6f0r(fugq0Q{!{uUmg5hi8@vc})x(keuW%f`Ctet5@=NHqoL+;) z`Ni-Y|6MwUKELrFVRtNLKUE|5XTPWD^O#1zy3RGLyx+x>&+Q!KSOaU}B>CUq*EkwKme&pQ+TU<`Ok^MIpl%-Bf?i5*#_Ie^ zm{#Ao?sWw^hy8uR?~fy}h5O%KeiOP8zVN=k#M=B?SOYt&FHe`oQuq!Q#kaA$IkMB; z=q|X4-$(z{{MGzibRL|+uS8eI$^1!Jg%IMD;&z-Row@U{Hs z_$S`Q6q!SP2E4)_8Gc-g$iqLy&rgpMf0r(XW$~8v6Z-SD_oIb%KFt!iS^YM8dnEZs z=oL{z{t}#vH^uMZWd8R!9>2z1Swo+p^bjn_Z?8{Nb6yi)W1c4bJN9=UEAuO1MSLNi zK;Jjy8cd1FF%iD@^Wk6STd%&beI$(@_IWl_U>?6`roxn%0ux~j9O`-1 z)%Ujd<|*FOf3Un4{C_d3buY;~kBRt6v5@r|Tc-?N0}o(veRtC(==X3FKd(M(=~dW3 z-Y)Y_<4?jK;w99V!{*{mahklU^d}Nke(3!EV`U!LnEP|`VOVOoq0l&GvGwJC#87E>Zb*-_3x}o$i{6v0F z?BHD5(Rtnb;#tGJeh(LA54uD|;7WQEZpN*cL*8*ZGku!QNH?=y3i_V-@Ax;y6_1)D ztp5g<=BK0=%AbjE`5qcBuNyxdzc0TJzaRF;f%pZEz>%0upKs{~`qjajI8D4NJ&ztk z|MhS9y`Y$WC7jD$`)VTI82{iu!|MEh>C$vE-@nN*4W`9h@^WGkenIQ!!;1W~k?YDo zLw`YMr*q@~_&2Z;e;-|sE^XiS=?2&kx5ZjDvUS3&(S{sj4>aR~N|8tzYX=l_HA zPm?Y9>2ZCOpcmsi{CBY!mcZHae!`0UN;sKcgC0-!pg+YW_R~uI7o5*ON=KJp*8ADj zzADqzur4+eKkRcMA3afg7B0Zc@>bJV=wIk#cmiKyG;^cerG>11-C z-j8%c@u_rMx|+Q1bRjw$PU3%Pj(K!U@#wgfzeN9;=1<-?oNotyZ#uvDcztt5YVnkG zGE9VVv7LTz(6iM=rC)Cf=d_CdkX}#UrOV0hXO6bwEpeK7TKY42>F8nR7|I_mzkv9s zbaA>Ymc!QK&9D)_x4up3dXaf_8@yv5<2{E&o$|v!nqyB zWBikN1~1|Ud28{I{tM}Y^lW;(x>@uHx*rbP8rDxh_o6e=Sus22!F(7|I=t73?LR4& z60d-z^{q{(m6xC2nSamxU(i1|=b7f8j@8sJ_%xjNLR^Zgu)4f0^iI62?jnXjmLI=UoI!C2NCM}LC}_=#``KNX!C(_<$5R9~_tI73}2x+Ko!UvVCr=pC3tURK=C&qQBWm)6{e#8cA^ z%()rgn9WFt+$I` zPQQ8hm-w8>{`Om!9xrbkHsXItkH84$(Vy;#ov|a1RR7vK|5|?ve;PKC-w@aE54z8d zoO?5D(l6Y{&OYCp((A3$f!;uOr#I65=^xzN-v=E$zMn>!g^Rmesy}K zbx+&RdAx|%aA#y+`G51H>9bmV6)wd^@)OESj1A2(OKi-X9rRXxPSAzq z7r>I!cWS76OY=@NxX@- zu#9<+*zZezgnrR62FAoQ);*0UaUcGI8RTcho!--tzE}V19q#q!Zh?n)hWC66eF(Sk zf5wft7BBmrZ)xpS`#Ti-;G) zGFS;0%d1M)!Ft#fC&_C|e@BnUyZE^|2iw;(=U*9{h&QDVIghIRD%eN-6Mf$0kKp&= zPoyW|bXrM!gFS_3@d7s69nQTeHo}J30IOpajM6pq zElC%~f|yslFqXh{;+?S^f46zoVPo7auRZ-CeuP`ad(ofZQvOhSIMyo@^}h{I6Q9Jd z&HtLeieH1jmhL6q!uh76E8E9B{v7-Xb9mn4>2Y{bT~6^__?h^h;=Sn?^h=CszOLdi z=nv^A-p2#-E88)w&6}(FK-XM zjE?Q+?;hUY{`hsTa1X!1Z}B^vwJqH5N%Rz)igR(Kyv6i#T!HIxpuEc7!=3z2{EoN~ zkBSe)zSt0(<4NatPF;KcY5qs_aq&)cJ#!r4AHeC+85QXO#b5kP-F~i@vu#yf?QnH9rHM&?h6EU;m^0&+tneg+1hb zjAQs6>9O>9{D9vICz-Q3JxAVREXUtUm!h}R1?eXGWH$d%``kmfpc~;y{uTV$`Bf6H zh$Zox@0$LoF(CF1}8YJ|-(>hk~Wh$t9=9mQWP3-KOw zZ|vq@T>FIXhyC%Ex<2wQ(qqNH$C@|^(^-;@88{u^K7 zKlmD3%8zUPL|C5RTK}SS3-i1q?;HMXdZ7GAbRYZfh)G6-eI&&K`emncU|uYS<<#eq zUxqG)wIl1rrAk`9KTb4fGd+ghL~p=J)?YkFC7-26{90bzVE@dGcbIXP-ICBo61B zfq#&H9>3G4z4&AP6Kuk7h;=cRb>m|KtSFv{PKv28ExwKUu#`FDSvRe@T6u44jtuv^ z7QVG4?5h#o7@K2!@ukJX?_rCvtN4q>q5d&05dWPXEN?#l9RCcS#%$J^D{loB;y<;o ze)N+s!#@7PgYtWbzvlmo5$1RU<6=CFkBKlf*3~bHKM&5$Uv0g({Lkc_u%BPCDh`w1 za#WbREfy7zi*Ya}#=v>_}l1J z^a}jR{(i)Z@^0Z&{v&#ny4Q3<>rarEk!~k%EWZJr%;)(4=l+N1{Ih@2Z7nXw`MA|R z+J@V42j29ays+L~`YZL%=mYY5@Kaeo6K2PJxJzC^I=c6Al|FN@xBj1CAN(9&=`&aU zD1H+C7V!U+cOMt>@6mU0G5;DpMZXz18-H~kN90$qkDbnc2X4pB;@j|o`a9~+(R;)f zs5?miL?5N6(kJNC>Mzh2@uB{^i+jv{wTbO~L3NPvxpN@y!^y`H; z)DNcrw(hs|M4XGK#n;e3`+2+c%J6=_hwrWpddHyfIdTfWNEH0DbTWDO>1gyb`qi3{ zA7yap^O$bz=lzFt1G+xGAwND|k+)gj)co?+>!>cj_*Q;Vx*{&(FT`s6ne=p=j19zF zV;k&Zz0Np|KOH;qE9+AccjGbp*@qMCr!zg3p6k4e>(@-Y7~P0&h_$dfmdA2$}3bvoO2-uW_*a0`z-W0auAH!=<!Qc*awGU zdih74`&*vRR{Pw7JN)_WF5H9fdOr%|5q@s^0(}ir^HX3#d?@}DUt)xKl!4*>XhFY0 z{~)g;e;uAM_d@zOeGGr(Psgd)KC&N<=J%q9VPF22bZ>ej{W1M5{XL#?&TpDO1x{TT zJ_kC`J+L1R!OwAweYAA{w(*Dai|bbm+sgaf`hUrPL|?(ncn+tjzlW{W)x)d&OIXf2 zqkLgKt6KsI*uL^x?*KHbcEl_mRWC&_zCgDxQf3LSKxA7hEwD(p=Z*w=$~*7e<~d} zad@8J(cj{7d0TKWe;^*`r*xkmd5;Eq&I?zEzVmSwHW(7_OCy}hZ%((sas1Zwhd7!) z61(vS(4W#NypR3qZsJwwq~bfw{T@G|{lv$(_y$J9r@p^l=^ImhVtf-%i~ouTF}rwv zEPzGv9V~-s&AZKe^(H+|JPkiRUho`F<96JJTX7>cRo51m^V`!?>5=qTI2nhC55__G z8poRRyz~Bt{uZa=d~D*J7SgronpgwZim$^G{Gxb_e+jSRb^HS#;a?b`KHlYUkI(w^ z)d%r|-qSJ{eI{_iry3_tP_u)6L<0(%X_JR z1Mvg=Db}fr^)O-i@b_~Pp9%fr(o^(}&2KJ0D*Z~|KXA7EDC)29zg9O6C*WD}Q#ga4 zT>t9)*7or`-a8fMJZ7IKth=B7P5c6$!PHH|c^;w9s>{nSf<^INTq*xOx-3@3d**6^ zxABPnAJFgFPZ{jX?}r!6zgOM9$bI1yd57o)^kI4(y&iw%@1u|68GLGAEh6{h{7Yl@ zv*DcI_dJu)F&l?-jD@i=j(8mUO^nKqf)Uu=e3|8C!R+|NJ*Z{<2lVYmVf{PwP5L@^ z(ti@&if(JYd69Yg&Zj%jTj<*AcF;BH8dx2xVN3Pp=|k!Y(Ep>en!B=no~C=@7v^k3 zx5j+>H>Q(&PG8Bd#4nE-#4}<}EF@lp&QIsVcOvuYK6nuyn0q+glkSTHaSV>dDYz2* zoBK2TR=;!NCGB@CzXbg?U7Q|Ge~HETxAhtA+`G8vy|A(Ot;LCO&l9x>_bM$`=U2gO z`~q|tItQISG7l@q4SiG4Rp{zi18ZVzd2#iv#g9dI7jJLwrOm^=yaG1 zi^?yE&E*#sFM@UXwXiI|64t~?;=|1Q0?X_FP`p0fz}!3J?ZjVjAJ&$Cg5IUiHr$F; zvgeS7PL6M4Q}M)fb2=`aL;tS)-q;6kn&WHw zGChGlPM4y4I`0y65sYP>AFVrG-V}N?eu*o^2h&gKDEg(uRG3cx+;kr7>zwn_`Stsh zUzDGVZth<8@cCZFzlZr{-Ehwz{TA-)Sb7}(fH%aK(kpQluECP}Zl!nO2KDQ3Ev~?2 z_%9w&7xiM8s~epiTl1S?E`A>DXpTDKHL(W1E3YC}#unPIXs0`#q&A0_VkCiTi;C1xvRSO@k4bdo&S(J zVIL##OY9_XpnjX=|0q5KXX0Aifj!js#D3UAzX6f`aRh&teTj|;Jccrh##seR8Bq!*dLzPf)Kgt=Gof0K6sPv9{;iYw&r zqL(H~sf5K__+I;!woS4Y(L5XpIe#z*Rmb+U z`oEp;E&Dl#Kk$FT`M3Z}$jghH_&e|y+>2Q~&o|{Kz*FKe>C5yTT_3el707on%n zhs@CrAM*#&gK;X(!Fjj@52#yCufV^Culil$55!+%OnqZvP5IR@F24+&gD!+cFpqeI=fB&2j+rBhdmjU1V_kW<=^|K& zUjVaX9r5IJB20*JF%Gu3?=I@PVQ=guZ@#=i_{6@piqGM1px5FG{7HNUF5#cG|M~Pz zeNW*O{up&%;bJskBg+1Y3p2bPt|Ks$2EG@q(?(`hL zlK(!xDee&;CBBdTBJ%S^UI*-gKZy6HOTRX2D(J8R@zD&cRgt zWAc9DU!X7HHN1`w@uhiQ&@s)qSfAwL`bf}ODwcEEPn7Te%V z{aVnABenZn&hxB@SNS*bKF;=k$kfC9Q|T!<5ueNd8^`fq&`~;t`xgu2U_4BU=`jOd zQlF9TXpZCj0^ZZS*pZ)!?n=j}TdV(^|Cc!z(>Lf#cn-IV@5DWLI5OXJ`$+$b;^m!h zF7ubd7x)jp>AgsW8}!RXzm55Ejd)r5TkEXk52Blje@f3YUtM~*_((j#FK({i=o?s$ zUlpt4Abkg8Lw+;-2)_{TO6PQbIq(Pm7+~P=1KdD|nue@k&Lf?)24Y(Y$iZ7sZ(ih@}x$@C>^}CL} z@CzJ)zo;vFG}IrUi_+8Ot;O}Y0XJg``P=BYbR0a+Kc)XA`UbX&T+hC~#-bR<_jPtU zD}Lpi)6;1%HKxSv&SgKw;77+-zlQza5PwYHr;}KJkoCUDiRz<>SE3)==RA2O_4!h~ z6kQt2;}G$F_$l_rUf5TDV|pn41=i$8n5!~f5mWIyI{!vE#oR0XIqeqQgL`owZa5as zZ9T5TbK>W5C4VXY<6Qm_e}E5hg1qnXGJc2i$J zy||bf(_;qAiIdfBF;`M^JT~tP>rKK>#GiSNJ?Vw&pYU_Ze@GXn8^|wBSHjxZ1bbs& z9Eu}w6pq0uc-YVB8@Q9 z_!M8`UHRkGr||pU6!DbwMEW~?+Ahrd5~K3t;eB)6z}WWN%R1%d^`n20*N*=I_80#Q z2jEL{FHkp1{#5#bxzf|=?V}xjfFEKf+ zqv$c%7SmxHY=xOHD^7F{#px*aS%NN!W$}vnD$uc;6L)N(oyU$I{sy!MfJ^t(bXle|L^aI z^N!1(&>)=82!1Zl@rrZ2jH%@JmX}z+9&~4Hi<#sX&@T&pP`|k9_tLA>ZNYQ}!(4CS z>15%)+!eoszhO1|NGSgT{}?tAZ-K3`Ek>w&Y@KcDwqh@No9M&t!EW;(5|1Gs9iw;- z(IPdzQvVXuIFA?fGpykJey2Zjj<@J*coi>T4(sN^nAXjy{-t>n@oT%kNBNuWtEhNh zb@}P@@^a9H#Z%hHBA;U=_{Hp_Bz;%?TzMtM|KLBszcHr1b=?2TxTkTrCx`JwhHy`6 zrVKp7kMMq+q@P&tB7F&;pR=6`vRRy~_WQzYCk2uaf;d z;g_LHVKFSHUoJW)R^<=3zoh(@{7L-j_z^$8yjZwId?o&C?l*9n`Jy@Zhx(Kke@vIA zpV1}dm%$?9h4Hn#M*7#rx5QIp1NEhx+hy-WsM1I4eXuO$AV{A>J7*1JRBQ2z&=L%gB7UEaquKF?G95#_)8JnhZ!zD>tC zb;IZ9EP6K1$7Q(uQK&DQDde9k6u6L|N}m<-7w}in$Ke@OR=K+=u(|bL-VLe;vFae%Sk0QUANv9igrc{}BHx{unGJUQ*wJ_SuJ@ zoBt`lFBa6V0QQxiUH*0bZ(>&d9eTWTJ(NA1M=X5~)6XA<=eEjv&(-y?PHQZyu9Lhm z^w08(@wd`Dty_w}jV?>Cqbtw{)m5br)9tKtl5S16!j{-tU0(ZtU|;e64EsCh`JJVQ z%8RRSJbYa{oKq5dkNhF>chZTSOA2{g`0?GBjr3~FAa5}}K))>Vuk*9gH|f_&qW(8f zg~wqZ6U{f+{hmS>7oVW-IJ~MppZME&-+6S<=VyHqi$7I&Pu}13etBoGx%w35&1U{w zSd~AF{sNmhkBZ_g=$7~%Kc)VY)#Y>U1;q=|GsWMbi{S$PLQJb}Ae|j+@ylEPZTz19 zuDn5XWx5K!Wxf95J+TX}@V=GNw}rZP*wyoDAwR2rjp=gg>e2~)UT<{oqb3daB;SK@ zPZs$7X+GwtAMSNd@oO1_o*|xJd^$Z13-OELALc4Wm&OV5>(GD7J8zwg{724Vh5W+i zxn=(I{G;{4d?)A&^g#I+={|H%yv{#h{SWyM%&}X)Q{pkr6%R|w&+PZkg7i3S#P2A7 zi03d6|FOR<;Am>A25m%}%_U%h-U)YYfDczgZ_c)?s%Kx{9;%f$I08Le`)?V{IYaW`!D9) zGhs1)5&Jo79~ba9ynE-HM)Ai)Hm$y#* zBYGHiHD7Q11pDANd7sfku!;V|=pXd|o}Nliq-W?eJ+fcqdnRu*zpr!ogidHbO|U-Z zz~=Jrd7i)PSHW}1D6b-YL0)5ZujSXL>&x3O@4okaC*54UHMYeMurQ9ZzbEQ$=~LXk z{&X&N%=erwB3_Aqzg$lFRkl2=FFX8s@i`?#84Pu^nsuJ|nahV`!FkXB)i2I@x9b+NL# z?&4`$hy1h{Rs3N3;Ai4z!#tQaXNVW1A6*X5ZHm5s(C>&B$I0fLh-Gqz=T%O8w{@eN zqXNdoH*s5JJ-wAKP2aTNE&QMHZR_QdmlN~x|5mqF{y%gEdFio;{8jQ+Vm$k(=3duS ze_GuHes}l18-9#ueg6N3Kgn++{y%;z`ab;!u9F|b^VvdI_5B!={|mp0K4a;E-pg<3 zKYhN`q(|s;g+G*TB0h*-s_zmkqHkf`Z{B|DKEnh2gLnuFsq3QuBkMoLQ_lB2@eBGz zw|*}7GAbPf^YLG(e}+%-2|mOJ7|S~M>3et$FXJV=h_Bs~IMy$%PkM92bYFfme<|@x zbTRri{VrV;i(nzlVx5QbV??flvE7H*baeMR4xLq>2y?~3L%t72`rf!szs?)+-(R~@ zh4=apX1oG^acI)UFi>eKP*#qR3@yqF>EZ-@B{nBxNfJeJdEzq~`(f&WJ8aIVLk z-v>=Y-^KK7{FqD%tA6hs zLPvEkQhBaD+=FiTOnz7TWBiN%H@%;MA!s>cP^Jb zhnDk`_f!l_*c|r)2F6=HB|pVT}6Ic{#%%b z|EE4B+?!JPuDtm2YFjrJU6ZbX)v%8Git4N2GxJoVo5>sO{tw45ycf%xMf~^I3QXhk zef^E_Is44d^G|V;ylt3Xeg=Fb?;h@zH%-3|?n7Sr7v-IocO4gDUv&%V`S`u_O!dDo zXCnLQC7zIL2q<>vK~47Zm%kGG^84Tj z`&%pCgTI-cVx6x1E&OfRg};ODOn-nI)kiq*Ire>yUygr~o+e(>d6&TASWSK{EXuD( zZ*e~w(v7hRHpOOGP<>7;hnw^{W3J-zW8(nl7MCt%za7JcjD3FAwNaD zkiUVy7E|-n;8Ok~oQ-c)2z{o}8Rbu*n`RCDbICi&Z@|A7H^d`Kgg)c#qekZ7e@~Z_ zKZ$;*?umUY;P1^6`Xq`H>R-$I7pv>DL;f!Lug&!s?}^`4x7j**?XR~!pW-O~?SI4f z(RcJs`hPgrIozNp%ezibG0zHlzwr;?cK!|=Z2fQ4<#cY@^?k0cyS#VRy(@2^{Vue> za^e-SDpteB*ajcEIFWLw;9! zwmv=RUO0n44L{?*Z;na)5&SQ4B#y^^<{cuxAKuodceXH36!(4!e;Ic19Cp#2=#H38 z|2FDBz~|3qFbx|Qc~#63TO9?%&AXDf+iT|a({cw@F zUsnwK>cQ`dbJewr)bi)xY-}K24^vq`EiTn(8BSDp&$=Dt9TjgNUKc;Hzuwp#J79Hr z)vzL7&KCCdOy5h^DJFiEzJ|X!uWI^6OAyZQu6RRrH^dv!-_YeepWFJJ8}ax)_hzgAO8yCR#1W5ezNzvac`n)L47k&KvQ>V4`@igYJyX}5zg7Mr z`G@gWTrR!{JE~h^&YAr4@_)mr{0X>;pV^%I_=oT#n%^xM;0As|I-}UxTYKv;0Kzm-3h30{mKhHvNZtIg8$kGclocKUH^(e+tjwSv-&N)g7h};sN|0 z-o*X55BK6P_z)lC9^8$C&9~n<9Jj9{*a63ix1gKj5BzC39Ur(iQQfos);WlWu)R5c zrB|zurfwa5Prv5!f0qB;_t9#4u=phUusQc*BmI7%XUdz6W7Lnr_VP#2U*O05uGkZ2 z==;iC|KJGzAob7eZ@v2-*L}YbExhkl>~~3#HL-y=n>zeT*S_(^mBkU7lNTfCz8xM=j?m!V5wC3!W>Q%k@2@|%grqN8J5 zer@w~r`xITMc=c(Zv0#HC45i6t?~=&m!w=c$7u2%M-B5Ybq?9Zv&hd$=fSJ;&tftD z9Q76GidY3};xu__^l!jl&+lcf&2&zANA2@{=h+-j@&6~krTXT0DofP=Hhday%P%ed zo4PjoMfLN=ul&Oplm7CX5Qe&DT4h4|mrT}ywh{u|uMpMp>1HxQq|k53Pw-=vdc3Os0@1K1%;IPdi0!_?0-XDd3ny?=oJ(%JQ?BYrVQ0MMHfma}>o^;(6rf<9FaE(l0S~ z;x{r!7dokUGRzg(&$@ZDhkd6K&t{#s#WT=3>Ec*L{x0hzs~Pr@68npf!ZBFSc}%8@ z(gm@Nc@~K;#(70T|E%&-V-ie^Ev+BLK9kZ_^+`lGvCa{7+p(6st@H+5gR5~R{)p4@ zt~u{Jms|7%@nn&6;TV1lbH&8o=IBP}lV4BY^PbCi&trY{a6Z-LZKi+5U5UbTKB8_H z{|og)@eu!49LPULpVH?HeHMGjYw!M@l{b|?gZ@mst-5yD2@52**1syhI#vre`P(vu zypz^HgRR7$$bVn|vixiE3e#8gACIZ|#np}GpX2X{T#r75NAM7KRaZctPv}0lUET&v zZU4z}h`i4+DSre#3ctp0-2W8%CC6g5!#T}#UX#o-8K>Y6{+xN4bDPDV6RB}JPQ&H$ z+Nz(x?_=F&{P*!Y@eTA%=Q+!KIn`Z~7tKB{&`ad?v2I^HCB9fZp+1Rln)A71y`=n9 zI9i`w`pnlSi}()yef57m4fi;&y6fgF=<{c)_!PYCbN>oHjNFIkI$YjByeqG#_;K&g zeRaR%So8Ey_c3-=cSYSGd9U)-ir++^qVzTU%uZ*(6y{1|z3S?cidUjj zikGFcsEaMHhtK`4c)|C@&o9HhzvlbsDz4!#$0fK3=U}%g;q$0kwy6L8kHP%U_ycet z4#K|jhSFF4K5*9h+r&HLN%3ECAuh%@_4)kWFi#Hi#B(nm>YGVk7VIg1t3KW6LgKsl zd+-~rC^zWdF&i9bT0lj1GJZ@dWSok08_>%7LR;?b*yeN;#o&NZg|1L8X{p}g(% zHhhzx3?tOPekb%@A#a&^lZv-C=Y8|MYyBqt!W@P-AlX^)^-0Mdw(BdLoAX#>_6|{;l96(d2n{M5Krdw|6}i8 zS@j9zy%*Wv-09_Kz_{`{tA8YKhyJ^;kv{pbF*e1K`t;MMFMZiQZ|K`jzYf?H>&mZ# zwXqt0F7JVU5AjR>NF0ro)V*)MQFLDV7kPD^!(YBX)B3$A9gg*TaXopBF^_l?dVsuU zbbtDHeOvNNsH=?E#GA;!OwXkAm^YF9gm_>4xP6?!Eb`CODd~&!HH^=XhjB3umNoBl z`E5Mcf9R^>OU?1h+{3*Wqn-B{oWZZ`bA5q+@6q46A7A@^8;65D=V|m$SV&!doX6j0 z{-tzQ@fGxX+=%Ps_qR?G`Tgi`&2?Yi81YfqQr;c$A@b|$-&wo`eOcbe{O;IZ{DOFM z{hMH8>>+QF^Q^+(!QW~9{q$DnzXg+ce%q|OmcIsR1&*kq@Hym<_uH+`C`yFkDFL6|$2^=g>+GwhDd)HQStOZ44sA6>26)ci&D`&-^Ab;spb zcRs@~zWr5}|EKw;^S^R_5A}^A@2q~C_;2%Xt6%BfM77Uj&Z(>OIir7H`j-60^fd9f zd7}PzP`C6Q#{WqE4NR$j49}^$xfb?+&r1- zUE;s#_p|d^Yre0{@vr%pxVIbhDXh;k>pgMq|5H~~d^Y_O`#G<}`qtHN3jL0{QPx{# zu2T9hGjD#+@2dDR`4hyK+DBIB)6@OzB;L&aPpE&UeuVt_<~nJvk^IX1G;~69mC(1Q z^EkloYTuX4+mG()95Q+jiqk9IhcEei%@->})QJE8>wEL8j|cLW=s$}dZO%6QR{H;Bo|Dd}oIb6^H;A7Qzu_EiJD17MD?1jo zP9OD8tY6$ckEc%=tZn|M&Zn@tl;-SZzc;Zbj(0A9=<~{4_vs?~95>H){a5hkm}|ZL zz2}}y_x!%oKdSk5tNV-J-5kfPmrwt!`iydp-}2Y!Gs~O{tbffuC+QP~e#3btr4y@f zAnzOg80*Y1*RSfL^GDL9&EL(sOVuB;{|WpC@(P(dhrThbU%|aAM-S4cV&pp3T_C>F zc}}wL75rlI6ZqWiZ`~7~S5|$Bnd4jjBm3{8Pk-?tbV2cH_EXUM{q*}zeop=|>;56X zz5V6W=K$^#AK>}^VE%8MPq{WxBL4rch5kOu#0>w*hkqCJ@?Lxq{ATXw_9;Op zd?&1%H%`b)St|IQzY0tmCvb0pkXOY2-$Z54?XthGzpZ|#kD5AgK*^B5i=VJ`@DFwh z{k~fo^gkVg{`ykjiP(V?$A|c*$%DS+&vC9N4St{b!CzV+=oJOSdQ)BmU8Zb^N41}2 z{yCzv9YTEJn!tvihP))s`DVJHj}!~>eq)19JvT5NridHjeHRA)FII?WsvhV+TM+SS z!Vs^VKXCKZz-%$YywmoC{Jhqg>Rt@~EBGgz=RVK<>dD|oUmg0?J{R=Y=E&sUf9YOL z_TQy^@_ESXVvfsn<%(gBMGHgxS&h(lr2RkN5_FSK0=tw8`F&CZUC_MeiUfbK{SCqE zr9dEfJ;54z&r5MS-TlRRr&(DPb{ z_(tzTjgdhQ@b_yIl?ij^=o$Q<*M_?2<<-9v`2LO%k2xyn2Z;kWB?x}qZv*QW4gFe8 z4Dk4+A%N-!|KCqOU`rEIwZo_YL}EpNAv-xmoTk!JjxZaBQ`}$w@-rWY>d^ zh!Oanxt`Pw@%4uS5Bcw=^qLj)`Tik)U!`y^MUw=*?5z-=k|!|YMDSPT47x?upjYd= zXh!g_#0!0HM+8=i2!0#;nc|&2}a7Jm1ak-~Z-?{OZF3w|bv`*c|9|0FGgU74#7Y8A~4OFz%}N1>2oBlf9|)#;ZV1^Z(zsF zfsLKhi_@Y0hR?%+J}27U3H~d8Kecs~1{H)&ln_GiF)#t^WlOev< zd8OYR;+K7HrOqF8L+A6e=a}8O4?P&_C#(;7*PL&JePn+p_+#P*wz?QtD0!H3d-qU( zXLj&E(|^OY;19kTxb}F6kMQ3!PU~}_mhaiV`9i;_2}6E|T_L}P`7Xx_{zsXEzuS6M z-HW__PE8y=ABXn5e%6d^xr;SjIaBlrdU zcL-B92zqtN5FhCO?`YxTpvU@sJV~+8XQ}^g$HUPf-q&+|_B`}S>T@sZ!=Qh<6!ISW zo=NYVZtMv09bW~G^7DO1pZ6IHh4n`HT)a0q^cmrN3sea4bH49m`h9s=#n7)~%#h!6 zUeGhX3c7gHpwoUF^usGbPks{EFLCf!ex|;1Smzh-b*odsKjw3yllMHTpR=A84t>t} zK74CO&{KW?{NX*n>VEhCH}u>1S6~O<%NdS_x^J2X|4Z-Ny4yh?DIMb7eQ$5~`F-2Z z`|(bMyfeOUe)T=mYjLRibykR%9uQc!eAwrPG(mTt|9>={cU;e3`^Q5nD^c09Wh;Ay zkc0>sAuAOjE3!xS9z~H5GP5$uF7vC9Jwn-pl9Z5fKOXn%+3%m%ea&;7>s;qL=e$4p z{)APV3a51xzTw^;K>xQUZxPhdI_?K8d&r+R{r6hD?6=nxHl3+Ba(6@<%0wp1dpmHW1x_cg%)Y()XdBC-D9(z&=i*9}X!XJAe9W4f;`oRpM{k zAU~(cbAHZ&qTD}^(wEn;F6X%a*t7p9(=S_;lD`d}@;8|E7`t2iuGpE;FOuk6hRdaY zjW~-nQJ!<^2=C32{CnQIE*5?MqWqpbC=BIZIGgjc=REO!=m(RR%C5yZ@$cBlf7&|H zVMm1p0)*AM&ty|yu0FEg&VAOesPw8(XKzkOesX}&n0-2o`$f=0=?63y9@s0r+(W`n zx5ZB_E;^;L=+2xgy?2Q|HB0h*nWAkupZ-#()5uGU8j=@#FZ8>B-_1gcm*St}{PoAr zo$kuZ`2VCg^OP`uq|j`G>_X{3)nmjT6)z07mE0sl7#}1&Pd(LGCcR${;`eHy@nXzG z54V!MOex`pLgF8H6jtTEpIUk>JKYGOd?s%r`8t~mDkvcZW)wr&l!_PPu?{lwj zpC-F*%&&Z9(S0tLQ8#aEG|sM@hbm`s#a0ewNG;|JY5@H9HH9=~qRl zCoA^z4g74pBfD|z(-xa#H<^BMpSt?9PyEH)uhT!u?gQ_bo}5qlBE&D)Qu;gjo^+i& zwxN%l;61(Liu7&TNWV>@=uxw=Xa5(wD%$3>upxc+I{R&Rn(UU8k$meg(HrTTg|>=c zxxM%m8j3zmAJ|I2nCC5iEOiw*S^9mr2W~wqy6hTZVe)1*Kz0+!SGJAlMx%sv>r21j zQqfoFL+0H@uP-RvKTvu+(+rx^-=gP=UxN2y0^>ifExsH3rXKTIJwW`A)P)J>NId=4 z6o0+?Yus@9_7rH3^|D_zRq}^tMcZ+%EdtAPZg%0`<(VUWCoAa(yb}GAdz$Y$(XaSE zX289v=2q!%>Y#n{m+#@mr^L77e7QPQ^yM)5ai@O#cz@MzA^v^(nSDX&pL-yF>yE;H zf5d;9E;@;GbmThm6Gn^w$U^iW`dmJ~m-coOe^jdU%FuTjQ~zJ|1h z{495spBJ2K=e~=s&AGH>sO+yT7r*in;SB1g0q>l(oL^V!NXgZauFe|0B77wOA$j_WFv)*huoX zA>!9(ot+veLO82FMA~V4)H~_6F-^zU(G|3`^Jd> zn>upkJ(X5k{8PLS_VIpu#{D9Meo>h|X;xYO{?RW^ua4nwvgmE3rjxIPH4ybE5TB7)4t;G;+-(ZR`i&3;nPdP2>NVW z`f-tu;;&B;{*0EtNf(9AeBau^{%uX2*CQW+%>Vc^>0jY{mOcBq1N}R@x#auEUl#No zzM~{@{|%!)wsuuKZ^>US{i5D{`SIYsQLvim2~VYONIlFUpTEP!|9oD0tA>hR4LUav zKZx(fvHY$!nY^|5A^D20N=$J5x_3BVndQa&;bxW#leFsR-nE9>$DEhUp za5Z@d;+)A162JRt`5RD4cx=7+QQVup68EW1k{@6n#?$v^Z4^JWmF!9)FKH_NboxM( z5uz(klAbO7eyqRvWp9a}og=*0Q&=>gwBe>^{tgU$`Ab-ku7da=6jg(z(1L3TO z!g6-DD21@=3%wk_O<$T<-P4ZK>WPgD5tjxV|5OvYzl;rU( zgkA2+F8+wn=A!R+Mf&|Giob$;c?A8( z%uD?1&xKap3%yKb=igT7@fi6=(Um(12W=8=;UZU^dw1kO@tYoyokM_d%L4IBOcsv! z5}GidHRNmmX6ZLzA3P5eeU1Eenku`=d z(tpo=@QH)ux%BZO<3xXC-Ttd6eLkBR*itV&xL-~hC;4#hUnefhz8rme^G?ajZWh1C zNMTf*_zmc*ΜNk-vQ0yN=PnuhHK|aNb?z-8j@kcIT%EYxI!+m#qIoPw|i1h@Z_q zcu)O%(NAwyk=|hTW#i7$Kh5`TJL>X4Z}D^HNdE@&uVO5^>i}V=8Nzwg@et0lE`wyB zf1%`~2aE2(yTg)qM71~K-%gWWE%r$qb-U16^3%lihyK!>^I}II$;bH$TXSzb#63Kf zbD$6VF@W>o1mgsek44m7eez_qQSqFmUsWXUpHFC|c&KgRG0<*Q3tbKNLMERQ>`|M0cwzIyG9j=a4Xv{auyuMxGLX8RNd` zE&GGNu;cH6%Chg~Wr%NDPI{fIs;`~oJhks2ei!=ms-x21K1uxX^s~L?#NRPk{GRMf zpDgiL84G9fJ{h-5v=M#m)kD!6>}3D)oUrB-p$Yf*)p(Xag%PDBe~I5&cSM)xUOAU@;vMHq7Zb^Sjf8v# zF?h=WzM2ze-ruRQykz3&st^U)EXpl=}Ch&d+c@U#H&JkvALm=Q{4&Ke&JY zAWyw3%U`|s!W3&^hlLvd_;exd(V!^xnqeh=kf+d{`|c_ zs)O`%=r@Pi#{rxhYw1VhGG#ygzHsqTVcIg;&p9Ua<{p^lD7gv#T`Noe@`(81jB|^) zyWnRv^_ES2{n;(MjpW6^UGy3DjSKsxA9dS=ckFcbK^t$4H~E?D&Q%m0jr~jV_kw*C zdRTg$cM1p25msj3Y+5M$dnw|7ix6Fucivdz{QnoY5?4X`>{$AJ3USRK|2x~s&nfof z<;9}^<36U{y z;x{fM+Le3$+0vptJ%oe%2}^d>JdvZ4Jj^pWGCUhS{nBTeoC_r4r9fyTS(Y# zj&KrsFSdye951X_S^nah3wMyuWcu1R=osX$_%4@_E&D6%$Ku;X@8^BAf#0vUbI$GR zDgV6>3XAf7{bnS)T>4+}F`_qfzs+FZ-?$@w$91v~ek^SJTKo_*(YLM&&AFcs-XnQg z>a$t8==z-BH!Dm39rvIs@Kqydclidh~4rUl@7qk6y)8>DR#DVE8pIiEo5oQ|7k_)_0bgiC;1P>z7}?E*dGO`zwj~|e?UQv z*PZ);PY?MuUn+TNE|P7iC!+=8&tX56rCz3Xliecr)m!cl-qhQHf0BDR%ifWC3TUhG zcRdn+KJ}gGBmFHB8#J&M9SR-C_-B`hKZ!hEo`Mh62b|LiBd(hL_H&ez*Zjax1?ul(VX9M_qs$Y)MTL8Uq zjp(n7ghj|}W5#U)?n{>3VYhH3=V`0rO3>qGin}@W(3N}NMb_ah=TCp^GONq3nT6~+ zeG!J7l>e;-McdH-Jg^%VFaAi@#q6c@KNc51-)7M+yn8!P{}-6=VBV2up`TBXU5#AX zU3e~Z?;yN7T=Heu#pCY<@0BRz&*8Vrl77eOLZ_kf6H{MwHQoU~!o>gaUAVuO(CLZr z{10K*Nx}s3@sM-*m$&$Ce}rGQ2o2MPEj=|}WAg6(L39!BEAv`N&yMw}#s2(7UYk-^ z9r!!WH_fDcBkP(unl85K?>p$GHny!?5VVvv&=_kYZ4zY#& zUbay{<2p(IH})16WH%Om;2O!Na=&VHOLBkS4gFt>-bs81u8GdT-|J1X-~2*o*Fo6H zNqV2SFUP+X{}TJ{@GsF%$a5TZwU56$7*0Qnv6r7`+^@E9|JZ#){OC~mDRocu@`Iu$ zbB;$I7JZGnPUP>UUh`e!hO6Y+XM_`03B%vZU;Zk>ZTrO^&%MtW{i=LVv27u_33>W2 zpXi&+tJi4JTgb<{E25|2$Hz(ZSoT#E_smOkHGbp$!io4<$M1f@oCC$_drl3dcb@nA znPB;~@)Q5jLeWz@iniqf``BLeO1^__>?6A2OzHQhZanC7M#TM{cqYw~eoCP56#KDL zLD>g!55CJe^8ADJzN`?QqmMk`KDqRm>>lyX{7nDt$M1N9OK)b7r!I*{j{t6 zW^iA2Gu6IaJWKqmw$gVX&zo+GzRbBf-dXzY#L?)7>?&dB)} zrDwo>dkKB8!4t{z!S6L!^kwR2sGI1Kvt?g*xiDv^_>;+#VNvl%eG^9Z5qeyeUJ`v~ zow4}d=p8ICde0K!Hap=E>N%5oYfm4kOTUlbD!t3xD-VWfoR|T^SR=`I5x2!e(Ho8m z15QXUjdy!kW6`7W(~EoRZSK*p>PvncSp|21*}H^{(4d$ zt-a-^=`x{(z~CeEPvHKr48H@1Yy2JUgyo61)B_owWWKWxO765+IHQvAU@hroPZw^% z-z)ldVd5OQTk^s5?FeVl6N$@wkm#Z{<=66*=x6*pS#w9xGa5^tL4Ibf6a8(eAmN7+LwHX=wT}UU-G+zdaGJc zd;mf99h_s$?#X`AQ^^Oi&r>;XZ*CIbg?D2j{r2BA*@b+Oyb1TfC&$FUN&oeHEcuNi z;x~COw45jY7WP95zh_=LAb#Lf>9uPl>|8|rE8LT6KN0=dO*pxY`geg5(yzBw{2|;w z)*cmq)&Swx%ffl9rFVw!_RBwuu3A@en=Yc?dx>_X4i0gj46ZD`Blod1);)<0UT2}? zbNk58JN$P4C4M8$N9PKXo6zTM21)*n^*mTe^z{Jgb+#3zMTo!nrs#z6!UN2^-2l=1 z{s{Ax7n(hk-Mfy;TS?yEn|aq-t(H8R{^?6S8B<4*3nX`7y#`y$&!vCj@3s-Xts?$P z>T~=u@rN4;3p7wXzv>Hp;P>PHbFP~7nlk>hy#5d<{w?ltDeUVu)8yyT8p(IM2)CaW ze?qh{n%|vV){D01Jbl6bZ3I1?zn9o+EI%F(gdG{*neXrJA@cM4w{R2suaZQ!rXKdw zKkjosc4EJrd@j9;C*{9{vFOVaL_Z_`cSV)YEuX}9j1>OnKGu|ewt;*7Ro1sY_4VSO z{HF0;Wm7-dPa7s2jD89F_9g12(Hz;i(wFwLFG^IA-NgjSH?Z#yj}qPdrsVtb?qw$8 zw`G6kOqBc(_x(2ZlAE#5cha|izmwi+)@v<&scs$dFZYsN?OmcHrV2ATpG(<`w&Z)p z?JVh686$qDEuvHD&j+~2hgB5co^#U0O8SNR2%B-Q*fB$TdpXA|_L96R=jXDEi4?|ulAyoiTzW`yLEJE=aBZ;4-zb87w-$!pIQ z2GZvz(!Wo&7XKIL!`l9`ryLEgaK62w|MjdTegE&m_9KOVstD`yon@nw;_>Evv8Rpv zt}iIPZS)Nz1JMSngb(%z4eQAMYGv6SVn2+@FS#T8uJbj~L#fMy+oa!So^UDs@C$Vn z%6-QHc`)~?J*;~Z*7L|S`88u7d)5>^n))lSS@bhgjWdOJPxx^0+f!HmQIbF495HDn zy7PHqN7gl&d8fR^Z@SQ#y#D2#@|SzxZT3&;6Y}H3IsC4R^5)C=X7gBb?|kytoAc6u zK5_k@_%`2!!3okoMc>-yFTN4|v>E4xLr3ZT?k;&EdCo^&1#mtk`$%4%b7~axJ)R_c z=lqJ-qlRb;?s-p$zrDBk=A7S=)bY$R;)nD8GpQzeWUj_*#{P)lJ!QF0{3X;;W$Gu_ zS^SsVghe~Z&#ckHbJ$mh-({NkiR{Y}HAN@f6Pn%@?#YqAw!XqX#P3G`j_54C&&(&2 zzeAiHDE%b*Q-1crXzG4p0oiSMEWH}spMM__f8|%E4)x&dgC}x?sNW}D5mwV zK%XDbSNgGhPku#TGUp!Q<0koz62h77g#KTJ?l!_Zwi<5+_o#v~qFeLts!cI`HJ%2?Sk+R z_f@M?qN88PF2qwfias!VrR3K99$f0UzwzdVJ?wUrBb~o(X@^ zKW4E{?is2sqd5OsJ(u2y#qv8pP4s>I)^!v=ko&7S@1~Qihb8;1Y%%H8V!yuNJ#poZ z_~p2ttz`V`Lp07f=2ekC5_wko(>n;`9tq#~5}w>3v>hq?_!Xi3i{|JT(l{*^ir@2< z`1Sbi6gX4#cIv++=RtS;wk;#Owd8q;t>{PmJ?k;zJ;psSy^#FXW}lVgKH8Cfv!DLd zpL6>>_W_#>* zVM?O-zMMBR@w0+=!lu)bkLBKVud?i1Ilq6>ABLGr?+pE_JoP`7dy8SV?85l_6x({D zGpUmm)YD_s@#{#{I6jqiA>5(brnz z_A{3LInE-$ z#YOx-SHwSDOW1?`VMt!yhf1&fJjSC>ZQ#55#x(K6=r^@2MVpY{@#Jlzzx*GKmi&8R z&EKJ?X!qBWFPSd7`*G24nSVdtmzj*07$+~Ct-F4@e9|`ymIP@zq_6ICyhj#4iUCu zy~C-;cGUHhX3{sIF78neo1V#Ta<=flJHjzng}d2z4LJw9{}BJ!ZTaiTcZ$2zVbV?U z4Y2zggrC7e&vBC5lD}e2MaNH*eE3Y^e|^Ls%{=pymkn;>hnY%mUK?S9`NC#=hk0)y zy~&)5;rMAp9#8SzrwaS?EBhje^WBv`zBEjJdOQ^_r*2vi&wJh@p|vINO&xAxJ)87W zTxpyKHQB!xcz2zlo~qL4?6`0KpfBz!A^UR~!juGIMR%b~jK=-IInb%N_?>r&pPC|i zDEF;}qmOP*drc%JXy z`QJ%igY_GIUh@Br2$!^!+<@O5pE`-}H&J}9X9hL7Pd%aThV7Po1@%5LP;|9DvVY9` zD3iLpV4?kVZI0v)wWL3Zx<7kMbP)06GLK}wt9|$@yCx^37rF{RZ-w(~%72B)k}v2c zeslV3*~OyourEGxuZTJ*eaGR#7OdBymeOy^-;wlcAo@1@?>75#%VWm5BRoeO)&GfZ za8`ad1c^R4OxSs;_%p@|dp;0ur|x&Mk6RYdyxLBb-J-6-MqkH1Ux1#}Y@z4%s~*jv;)vX@fk6{=Y0< zc5`Y73vLpY=6gw$muSCqVOjddQ_g{O>M(b%#(PYEDV-oXXpii==EX}NYs)>M*$Bzo zajy<*CA+@l@kplR5uEpN_e4i!3CrG;el0da9QEIw`$B&5c6qM!>vFEX<=$aNJ@`|< z5yWf3{VSIB>AgYYe4<`v@}63}Mf{@kgp25Vj{8JM?a;WDE(_gQ=h3WNS?=ir*=JV0 zr1ygRuPgiEOcVKQK1=c*+(T{1|5oZ|*n7#ZU6B3>&f8%6hEpB!ZFnbS+>m}Uze~O# zU%|xnig+Bp%g*t*us`3YPIVVuiu#+)KJM)&zo)xMK9BP@o&Ro$FZmByBzalR>j&3F z_bnlN18bozeW1?-(VKc`-$ktwUDiu>cR3GQ((nHxujh!j;Wp`2=RE6oQ}*Y)h2!Xp z=Qy8?=$qBs%PzCH#&!E3`n7@VD$)0c@^?))=}V;=OJ0zBA47h|T8b`JUwS1tM?AUr$8c}1l=n^~pYzH0>>{%J+edyz{1d%CN3_Xq z;ZN?}aoiuT+iTvr?3YWN54E^Y+LV)>H|xT+%-~i{@f|rQ4{=V8=bTv(pz$l85|$^v zO1_-+ zIK{lGk>B6W(yJXRTsv9%vk!<~a8B5Z{TIXj8^w9`k^Yg-U3za8$bJ}g`*W4}eb|?$ z*?%8`#W&!4&ujAHT~++98(2=`rbgH z75!lz>t)0E*MCVK%{+fBmHh(lF*yfB2h(@ga&CP5EWXJN;b{6{{@(KUmwq1pP4q?H zan-29+U&pO)U6l(Z(=u&zaQKFPWC5=C*-VXW9s5xkjC#aMEG)%gTwOP zl_}EeivMuFXI&~J{SL9h7N4Y7jrzXB_xV<@BtOeI->Bn#A=0;?U#+Cx4|4Aq%y)>n zw`5yt^xw=e((6n=?7+H?VO>Y??;6dCV=KQygm7-TaX(yBSbid( z2y;Uf$92xHA?%wR_RGrz$;;-QFGpopB)@P5b-jyur!13x6z5eA{buHS@hv#-40#u> zr@ni0U;NZv`TNQIhR}z`@J{rW+!JpEf zHAno{{X|z;F53K{=*at`PcIR@bcC=oe^+v5o#@4Z(z`rEv^#w{jdl4(+)>lzeftXs7_i~YZD)V?ADSm(Y z<`M3j!Ox|ayj}SBg!CMy3p37$Uz$9$;5~TfpZFP_6o2+r>93~WjAUP&=e|?pALBEx zKb%v`t;Da^S^n}9$3xbA^fbxWnoC}rzhAK<&LfW`-_Tz2Zq#useXBzU@qd?*o)dBJ zD<}F5b?ru9yv4rpFCe*DUD@}mu6cU1zs~)Z{B<|sw3*VIHCdQ7Uig9a>{(QF^9RyT z=_4G}1)Bf9OXnY=Z~vD5o3)~6$B6#qBkWBbt!pCs#!>10C@M6k|9R5)&UBMrBz07^ zy7c}w7vIxNbkC_md+vKPiR(j{^j_sip2YpIJ?D4JAjvPW&x`gD{o<@}>v-91A1f?d zUHm9_#{2!V?y5*(p&LDbY_g`V-~{hZNwjX zS@b@}H6za}uS$NcwB#F{L=S5x{9Q%-Z(D^S6U4vDzOP39NAT{uUR!$An@Mklspx;K zdykFcpWyycpL^cf#^PJFmHwbW;XzOFvrY?L>xzGze)pxF=qisSU&_0zI{Q40ds6n%^5Z^Fcrsc1iqWEnyc8X}L-Y(I?aP6LZD?M7{mTJvNwm&T*Ig z?_AmSwGjQbsptv=gz5CV-j<@B!-enulm0d@(JfYso=#s2ZY=(ky2{V90+QEwEi6f2 z?3XM0+&$_4{Uls@Mi|WB^^LnNJ)1$o`+FrH^HcQBZNkFS#Gh4A^xZq6ExETi7E(Nq zMo2!WyyS;o3fJ